Wala shell

Advanced PHP File Manager

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

Name	Size	Last Modified
📁 ..	-	2025-05-25 12:27
📄 alert.go // Copyright 2013 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 model import ( "errors" "fmt" "time" ) type AlertStatus string const ( AlertFiring AlertStatus = "firing" AlertResolved AlertStatus = "resolved" ) // Alert is a generic representation of an alert in the Prometheus eco-system. type Alert struct { // Label value pairs for purpose of aggregation, matching, and disposition // dispatching. This must minimally include an "alertname" label. Labels LabelSet `json:"labels"` // Extra key/value information which does not define alert identity. Annotations LabelSet `json:"annotations"` // The known time range for this alert. Both ends are optional. StartsAt time.Time `json:"startsAt,omitempty"` EndsAt time.Time `json:"endsAt,omitempty"` GeneratorURL string `json:"generatorURL"` } // Name returns the name of the alert. It is equivalent to the "alertname" label. func (a Alert) Name() string { return string(a.Labels[AlertNameLabel]) } // Fingerprint returns a unique hash for the alert. It is equivalent to // the fingerprint of the alert's label set. func (a Alert) Fingerprint() Fingerprint { return a.Labels.Fingerprint() } func (a Alert) String() string { s := fmt.Sprintf("%s[%s]", a.Name(), a.Fingerprint().String()[:7]) if a.Resolved() { return s + "[resolved]" } return s + "[active]" } // Resolved returns true iff the activity interval ended in the past. func (a Alert) Resolved() bool { return a.ResolvedAt(time.Now()) } // ResolvedAt returns true off the activity interval ended before // the given timestamp. func (a Alert) ResolvedAt(ts time.Time) bool { if a.EndsAt.IsZero() { return false } return !a.EndsAt.After(ts) } // Status returns the status of the alert. func (a Alert) Status() AlertStatus { return a.StatusAt(time.Now()) } // StatusAt returns the status of the alert at the given timestamp. func (a Alert) StatusAt(ts time.Time) AlertStatus { if a.ResolvedAt(ts) { return AlertResolved } return AlertFiring } // Validate checks whether the alert data is inconsistent. func (a Alert) Validate() error { if a.StartsAt.IsZero() { return errors.New("start time missing") } if !a.EndsAt.IsZero() && a.EndsAt.Before(a.StartsAt) { return errors.New("start time must be before end time") } if err := a.Labels.Validate(); err != nil { return fmt.Errorf("invalid label set: %w", err) } if len(a.Labels) == 0 { return errors.New("at least one label pair required") } if err := a.Annotations.Validate(); err != nil { return fmt.Errorf("invalid annotations: %w", err) } return nil } // Alert is a list of alerts that can be sorted in chronological order. type Alerts []*Alert func (as Alerts) Len() int { return len(as) } func (as Alerts) Swap(i, j int) { as[i], as[j] = as[j], as[i] } func (as Alerts) Less(i, j int) bool { if as[i].StartsAt.Before(as[j].StartsAt) { return true } if as[i].EndsAt.Before(as[j].EndsAt) { return true } return as[i].Fingerprint() < as[j].Fingerprint() } // HasFiring returns true iff one of the alerts is not resolved. func (as Alerts) HasFiring() bool { for _, a := range as { if !a.Resolved() { return true } } return false } // HasFiringAt returns true iff one of the alerts is not resolved // at the time ts. func (as Alerts) HasFiringAt(ts time.Time) bool { for _, a := range as { if !a.ResolvedAt(ts) { return true } } return false } // Status returns StatusFiring iff at least one of the alerts is firing. func (as Alerts) Status() AlertStatus { if as.HasFiring() { return AlertFiring } return AlertResolved } // StatusAt returns StatusFiring iff at least one of the alerts is firing // at the time ts. func (as Alerts) StatusAt(ts time.Time) AlertStatus { if as.HasFiringAt(ts) { return AlertFiring } return AlertResolved }	4.27 KB	2025-05-25 12:27
📄 alert_test.go // Copyright 2013 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 model import ( "fmt" "sort" "strings" "testing" "time" ) func TestAlertValidate(t testing.T) { ts := time.Now() cases := []struct { alert Alert err string }{ { alert: &Alert{ Labels: LabelSet{"a": "b"}, StartsAt: ts, }, }, { alert: &Alert{ Labels: LabelSet{"a": "b"}, }, err: "start time missing", }, { alert: &Alert{ Labels: LabelSet{"a": "b"}, StartsAt: ts, EndsAt: ts, }, }, { alert: &Alert{ Labels: LabelSet{"a": "b"}, StartsAt: ts, EndsAt: ts.Add(1 * time.Minute), }, }, { alert: &Alert{ Labels: LabelSet{"a": "b"}, StartsAt: ts, EndsAt: ts.Add(-1 * time.Minute), }, err: "start time must be before end time", }, { alert: &Alert{ StartsAt: ts, }, err: "at least one label pair required", }, { alert: &Alert{ Labels: LabelSet{"a": "b", "!bad": "label"}, StartsAt: ts, }, err: "invalid label set: invalid name", }, { alert: &Alert{ Labels: LabelSet{"a": "b", "bad": "\xfflabel"}, StartsAt: ts, }, err: "invalid label set: invalid value", }, { alert: &Alert{ Labels: LabelSet{"a": "b"}, Annotations: LabelSet{"!bad": "label"}, StartsAt: ts, }, err: "invalid annotations: invalid name", }, { alert: &Alert{ Labels: LabelSet{"a": "b"}, Annotations: LabelSet{"bad": "\xfflabel"}, StartsAt: ts, }, err: "invalid annotations: invalid value", }, } for i, c := range cases { err := c.alert.Validate() if err == nil { if c.err == "" { continue } t.Errorf("%d. Expected error %q but got none", i, c.err) continue } if c.err == "" { t.Errorf("%d. Expected no error but got %q", i, err) continue } if !strings.Contains(err.Error(), c.err) { t.Errorf("%d. Expected error to contain %q but got %q", i, c.err, err) } } } func TestAlert(t testing.T) { // Verifying that an alert with no EndsAt field is unresolved and has firing status. alert := &Alert{ Labels: LabelSet{"foo": "bar", "lorem": "ipsum"}, StartsAt: time.Now(), } actual := fmt.Sprint(alert) expected := "[d181d0f][active]" if actual != expected { t.Errorf("expected %s, but got %s", expected, actual) } actualStatus := alert.Status() expectedStatus := AlertStatus("firing") if actualStatus != expectedStatus { t.Errorf("expected alertStatus %s, but got %s", expectedStatus, actualStatus) } // Verifying that an alert with an EndsAt time before the current time is resolved and has resolved status. ts := time.Now() ts1 := ts.Add(-2 time.Minute) ts2 := ts.Add(-1 * time.Minute) alert = &Alert{ Labels: LabelSet{"foo": "bar", "lorem": "ipsum"}, StartsAt: ts1, EndsAt: ts2, } if !alert.Resolved() { t.Error("expected alert to be resolved, but it was not") } actual = fmt.Sprint(alert) expected = "[d181d0f][resolved]" if actual != expected { t.Errorf("expected %s, but got %s", expected, actual) } actualStatus = alert.Status() expectedStatus = "resolved" if actualStatus != expectedStatus { t.Errorf("expected alertStatus %s, but got %s", expectedStatus, actualStatus) } // Verifying that ResolvedAt works for different times if alert.ResolvedAt(ts1) { t.Error("unexpected alert was resolved at start time") } if alert.ResolvedAt(ts2.Add(-time.Millisecond)) { t.Error("unexpected alert was resolved before it ended") } if !alert.ResolvedAt(ts2) { t.Error("expected alert to be resolved at end time") } if !alert.ResolvedAt(ts2.Add(time.Millisecond)) { t.Error("expected alert to be resolved after it ended") } // Verifying that StatusAt works for different times actualStatus = alert.StatusAt(ts1) if actualStatus != "firing" { t.Errorf("expected alert to be firing at start time, but got %s", actualStatus) } actualStatus = alert.StatusAt(ts1.Add(-time.Millisecond)) if actualStatus != "firing" { t.Errorf("expected alert to be firing before it ended, but got %s", actualStatus) } actualStatus = alert.StatusAt(ts2) if actualStatus != "resolved" { t.Errorf("expected alert to be resolved at end time, but got %s", actualStatus) } actualStatus = alert.StatusAt(ts2.Add(time.Millisecond)) if actualStatus != "resolved" { t.Errorf("expected alert to be resolved after it ended, but got %s", actualStatus) } } func TestSortAlerts(t testing.T) { ts := time.Now() alerts := Alerts{ { Labels: LabelSet{ "alertname": "InternalError", "dev": "sda3", }, StartsAt: ts.Add(-6 time.Minute), EndsAt: ts.Add(-3 * time.Minute), }, { Labels: LabelSet{ "alertname": "DiskFull", "dev": "sda1", }, StartsAt: ts.Add(-5 * time.Minute), EndsAt: ts.Add(-4 * time.Minute), }, { Labels: LabelSet{ "alertname": "OutOfMemory", "dev": "sda1", }, StartsAt: ts.Add(-2 * time.Minute), EndsAt: ts.Add(-1 * time.Minute), }, { Labels: LabelSet{ "alertname": "DiskFull", "dev": "sda2", }, StartsAt: ts.Add(-2 * time.Minute), EndsAt: ts.Add(-3 * time.Minute), }, { Labels: LabelSet{ "alertname": "OutOfMemory", "dev": "sda2", }, StartsAt: ts.Add(-5 * time.Minute), EndsAt: ts.Add(-2 * time.Minute), }, } sort.Sort(alerts) expected := []string{ "DiskFull[5ffe595][resolved]", "InternalError[09cfd46][resolved]", "OutOfMemory[d43a602][resolved]", "DiskFull[5ff4595][resolved]", "OutOfMemory[d444602][resolved]", } for i := range alerts { if alerts[i].String() != expected[i] { t.Errorf("expected alert %s at index %d, but got %s", expected[i], i, alerts[i].String()) } } } func TestAlertsStatus(t testing.T) { ts := time.Now() firingAlerts := Alerts{ { Labels: LabelSet{ "foo": "bar", }, StartsAt: ts, }, { Labels: LabelSet{ "bar": "baz", }, StartsAt: ts, }, } actualStatus := firingAlerts.Status() expectedStatus := AlertFiring if actualStatus != expectedStatus { t.Errorf("expected status %s, but got %s", expectedStatus, actualStatus) } actualStatus = firingAlerts.StatusAt(ts) if actualStatus != expectedStatus { t.Errorf("expected status %s, but got %s", expectedStatus, actualStatus) } ts = time.Now() resolvedAlerts := Alerts{ { Labels: LabelSet{ "foo": "bar", }, StartsAt: ts.Add(-1 time.Minute), EndsAt: ts, }, { Labels: LabelSet{ "bar": "baz", }, StartsAt: ts.Add(-1 * time.Minute), EndsAt: ts, }, } actualStatus = resolvedAlerts.Status() expectedStatus = AlertResolved if actualStatus != expectedStatus { t.Errorf("expected status %s, but got %s", expectedStatus, actualStatus) } actualStatus = resolvedAlerts.StatusAt(ts) expectedStatus = AlertResolved if actualStatus != expectedStatus { t.Errorf("expected status %s, but got %s", expectedStatus, actualStatus) } ts = time.Now() mixedAlerts := Alerts{ { Labels: LabelSet{ "foo": "bar", }, StartsAt: ts.Add(-1 * time.Minute), EndsAt: ts.Add(5 * time.Minute), }, { Labels: LabelSet{ "bar": "baz", }, StartsAt: ts.Add(-1 * time.Minute), EndsAt: ts, }, } actualStatus = mixedAlerts.Status() expectedStatus = AlertFiring if actualStatus != expectedStatus { t.Errorf("expected status %s, but got %s", expectedStatus, actualStatus) } actualStatus = mixedAlerts.StatusAt(ts) expectedStatus = AlertFiring if actualStatus != expectedStatus { t.Errorf("expected status %s, but got %s", expectedStatus, actualStatus) } actualStatus = mixedAlerts.StatusAt(ts.Add(5 * time.Minute)) expectedStatus = AlertResolved if actualStatus != expectedStatus { t.Errorf("expected status %s, but got %s", expectedStatus, actualStatus) } }	8.19 KB	2025-05-25 12:27
📄 fingerprinting.go // Copyright 2013 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 model import ( "fmt" "strconv" ) // Fingerprint provides a hash-capable representation of a Metric. // For our purposes, FNV-1A 64-bit is used. type Fingerprint uint64 // FingerprintFromString transforms a string representation into a Fingerprint. func FingerprintFromString(s string) (Fingerprint, error) { num, err := strconv.ParseUint(s, 16, 64) return Fingerprint(num), err } // ParseFingerprint parses the input string into a fingerprint. func ParseFingerprint(s string) (Fingerprint, error) { num, err := strconv.ParseUint(s, 16, 64) if err != nil { return 0, err } return Fingerprint(num), nil } func (f Fingerprint) String() string { return fmt.Sprintf("%016x", uint64(f)) } // Fingerprints represents a collection of Fingerprint subject to a given // natural sorting scheme. It implements sort.Interface. type Fingerprints []Fingerprint // Len implements sort.Interface. func (f Fingerprints) Len() int { return len(f) } // Less implements sort.Interface. func (f Fingerprints) Less(i, j int) bool { return f[i] < f[j] } // Swap implements sort.Interface. func (f Fingerprints) Swap(i, j int) { f[i], f[j] = f[j], f[i] } // FingerprintSet is a set of Fingerprints. type FingerprintSet map[Fingerprint]struct{} // Equal returns true if both sets contain the same elements (and not more). func (s FingerprintSet) Equal(o FingerprintSet) bool { if len(s) != len(o) { return false } for k := range s { if _, ok := o[k]; !ok { return false } } return true } // Intersection returns the elements contained in both sets. func (s FingerprintSet) Intersection(o FingerprintSet) FingerprintSet { myLength, otherLength := len(s), len(o) if myLength == 0 \|\| otherLength == 0 { return FingerprintSet{} } subSet := s superSet := o if otherLength < myLength { subSet = o superSet = s } out := FingerprintSet{} for k := range subSet { if _, ok := superSet[k]; ok { out[k] = struct{}{} } } return out }	2.51 KB	2025-05-25 12:27
📄 fingerprinting_test.go // Copyright 2019 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 model import ( "sort" "testing" ) func TestFingerprintFromString(t testing.T) { fs := "4294967295" f, err := FingerprintFromString(fs) if err != nil { t.Errorf("unexpected error while getting Fingerprint from string: %s", err.Error()) } expected := Fingerprint(285960729237) if expected != f { t.Errorf("expected to get %d, but got %d instead", f, expected) } f, err = ParseFingerprint(fs) if err != nil { t.Errorf("unexpected error while getting Fingerprint from string: %s", err.Error()) } if expected != f { t.Errorf("expected to get %d, but got %d instead", f, expected) } } func TestFingerprintsSort(t testing.T) { fingerPrints := Fingerprints{ 14695981039346656037, 285960729237, 0, 4294967295, 285960729237, 18446744073709551615, } sort.Sort(fingerPrints) expected := Fingerprints{ 0, 4294967295, 285960729237, 285960729237, 14695981039346656037, 18446744073709551615, } for i, f := range fingerPrints { if f != expected[i] { t.Errorf("expected Fingerprint %d, but got %d for index %d", expected[i], f, i) } } } func TestFingerprintSet(t testing.T) { // Testing with two sets of unequal length. f := FingerprintSet{ 14695981039346656037: struct{}{}, 0: struct{}{}, 4294967295: struct{}{}, 285960729237: struct{}{}, 18446744073709551615: struct{}{}, } f2 := FingerprintSet{ 285960729237: struct{}{}, } if f.Equal(f2) { t.Errorf("expected two FingerPrintSets of unequal length to be unequal") } // Testing with two unequal sets of equal length. f = FingerprintSet{ 14695981039346656037: struct{}{}, 0: struct{}{}, 4294967295: struct{}{}, } f2 = FingerprintSet{ 14695981039346656037: struct{}{}, 0: struct{}{}, 285960729237: struct{}{}, } if f.Equal(f2) { t.Errorf("expected two FingerPrintSets of unequal content to be unequal") } // Testing with equal sets of equal length. f = FingerprintSet{ 14695981039346656037: struct{}{}, 0: struct{}{}, 4294967295: struct{}{}, } f2 = FingerprintSet{ 14695981039346656037: struct{}{}, 0: struct{}{}, 4294967295: struct{}{}, } if !f.Equal(f2) { t.Errorf("expected two FingerPrintSets of equal content to be equal") } } func TestFingerprintIntersection(t testing.T) { scenarios := []struct { name string input1 FingerprintSet input2 FingerprintSet expected FingerprintSet }{ { name: "two empty sets", input1: FingerprintSet{}, input2: FingerprintSet{}, expected: FingerprintSet{}, }, { name: "one empty set", input1: FingerprintSet{ 0: struct{}{}, }, input2: FingerprintSet{}, expected: FingerprintSet{}, }, { name: "two non-empty unequal sets", input1: FingerprintSet{ 14695981039346656037: struct{}{}, 0: struct{}{}, 4294967295: struct{}{}, }, input2: FingerprintSet{ 14695981039346656037: struct{}{}, 0: struct{}{}, 4294967295: struct{}{}, }, expected: FingerprintSet{ 14695981039346656037: struct{}{}, 0: struct{}{}, 4294967295: struct{}{}, }, }, { name: "two non-empty equal sets", input1: FingerprintSet{ 14695981039346656037: struct{}{}, 0: struct{}{}, 285960729237: struct{}{}, }, input2: FingerprintSet{ 14695981039346656037: struct{}{}, 0: struct{}{}, 4294967295: struct{}{}, }, expected: FingerprintSet{ 14695981039346656037: struct{}{}, 0: struct{}{}, }, }, { name: "two non-empty equal sets of unequal length", input1: FingerprintSet{ 14695981039346656037: struct{}{}, 0: struct{}{}, 285960729237: struct{}{}, }, input2: FingerprintSet{ 14695981039346656037: struct{}{}, 0: struct{}{}, }, expected: FingerprintSet{ 14695981039346656037: struct{}{}, 0: struct{}{}, }, }, } for _, scenario := range scenarios { s1 := scenario.input1 s2 := scenario.input2 actual := s1.Intersection(s2) if !actual.Equal(scenario.expected) { t.Errorf("expected %v to be equal to %v", actual, scenario.expected) } } }	4.92 KB	2025-05-25 12:27
📄 fnv.go // Copyright 2015 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package model // Inline and byte-free variant of hash/fnv's fnv64a. const ( offset64 = 14695981039346656037 prime64 = 1099511628211 ) // hashNew initializes a new fnv64a hash value. func hashNew() uint64 { return offset64 } // hashAdd adds a string to a fnv64a hash value, returning the updated hash. func hashAdd(h uint64, s string) uint64 { for i := 0; i < len(s); i++ { h ^= uint64(s[i]) h = prime64 } return h } // hashAddByte adds a byte to a fnv64a hash value, returning the updated hash. func hashAddByte(h uint64, b byte) uint64 { h ^= uint64(b) h = prime64 return h }	1.16 KB	2025-05-25 12:27
📄 labels.go // Copyright 2013 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 model import ( "encoding/json" "fmt" "regexp" "strings" "unicode/utf8" ) const ( // AlertNameLabel is the name of the label containing the an alert's name. AlertNameLabel = "alertname" // ExportedLabelPrefix is the prefix to prepend to the label names present in // exported metrics if a label of the same name is added by the server. ExportedLabelPrefix = "exported_" // MetricNameLabel is the label name indicating the metric name of a // timeseries. MetricNameLabel = "__name__" // SchemeLabel is the name of the label that holds the scheme on which to // scrape a target. SchemeLabel = "__scheme__" // AddressLabel is the name of the label that holds the address of // a scrape target. AddressLabel = "__address__" // MetricsPathLabel is the name of the label that holds the path on which to // scrape a target. MetricsPathLabel = "__metrics_path__" // ScrapeIntervalLabel is the name of the label that holds the scrape interval // used to scrape a target. ScrapeIntervalLabel = "__scrape_interval__" // ScrapeTimeoutLabel is the name of the label that holds the scrape // timeout used to scrape a target. ScrapeTimeoutLabel = "__scrape_timeout__" // ReservedLabelPrefix is a prefix which is not legal in user-supplied // label names. ReservedLabelPrefix = "__" // MetaLabelPrefix is a prefix for labels that provide meta information. // Labels with this prefix are used for intermediate label processing and // will not be attached to time series. MetaLabelPrefix = "__meta_" // TmpLabelPrefix is a prefix for temporary labels as part of relabelling. // Labels with this prefix are used for intermediate label processing and // will not be attached to time series. This is reserved for use in // Prometheus configuration files by users. TmpLabelPrefix = "__tmp_" // ParamLabelPrefix is a prefix for labels that provide URL parameters // used to scrape a target. ParamLabelPrefix = "__param_" // JobLabel is the label name indicating the job from which a timeseries // was scraped. JobLabel = "job" // InstanceLabel is the label name used for the instance label. InstanceLabel = "instance" // BucketLabel is used for the label that defines the upper bound of a // bucket of a histogram ("le" -> "less or equal"). BucketLabel = "le" // QuantileLabel is used for the label that defines the quantile in a // summary. QuantileLabel = "quantile" ) // LabelNameRE is a regular expression matching valid label names. Note that the // IsValid method of LabelName performs the same check but faster than a match // with this regular expression. var LabelNameRE = regexp.MustCompile("^[a-zA-Z_][a-zA-Z0-9_]$") // A LabelName is a key for a LabelSet or Metric. It has a value associated // therewith. type LabelName string // IsValid returns true iff the name matches the pattern of LabelNameRE when // NameValidationScheme is set to LegacyValidation, or valid UTF-8 if // NameValidationScheme is set to UTF8Validation. func (ln LabelName) IsValid() bool { if len(ln) == 0 { return false } switch NameValidationScheme { case LegacyValidation: return ln.IsValidLegacy() case UTF8Validation: return utf8.ValidString(string(ln)) default: panic(fmt.Sprintf("Invalid name validation scheme requested: %d", NameValidationScheme)) } } // IsValidLegacy returns true iff name matches the pattern of LabelNameRE for // legacy names. It does not use LabelNameRE for the check but a much faster // hardcoded implementation. func (ln LabelName) IsValidLegacy() bool { if len(ln) == 0 { return false } for i, b := range ln { if !((b >= 'a' && b <= 'z') \|\| (b >= 'A' && b <= 'Z') \|\| b == '_' \|\| (b >= '0' && b <= '9' && i > 0)) { return false } } return true } // UnmarshalYAML implements the yaml.Unmarshaler interface. func (ln LabelName) UnmarshalYAML(unmarshal func(interface{}) error) error { var s string if err := unmarshal(&s); err != nil { return err } if !LabelName(s).IsValid() { return fmt.Errorf("%q is not a valid label name", s) } ln = LabelName(s) return nil } // UnmarshalJSON implements the json.Unmarshaler interface. func (ln LabelName) UnmarshalJSON(b []byte) error { var s string if err := json.Unmarshal(b, &s); err != nil { return err } if !LabelName(s).IsValid() { return fmt.Errorf("%q is not a valid label name", s) } ln = LabelName(s) return nil } // LabelNames is a sortable LabelName slice. In implements sort.Interface. type LabelNames []LabelName func (l LabelNames) Len() int { return len(l) } func (l LabelNames) Less(i, j int) bool { return l[i] < l[j] } func (l LabelNames) Swap(i, j int) { l[i], l[j] = l[j], l[i] } func (l LabelNames) String() string { labelStrings := make([]string, 0, len(l)) for _, label := range l { labelStrings = append(labelStrings, string(label)) } return strings.Join(labelStrings, ", ") } // A LabelValue is an associated value for a LabelName. type LabelValue string // IsValid returns true iff the string is a valid UTF-8. func (lv LabelValue) IsValid() bool { return utf8.ValidString(string(lv)) } // LabelValues is a sortable LabelValue slice. It implements sort.Interface. type LabelValues []LabelValue func (l LabelValues) Len() int { return len(l) } func (l LabelValues) Less(i, j int) bool { return string(l[i]) < string(l[j]) } func (l LabelValues) Swap(i, j int) { l[i], l[j] = l[j], l[i] } // LabelPair pairs a name with a value. type LabelPair struct { Name LabelName Value LabelValue } // LabelPairs is a sortable slice of LabelPair pointers. It implements // sort.Interface. type LabelPairs []LabelPair func (l LabelPairs) Len() int { return len(l) } func (l LabelPairs) Less(i, j int) bool { switch { case l[i].Name > l[j].Name: return false case l[i].Name < l[j].Name: return true case l[i].Value > l[j].Value: return false case l[i].Value < l[j].Value: return true default: return false } } func (l LabelPairs) Swap(i, j int) { l[i], l[j] = l[j], l[i] }	6.45 KB	2025-05-25 12:27
📄 labels_test.go // Copyright 2013 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 model import ( "sort" "testing" ) func testLabelNames(t testing.TB) { scenarios := []struct { in LabelNames out LabelNames }{ { in: LabelNames{"ZZZ", "zzz"}, out: LabelNames{"ZZZ", "zzz"}, }, { in: LabelNames{"aaa", "AAA"}, out: LabelNames{"AAA", "aaa"}, }, } for i, scenario := range scenarios { sort.Sort(scenario.in) for j, expected := range scenario.out { if expected != scenario.in[j] { t.Errorf("%d.%d expected %s, got %s", i, j, expected, scenario.in[j]) } } } } func TestLabelNames(t testing.T) { testLabelNames(t) } func BenchmarkLabelNames(b testing.B) { for i := 0; i < b.N; i++ { testLabelNames(b) } } func testLabelValues(t testing.TB) { scenarios := []struct { in LabelValues out LabelValues }{ { in: LabelValues{"ZZZ", "zzz"}, out: LabelValues{"ZZZ", "zzz"}, }, { in: LabelValues{"aaa", "AAA"}, out: LabelValues{"AAA", "aaa"}, }, } for i, scenario := range scenarios { sort.Sort(scenario.in) for j, expected := range scenario.out { if expected != scenario.in[j] { t.Errorf("%d.%d expected %s, got %s", i, j, expected, scenario.in[j]) } } } } func TestLabelValues(t testing.T) { testLabelValues(t) } func BenchmarkLabelValues(b testing.B) { for i := 0; i < b.N; i++ { testLabelValues(b) } } func TestLabelNameIsValid(t testing.T) { scenarios := []struct { ln LabelName legacyValid bool utf8Valid bool }{ { ln: "Avalid_23name", legacyValid: true, utf8Valid: true, }, { ln: "_Avalid_23name", legacyValid: true, utf8Valid: true, }, { ln: "1valid_23name", legacyValid: false, utf8Valid: true, }, { ln: "avalid_23name", legacyValid: true, utf8Valid: true, }, { ln: "Ava:lid_23name", legacyValid: false, utf8Valid: true, }, { ln: "a lid_23name", legacyValid: false, utf8Valid: true, }, { ln: ":leading_colon", legacyValid: false, utf8Valid: true, }, { ln: "colon:in:the:middle", legacyValid: false, utf8Valid: true, }, { ln: "a\xc5z", legacyValid: false, utf8Valid: false, }, } for _, s := range scenarios { NameValidationScheme = LegacyValidation if s.ln.IsValid() != s.legacyValid { t.Errorf("Expected %v for %q using legacy IsValid method", s.legacyValid, s.ln) } if LabelNameRE.MatchString(string(s.ln)) != s.legacyValid { t.Errorf("Expected %v for %q using legacy regexp match", s.legacyValid, s.ln) } NameValidationScheme = UTF8Validation if s.ln.IsValid() != s.utf8Valid { t.Errorf("Expected %v for %q using UTF-8 IsValid method", s.legacyValid, s.ln) } } } func TestSortLabelPairs(t testing.T) { labelPairs := LabelPairs{ { Name: "FooName", Value: "FooValue", }, { Name: "FooName", Value: "BarValue", }, { Name: "BarName", Value: "FooValue", }, { Name: "BazName", Value: "BazValue", }, { Name: "BarName", Value: "FooValue", }, { Name: "BazName", Value: "FazValue", }, } sort.Sort(labelPairs) expectedLabelPairs := LabelPairs{ { Name: "BarName", Value: "FooValue", }, { Name: "BarName", Value: "FooValue", }, { Name: "BazName", Value: "BazValue", }, { Name: "BazName", Value: "FazValue", }, { Name: "FooName", Value: "BarValue", }, } for i, expected := range expectedLabelPairs { if expected.Name != labelPairs[i].Name \|\| expected.Value != labelPairs[i].Value { t.Errorf("%d expected %s, got %s", i, expected, labelPairs[i]) } } }	4.18 KB	2025-05-25 12:27
📄 labelset.go // Copyright 2013 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 model import ( "encoding/json" "fmt" "sort" ) // A LabelSet is a collection of LabelName and LabelValue pairs. The LabelSet // may be fully-qualified down to the point where it may resolve to a single // Metric in the data store or not. All operations that occur within the realm // of a LabelSet can emit a vector of Metric entities to which the LabelSet may // match. type LabelSet map[LabelName]LabelValue // Validate checks whether all names and values in the label set // are valid. func (ls LabelSet) Validate() error { for ln, lv := range ls { if !ln.IsValid() { return fmt.Errorf("invalid name %q", ln) } if !lv.IsValid() { return fmt.Errorf("invalid value %q", lv) } } return nil } // Equal returns true iff both label sets have exactly the same key/value pairs. func (ls LabelSet) Equal(o LabelSet) bool { if len(ls) != len(o) { return false } for ln, lv := range ls { olv, ok := o[ln] if !ok { return false } if olv != lv { return false } } return true } // Before compares the metrics, using the following criteria: // // If m has fewer labels than o, it is before o. If it has more, it is not. // // If the number of labels is the same, the superset of all label names is // sorted alphanumerically. The first differing label pair found in that order // determines the outcome: If the label does not exist at all in m, then m is // before o, and vice versa. Otherwise the label value is compared // alphanumerically. // // If m and o are equal, the method returns false. func (ls LabelSet) Before(o LabelSet) bool { if len(ls) < len(o) { return true } if len(ls) > len(o) { return false } lns := make(LabelNames, 0, len(ls)+len(o)) for ln := range ls { lns = append(lns, ln) } for ln := range o { lns = append(lns, ln) } // It's probably not worth it to de-dup lns. sort.Sort(lns) for _, ln := range lns { mlv, ok := ls[ln] if !ok { return true } olv, ok := o[ln] if !ok { return false } if mlv < olv { return true } if mlv > olv { return false } } return false } // Clone returns a copy of the label set. func (ls LabelSet) Clone() LabelSet { lsn := make(LabelSet, len(ls)) for ln, lv := range ls { lsn[ln] = lv } return lsn } // Merge is a helper function to non-destructively merge two label sets. func (l LabelSet) Merge(other LabelSet) LabelSet { result := make(LabelSet, len(l)) for k, v := range l { result[k] = v } for k, v := range other { result[k] = v } return result } // Fingerprint returns the LabelSet's fingerprint. func (ls LabelSet) Fingerprint() Fingerprint { return labelSetToFingerprint(ls) } // FastFingerprint returns the LabelSet's Fingerprint calculated by a faster hashing // algorithm, which is, however, more susceptible to hash collisions. func (ls LabelSet) FastFingerprint() Fingerprint { return labelSetToFastFingerprint(ls) } // UnmarshalJSON implements the json.Unmarshaler interface. func (l LabelSet) UnmarshalJSON(b []byte) error { var m map[LabelName]LabelValue if err := json.Unmarshal(b, &m); err != nil { return err } // encoding/json only unmarshals maps of the form map[string]T. It treats // LabelName as a string and does not call its UnmarshalJSON method. // Thus, we have to replicate the behavior here. for ln := range m { if !ln.IsValid() { return fmt.Errorf("%q is not a valid label name", ln) } } l = LabelSet(m) return nil }	3.95 KB	2025-05-25 12:27
📄 labelset_string.go // Copyright 2024 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package model import ( "bytes" "slices" "strconv" ) // String will look like `{foo="bar", more="less"}`. Names are sorted alphabetically. func (l LabelSet) String() string { var lna [32]string // On stack to avoid memory allocation for sorting names. labelNames := lna[:0] for name := range l { labelNames = append(labelNames, string(name)) } slices.Sort(labelNames) var bytea [1024]byte // On stack to avoid memory allocation while building the output. b := bytes.NewBuffer(bytea[:0]) b.WriteByte('{') for i, name := range labelNames { if i > 0 { b.WriteString(", ") } b.WriteString(name) b.WriteByte('=') b.Write(strconv.AppendQuote(b.AvailableBuffer(), string(l[LabelName(name)]))) } b.WriteByte('}') return b.String() }	1.32 KB	2025-05-25 12:27
📄 labelset_test.go // Copyright 2019 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 model import ( "encoding/json" "testing" ) func TestUnmarshalJSONLabelSet(t testing.T) { type testConfig struct { LabelSet LabelSet `yaml:"labelSet,omitempty"` } // valid LabelSet JSON labelSetJSON := `{ "labelSet": { "monitor": "codelab", "foo": "bar", "foo2": "bar", "abc": "prometheus", "foo11": "bar11" } }` var c testConfig err := json.Unmarshal([]byte(labelSetJSON), &c) if err != nil { t.Errorf("unexpected error while marshalling JSON : %s", err.Error()) } labelSetString := c.LabelSet.String() expected := `{abc="prometheus", foo="bar", foo11="bar11", foo2="bar", monitor="codelab"}` if expected != labelSetString { t.Errorf("expected %s but got %s", expected, labelSetString) } // invalid LabelSet JSON invalidlabelSetJSON := `{ "labelSet": { "1nvalid_23name": "codelab", "foo": "bar" } }` NameValidationScheme = LegacyValidation err = json.Unmarshal([]byte(invalidlabelSetJSON), &c) expectedErr := `"1nvalid_23name" is not a valid label name` if err == nil \|\| err.Error() != expectedErr { t.Errorf("expected an error with message '%s' to be thrown", expectedErr) } } func TestLabelSetClone(t testing.T) { labelSet := LabelSet{ "monitor": "codelab", "foo": "bar", "bar": "baz", } cloneSet := labelSet.Clone() if len(labelSet) != len(cloneSet) { t.Errorf("expected the length of the cloned Label set to be %d, but got %d", len(labelSet), len(cloneSet)) } for ln, lv := range labelSet { expected := cloneSet[ln] if expected != lv { t.Errorf("expected to get LabelValue %s, but got %s for LabelName %s", expected, lv, ln) } } } func TestLabelSetMerge(t testing.T) { labelSet := LabelSet{ "monitor": "codelab", "foo": "bar", "bar": "baz", } labelSet2 := LabelSet{ "monitor": "codelab", "dolor": "mi", "lorem": "ipsum", } expectedSet := LabelSet{ "monitor": "codelab", "foo": "bar", "bar": "baz", "dolor": "mi", "lorem": "ipsum", } mergedSet := labelSet.Merge(labelSet2) if len(mergedSet) != len(expectedSet) { t.Errorf("expected the length of the cloned Label set to be %d, but got %d", len(expectedSet), len(mergedSet)) } for ln, lv := range mergedSet { expected := expectedSet[ln] if expected != lv { t.Errorf("expected to get LabelValue %s, but got %s for LabelName %s", expected, lv, ln) } } } func TestLabelSet_String(t testing.T) { tests := []struct { input LabelSet want string }{ { input: nil, want: `{}`, }, { input: LabelSet{ "foo": "bar", }, want: `{foo="bar"}`, }, { input: LabelSet{ "foo": "bar", "foo2": "bar", "abc": "prometheus", "foo11": "bar11", }, want: `{abc="prometheus", foo="bar", foo11="bar11", foo2="bar"}`, }, } for _, tt := range tests { t.Run("test", func(t testing.T) { if got := tt.input.String(); got != tt.want { t.Errorf("LabelSet.String() = %v, want %v", got, tt.want) } }) } } // Benchmark Results for LabelSet's String() method // --------------------------------------------------------------------------------------------------------- // goos: linux // goarch: amd64 // pkg: github.com/prometheus/common/model // cpu: 11th Gen Intel(R) Core(TM) i5-1145G7 @ 2.60GHz // BenchmarkLabelSetStringMethod-8 732376 1532 ns/op func BenchmarkLabelSetStringMethod(b testing.B) { ls := make(LabelSet) ls["monitor"] = "codelab" ls["foo2"] = "bar" ls["foo"] = "bar" ls["abc"] = "prometheus" ls["foo11"] = "bar11" for i := 0; i < b.N; i++ { _ = ls.String() } }	4.11 KB	2025-05-25 12:27
📄 metadata.go // Copyright 2023 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 model // MetricType represents metric type values. type MetricType string const ( MetricTypeCounter = MetricType("counter") MetricTypeGauge = MetricType("gauge") MetricTypeHistogram = MetricType("histogram") MetricTypeGaugeHistogram = MetricType("gaugehistogram") MetricTypeSummary = MetricType("summary") MetricTypeInfo = MetricType("info") MetricTypeStateset = MetricType("stateset") MetricTypeUnknown = MetricType("unknown") )	1.07 KB	2025-05-25 12:27
📄 metric.go // Copyright 2013 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 model import ( "errors" "fmt" "regexp" "sort" "strconv" "strings" "unicode/utf8" dto "github.com/prometheus/client_model/go" "google.golang.org/protobuf/proto" ) var ( // NameValidationScheme determines the method of name validation to be used by // all calls to IsValidMetricName() and LabelName IsValid(). Setting UTF-8 mode // in isolation from other components that don't support UTF-8 may result in // bugs or other undefined behavior. This value is intended to be set by // UTF-8-aware binaries as part of their startup. To avoid need for locking, // this value should be set once, ideally in an init(), before multiple // goroutines are started. NameValidationScheme = LegacyValidation // NameEscapingScheme defines the default way that names will be escaped when // presented to systems that do not support UTF-8 names. If the Content-Type // "escaping" term is specified, that will override this value. // NameEscapingScheme should not be set to the NoEscaping value. That string // is used in content negotiation to indicate that a system supports UTF-8 and // has that feature enabled. NameEscapingScheme = UnderscoreEscaping ) // ValidationScheme is a Go enum for determining how metric and label names will // be validated by this library. type ValidationScheme int const ( // LegacyValidation is a setting that requirets that metric and label names // conform to the original Prometheus character requirements described by // MetricNameRE and LabelNameRE. LegacyValidation ValidationScheme = iota // UTF8Validation only requires that metric and label names be valid UTF-8 // strings. UTF8Validation ) type EscapingScheme int const ( // NoEscaping indicates that a name will not be escaped. Unescaped names that // do not conform to the legacy validity check will use a new exposition // format syntax that will be officially standardized in future versions. NoEscaping EscapingScheme = iota // UnderscoreEscaping replaces all legacy-invalid characters with underscores. UnderscoreEscaping // DotsEscaping is similar to UnderscoreEscaping, except that dots are // converted to `_dot_` and pre-existing underscores are converted to `__`. DotsEscaping // ValueEncodingEscaping prepends the name with `U__` and replaces all invalid // characters with the unicode value, surrounded by underscores. Single // underscores are replaced with double underscores. ValueEncodingEscaping ) const ( // EscapingKey is the key in an Accept or Content-Type header that defines how // metric and label names that do not conform to the legacy character // requirements should be escaped when being scraped by a legacy prometheus // system. If a system does not explicitly pass an escaping parameter in the // Accept header, the default NameEscapingScheme will be used. EscapingKey = "escaping" // Possible values for Escaping Key: AllowUTF8 = "allow-utf-8" // No escaping required. EscapeUnderscores = "underscores" EscapeDots = "dots" EscapeValues = "values" ) // MetricNameRE is a regular expression matching valid metric // names. Note that the IsValidMetricName function performs the same // check but faster than a match with this regular expression. var MetricNameRE = regexp.MustCompile(`^[a-zA-Z_:][a-zA-Z0-9_:]$`) // A Metric is similar to a LabelSet, but the key difference is that a Metric is // a singleton and refers to one and only one stream of samples. type Metric LabelSet // Equal compares the metrics. func (m Metric) Equal(o Metric) bool { return LabelSet(m).Equal(LabelSet(o)) } // Before compares the metrics' underlying label sets. func (m Metric) Before(o Metric) bool { return LabelSet(m).Before(LabelSet(o)) } // Clone returns a copy of the Metric. func (m Metric) Clone() Metric { clone := make(Metric, len(m)) for k, v := range m { clone[k] = v } return clone } func (m Metric) String() string { metricName, hasName := m[MetricNameLabel] numLabels := len(m) - 1 if !hasName { numLabels = len(m) } labelStrings := make([]string, 0, numLabels) for label, value := range m { if label != MetricNameLabel { labelStrings = append(labelStrings, fmt.Sprintf("%s=%q", label, value)) } } switch numLabels { case 0: if hasName { return string(metricName) } return "{}" default: sort.Strings(labelStrings) return fmt.Sprintf("%s{%s}", metricName, strings.Join(labelStrings, ", ")) } } // Fingerprint returns a Metric's Fingerprint. func (m Metric) Fingerprint() Fingerprint { return LabelSet(m).Fingerprint() } // FastFingerprint returns a Metric's Fingerprint calculated by a faster hashing // algorithm, which is, however, more susceptible to hash collisions. func (m Metric) FastFingerprint() Fingerprint { return LabelSet(m).FastFingerprint() } // IsValidMetricName returns true iff name matches the pattern of MetricNameRE // for legacy names, and iff it's valid UTF-8 if the UTF8Validation scheme is // selected. func IsValidMetricName(n LabelValue) bool { switch NameValidationScheme { case LegacyValidation: return IsValidLegacyMetricName(string(n)) case UTF8Validation: if len(n) == 0 { return false } return utf8.ValidString(string(n)) default: panic(fmt.Sprintf("Invalid name validation scheme requested: %d", NameValidationScheme)) } } // IsValidLegacyMetricName is similar to IsValidMetricName but always uses the // legacy validation scheme regardless of the value of NameValidationScheme. // This function, however, does not use MetricNameRE for the check but a much // faster hardcoded implementation. func IsValidLegacyMetricName(n string) bool { if len(n) == 0 { return false } for i, b := range n { if !isValidLegacyRune(b, i) { return false } } return true } // EscapeMetricFamily escapes the given metric names and labels with the given // escaping scheme. Returns a new object that uses the same pointers to fields // when possible and creates new escaped versions so as not to mutate the // input. func EscapeMetricFamily(v dto.MetricFamily, scheme EscapingScheme) dto.MetricFamily { if v == nil { return nil } if scheme == NoEscaping { return v } out := &dto.MetricFamily{ Help: v.Help, Type: v.Type, Unit: v.Unit, } // If the name is nil, copy as-is, don't try to escape. if v.Name == nil \|\| IsValidLegacyMetricName(v.GetName()) { out.Name = v.Name } else { out.Name = proto.String(EscapeName(v.GetName(), scheme)) } for _, m := range v.Metric { if !metricNeedsEscaping(m) { out.Metric = append(out.Metric, m) continue } escaped := &dto.Metric{ Gauge: m.Gauge, Counter: m.Counter, Summary: m.Summary, Untyped: m.Untyped, Histogram: m.Histogram, TimestampMs: m.TimestampMs, } for _, l := range m.Label { if l.GetName() == MetricNameLabel { if l.Value == nil \|\| IsValidLegacyMetricName(l.GetValue()) { escaped.Label = append(escaped.Label, l) continue } escaped.Label = append(escaped.Label, &dto.LabelPair{ Name: proto.String(MetricNameLabel), Value: proto.String(EscapeName(l.GetValue(), scheme)), }) continue } if l.Name == nil \|\| IsValidLegacyMetricName(l.GetName()) { escaped.Label = append(escaped.Label, l) continue } escaped.Label = append(escaped.Label, &dto.LabelPair{ Name: proto.String(EscapeName(l.GetName(), scheme)), Value: l.Value, }) } out.Metric = append(out.Metric, escaped) } return out } func metricNeedsEscaping(m dto.Metric) bool { for _, l := range m.Label { if l.GetName() == MetricNameLabel && !IsValidLegacyMetricName(l.GetValue()) { return true } if !IsValidLegacyMetricName(l.GetName()) { return true } } return false } // EscapeName escapes the incoming name according to the provided escaping // scheme. Depending on the rules of escaping, this may cause no change in the // string that is returned. (Especially NoEscaping, which by definition is a // noop). This function does not do any validation of the name. func EscapeName(name string, scheme EscapingScheme) string { if len(name) == 0 { return name } var escaped strings.Builder switch scheme { case NoEscaping: return name case UnderscoreEscaping: if IsValidLegacyMetricName(name) { return name } for i, b := range name { if isValidLegacyRune(b, i) { escaped.WriteRune(b) } else { escaped.WriteRune('_') } } return escaped.String() case DotsEscaping: // Do not early return for legacy valid names, we still escape underscores. for i, b := range name { if b == '_' { escaped.WriteString("__") } else if b == '.' { escaped.WriteString("_dot_") } else if isValidLegacyRune(b, i) { escaped.WriteRune(b) } else { escaped.WriteString("__") } } return escaped.String() case ValueEncodingEscaping: if IsValidLegacyMetricName(name) { return name } escaped.WriteString("U__") for i, b := range name { if b == '_' { escaped.WriteString("__") } else if isValidLegacyRune(b, i) { escaped.WriteRune(b) } else if !utf8.ValidRune(b) { escaped.WriteString("_FFFD_") } else { escaped.WriteRune('_') escaped.WriteString(strconv.FormatInt(int64(b), 16)) escaped.WriteRune('_') } } return escaped.String() default: panic(fmt.Sprintf("invalid escaping scheme %d", scheme)) } } // lower function taken from strconv.atoi func lower(c byte) byte { return c \| ('x' - 'X') } // UnescapeName unescapes the incoming name according to the provided escaping // scheme if possible. Some schemes are partially or totally non-roundtripable. // If any error is enountered, returns the original input. func UnescapeName(name string, scheme EscapingScheme) string { if len(name) == 0 { return name } switch scheme { case NoEscaping: return name case UnderscoreEscaping: // It is not possible to unescape from underscore replacement. return name case DotsEscaping: name = strings.ReplaceAll(name, "_dot_", ".") name = strings.ReplaceAll(name, "__", "_") return name case ValueEncodingEscaping: escapedName, found := strings.CutPrefix(name, "U__") if !found { return name } var unescaped strings.Builder TOP: for i := 0; i < len(escapedName); i++ { // All non-underscores are treated normally. if escapedName[i] != '_' { unescaped.WriteByte(escapedName[i]) continue } i++ if i >= len(escapedName) { return name } // A double underscore is a single underscore. if escapedName[i] == '_' { unescaped.WriteByte('_') continue } // We think we are in a UTF-8 code, process it. var utf8Val uint for j := 0; i < len(escapedName); j++ { // This is too many characters for a utf8 value based on the MaxRune // value of '\U0010FFFF'. if j >= 6 { return name } // Found a closing underscore, convert to a rune, check validity, and append. if escapedName[i] == '_' { utf8Rune := rune(utf8Val) if !utf8.ValidRune(utf8Rune) { return name } unescaped.WriteRune(utf8Rune) continue TOP } r := lower(escapedName[i]) utf8Val *= 16 if r >= '0' && r <= '9' { utf8Val += uint(r) - '0' } else if r >= 'a' && r <= 'f' { utf8Val += uint(r) - 'a' + 10 } else { return name } i++ } // Didn't find closing underscore, invalid. return name } return unescaped.String() default: panic(fmt.Sprintf("invalid escaping scheme %d", scheme)) } } func isValidLegacyRune(b rune, i int) bool { return (b >= 'a' && b <= 'z') \|\| (b >= 'A' && b <= 'Z') \|\| b == '_' \|\| b == ':' \|\| (b >= '0' && b <= '9' && i > 0) } func (e EscapingScheme) String() string { switch e { case NoEscaping: return AllowUTF8 case UnderscoreEscaping: return EscapeUnderscores case DotsEscaping: return EscapeDots case ValueEncodingEscaping: return EscapeValues default: panic(fmt.Sprintf("unknown format scheme %d", e)) } } func ToEscapingScheme(s string) (EscapingScheme, error) { if s == "" { return NoEscaping, errors.New("got empty string instead of escaping scheme") } switch s { case AllowUTF8: return NoEscaping, nil case EscapeUnderscores: return UnderscoreEscaping, nil case EscapeDots: return DotsEscaping, nil case EscapeValues: return ValueEncodingEscaping, nil default: return NoEscaping, fmt.Errorf("unknown format scheme %s", s) } }	12.72 KB	2025-05-25 12:27
📄 metric_test.go // Copyright 2013 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 model import ( "testing" "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" dto "github.com/prometheus/client_model/go" "google.golang.org/protobuf/proto" ) func testMetric(t testing.TB) { scenarios := []struct { input LabelSet fingerprint Fingerprint fastFingerprint Fingerprint }{ { input: LabelSet{}, fingerprint: 14695981039346656037, fastFingerprint: 14695981039346656037, }, { input: LabelSet{ "first_name": "electro", "occupation": "robot", "manufacturer": "westinghouse", }, fingerprint: 5911716720268894962, fastFingerprint: 11310079640881077873, }, { input: LabelSet{ "x": "y", }, fingerprint: 8241431561484471700, fastFingerprint: 13948396922932177635, }, { input: LabelSet{ "a": "bb", "b": "c", }, fingerprint: 3016285359649981711, fastFingerprint: 3198632812309449502, }, { input: LabelSet{ "a": "b", "bb": "c", }, fingerprint: 7122421792099404749, fastFingerprint: 5774953389407657638, }, } for i, scenario := range scenarios { input := Metric(scenario.input) if scenario.fingerprint != input.Fingerprint() { t.Errorf("%d. expected %d, got %d", i, scenario.fingerprint, input.Fingerprint()) } if scenario.fastFingerprint != input.FastFingerprint() { t.Errorf("%d. expected %d, got %d", i, scenario.fastFingerprint, input.FastFingerprint()) } } } func TestMetric(t testing.T) { testMetric(t) } func BenchmarkMetric(b testing.B) { for i := 0; i < b.N; i++ { testMetric(b) } } func TestMetricNameIsLegacyValid(t testing.T) { scenarios := []struct { mn LabelValue legacyValid bool utf8Valid bool }{ { mn: "Avalid_23name", legacyValid: true, utf8Valid: true, }, { mn: "_Avalid_23name", legacyValid: true, utf8Valid: true, }, { mn: "1valid_23name", legacyValid: false, utf8Valid: true, }, { mn: "avalid_23name", legacyValid: true, utf8Valid: true, }, { mn: "Ava:lid_23name", legacyValid: true, utf8Valid: true, }, { mn: "a lid_23name", legacyValid: false, utf8Valid: true, }, { mn: ":leading_colon", legacyValid: true, utf8Valid: true, }, { mn: "colon:in:the:middle", legacyValid: true, utf8Valid: true, }, { mn: "", legacyValid: false, utf8Valid: false, }, { mn: "a\xc5z", legacyValid: false, utf8Valid: false, }, } for _, s := range scenarios { NameValidationScheme = LegacyValidation if IsValidMetricName(s.mn) != s.legacyValid { t.Errorf("Expected %v for %q using legacy IsValidMetricName method", s.legacyValid, s.mn) } if MetricNameRE.MatchString(string(s.mn)) != s.legacyValid { t.Errorf("Expected %v for %q using regexp matching", s.legacyValid, s.mn) } NameValidationScheme = UTF8Validation if IsValidMetricName(s.mn) != s.utf8Valid { t.Errorf("Expected %v for %q using utf-8 IsValidMetricName method", s.legacyValid, s.mn) } } } func TestMetricClone(t testing.T) { m := Metric{ "first_name": "electro", "occupation": "robot", "manufacturer": "westinghouse", } m2 := m.Clone() if len(m) != len(m2) { t.Errorf("expected the length of the cloned metric to be equal to the input metric") } for ln, lv := range m2 { expected := m[ln] if expected != lv { t.Errorf("expected label value %s but got %s for label name %s", expected, lv, ln) } } } func TestMetricToString(t testing.T) { scenarios := []struct { name string input Metric expected string }{ { name: "valid metric without __name__ label", input: Metric{ "first_name": "electro", "occupation": "robot", "manufacturer": "westinghouse", }, expected: `{first_name="electro", manufacturer="westinghouse", occupation="robot"}`, }, { name: "valid metric with __name__ label", input: Metric{ "__name__": "electro", "occupation": "robot", "manufacturer": "westinghouse", }, expected: `electro{manufacturer="westinghouse", occupation="robot"}`, }, { name: "empty metric with __name__ label", input: Metric{ "__name__": "fooname", }, expected: "fooname", }, { name: "empty metric", input: Metric{}, expected: "{}", }, } for _, scenario := range scenarios { t.Run(scenario.name, func(t testing.T) { actual := scenario.input.String() if actual != scenario.expected { t.Errorf("expected string output %s but got %s", scenario.expected, actual) } }) } } func TestEscapeName(t testing.T) { scenarios := []struct { name string input string expectedUnderscores string expectedDots string expectedUnescapedDots string expectedValue string }{ { name: "empty string", }, { name: "legacy valid name", input: "no:escaping_required", expectedUnderscores: "no:escaping_required", // Dots escaping will escape underscores even though it's not strictly // necessary for compatibility. expectedDots: "no:escaping__required", expectedUnescapedDots: "no:escaping_required", expectedValue: "no:escaping_required", }, { name: "name with dots", input: "mysystem.prod.west.cpu.load", expectedUnderscores: "mysystem_prod_west_cpu_load", expectedDots: "mysystem_dot_prod_dot_west_dot_cpu_dot_load", expectedUnescapedDots: "mysystem.prod.west.cpu.load", expectedValue: "U__mysystem_2e_prod_2e_west_2e_cpu_2e_load", }, { name: "name with dots and underscore", input: "mysystem.prod.west.cpu.load_total", expectedUnderscores: "mysystem_prod_west_cpu_load_total", expectedDots: "mysystem_dot_prod_dot_west_dot_cpu_dot_load__total", expectedUnescapedDots: "mysystem.prod.west.cpu.load_total", expectedValue: "U__mysystem_2e_prod_2e_west_2e_cpu_2e_load__total", }, { name: "name with dots and colon", input: "http.status:sum", expectedUnderscores: "http_status:sum", expectedDots: "http_dot_status:sum", expectedUnescapedDots: "http.status:sum", expectedValue: "U__http_2e_status:sum", }, { name: "name with spaces and emoji", input: "label with 😱", expectedUnderscores: "label_with__", expectedDots: "label__with____", expectedUnescapedDots: "label_with__", expectedValue: "U__label_20_with_20__1f631_", }, { name: "name with unicode characters > 0x100", input: "花火", expectedUnderscores: "__", expectedDots: "____", // Dots-replacement does not know the difference between two replaced // characters and a single underscore. expectedUnescapedDots: "__", expectedValue: "U___82b1__706b_", }, { name: "name with spaces and edge-case value", input: "label with \u0100", expectedUnderscores: "label_with__", expectedDots: "label__with____", expectedUnescapedDots: "label_with__", expectedValue: "U__label_20_with_20__100_", }, } for _, scenario := range scenarios { t.Run(scenario.name, func(t testing.T) { got := EscapeName(scenario.input, UnderscoreEscaping) if got != scenario.expectedUnderscores { t.Errorf("expected string output %s but got %s", scenario.expectedUnderscores, got) } // Unescaping with the underscore method is a noop. got = UnescapeName(got, UnderscoreEscaping) if got != scenario.expectedUnderscores { t.Errorf("expected unescaped string output %s but got %s", scenario.expectedUnderscores, got) } got = EscapeName(scenario.input, DotsEscaping) if got != scenario.expectedDots { t.Errorf("expected string output %s but got %s", scenario.expectedDots, got) } got = UnescapeName(got, DotsEscaping) if got != scenario.expectedUnescapedDots { t.Errorf("expected unescaped string output %s but got %s", scenario.expectedUnescapedDots, got) } got = EscapeName(scenario.input, ValueEncodingEscaping) if got != scenario.expectedValue { t.Errorf("expected string output %s but got %s", scenario.expectedValue, got) } // Unescaped result should always be identical to the original input. got = UnescapeName(got, ValueEncodingEscaping) if got != scenario.input { t.Errorf("expected unescaped string output %s but got %s", scenario.input, got) } }) } } func TestValueUnescapeErrors(t testing.T) { scenarios := []struct { name string input string expected string }{ { name: "empty string", }, { name: "basic case, no error", input: "U__no:unescapingrequired", expected: "no:unescapingrequired", }, { name: "capitals ok, no error", input: "U__capitals_2E_ok", expected: "capitals.ok", }, { name: "underscores, no error", input: "U__underscores__doubled__", expected: "underscores_doubled_", }, { name: "invalid single underscore", input: "U__underscores_doubled_", expected: "U__underscores_doubled_", }, { name: "invalid single underscore, 2", input: "U__underscores__doubled_", expected: "U__underscores__doubled_", }, { name: "giant fake utf-8 code", input: "U__my__hack_2e_attempt_872348732fabdabbab_", expected: "U__my__hack_2e_attempt_872348732fabdabbab_", }, { name: "trailing utf-8", input: "U__my__hack_2e", expected: "U__my__hack_2e", }, { name: "invalid utf-8 value", input: "U__bad__utf_2eg_", expected: "U__bad__utf_2eg_", }, { name: "surrogate utf-8 value", input: "U__bad__utf_D900_", expected: "U__bad__utf_D900_", }, } for _, scenario := range scenarios { t.Run(scenario.name, func(t testing.T) { got := UnescapeName(scenario.input, ValueEncodingEscaping) if got != scenario.expected { t.Errorf("expected unescaped string output %s but got %s", scenario.expected, got) } }) } } func TestEscapeMetricFamily(t testing.T) { scenarios := []struct { name string input dto.MetricFamily scheme EscapingScheme expected dto.MetricFamily }{ { name: "empty", input: &dto.MetricFamily{}, scheme: ValueEncodingEscaping, expected: &dto.MetricFamily{}, }, { name: "simple, no escaping needed", scheme: ValueEncodingEscaping, input: &dto.MetricFamily{ Name: proto.String("my_metric"), Help: proto.String("some help text"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Counter: &dto.Counter{ Value: proto.Float64(34.2), }, Label: []dto.LabelPair{ { Name: proto.String("__name__"), Value: proto.String("my_metric"), }, { Name: proto.String("some_label"), Value: proto.String("labelvalue"), }, }, }, }, }, expected: &dto.MetricFamily{ Name: proto.String("my_metric"), Help: proto.String("some help text"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Counter: &dto.Counter{ Value: proto.Float64(34.2), }, Label: []dto.LabelPair{ { Name: proto.String("__name__"), Value: proto.String("my_metric"), }, { Name: proto.String("some_label"), Value: proto.String("labelvalue"), }, }, }, }, }, }, { name: "label name escaping needed", scheme: ValueEncodingEscaping, input: &dto.MetricFamily{ Name: proto.String("my_metric"), Help: proto.String("some help text"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Counter: &dto.Counter{ Value: proto.Float64(34.2), }, Label: []dto.LabelPair{ { Name: proto.String("__name__"), Value: proto.String("my_metric"), }, { Name: proto.String("some.label"), Value: proto.String("labelvalue"), }, }, }, }, }, expected: &dto.MetricFamily{ Name: proto.String("my_metric"), Help: proto.String("some help text"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Counter: &dto.Counter{ Value: proto.Float64(34.2), }, Label: []dto.LabelPair{ { Name: proto.String("__name__"), Value: proto.String("my_metric"), }, { Name: proto.String("U__some_2e_label"), Value: proto.String("labelvalue"), }, }, }, }, }, }, { name: "counter, escaping needed", scheme: ValueEncodingEscaping, input: &dto.MetricFamily{ Name: proto.String("my.metric"), Help: proto.String("some help text"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Counter: &dto.Counter{ Value: proto.Float64(34.2), }, Label: []dto.LabelPair{ { Name: proto.String("__name__"), Value: proto.String("my.metric"), }, { Name: proto.String("some?label"), Value: proto.String("label??value"), }, }, }, }, }, expected: &dto.MetricFamily{ Name: proto.String("U__my_2e_metric"), Help: proto.String("some help text"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Counter: &dto.Counter{ Value: proto.Float64(34.2), }, Label: []dto.LabelPair{ { Name: proto.String("__name__"), Value: proto.String("U__my_2e_metric"), }, { Name: proto.String("U__some_3f_label"), Value: proto.String("label??value"), }, }, }, }, }, }, { name: "gauge, escaping needed", scheme: DotsEscaping, input: &dto.MetricFamily{ Name: proto.String("unicode.and.dots.花火"), Help: proto.String("some help text"), Type: dto.MetricType_GAUGE.Enum(), Metric: []dto.Metric{ { Gauge: &dto.Gauge{ Value: proto.Float64(34.2), }, Label: []dto.LabelPair{ { Name: proto.String("__name__"), Value: proto.String("unicode.and.dots.花火"), }, { Name: proto.String("some_label"), Value: proto.String("label??value"), }, }, }, }, }, expected: &dto.MetricFamily{ Name: proto.String("unicode_dot_and_dot_dots_dot_____"), Help: proto.String("some help text"), Type: dto.MetricType_GAUGE.Enum(), Metric: []dto.Metric{ { Gauge: &dto.Gauge{ Value: proto.Float64(34.2), }, Label: []dto.LabelPair{ { Name: proto.String("__name__"), Value: proto.String("unicode_dot_and_dot_dots_dot_____"), }, { Name: proto.String("some_label"), Value: proto.String("label??value"), }, }, }, }, }, }, } unexportList := []interface{}{dto.MetricFamily{}, dto.Metric{}, dto.LabelPair{}, dto.Counter{}, dto.Gauge{}} for _, scenario := range scenarios { t.Run(scenario.name, func(t testing.T) { original := proto.Clone(scenario.input) got := EscapeMetricFamily(scenario.input, scenario.scheme) if !cmp.Equal(scenario.expected, got, cmpopts.IgnoreUnexported(unexportList...)) { t.Errorf("unexpected difference in escaped output:\n%s", cmp.Diff(scenario.expected, got, cmpopts.IgnoreUnexported(unexportList...))) } if !cmp.Equal(scenario.input, original, cmpopts.IgnoreUnexported(unexportList...)) { t.Errorf("input was mutated during escaping:\n%s", cmp.Diff(scenario.expected, got, cmpopts.IgnoreUnexported(unexportList...))) } }) } } // TestProtoFormatUnchanged checks to see if the proto format changed, in which // case EscapeMetricFamily will need to be updated. func TestProtoFormatUnchanged(t testing.T) { scenarios := []struct { name string input proto.Message expectFields []string }{ { name: "MetricFamily", input: &dto.MetricFamily{}, expectFields: []string{"name", "help", "type", "metric", "unit"}, }, { name: "Metric", input: &dto.Metric{}, expectFields: []string{"label", "gauge", "counter", "summary", "untyped", "histogram", "timestamp_ms"}, }, { name: "LabelPair", input: &dto.LabelPair{}, expectFields: []string{"name", "value"}, }, } for _, scenario := range scenarios { t.Run(scenario.name, func(t testing.T) { desc := scenario.input.ProtoReflect().Descriptor() fields := desc.Fields() if fields.Len() != len(scenario.expectFields) { t.Errorf("dto.MetricFamily changed length, expected %d, got %d", len(scenario.expectFields), fields.Len()) } for i := 0; i < fields.Len(); i++ { got := fields.Get(i).TextName() if got != scenario.expectFields[i] { t.Errorf("dto.MetricFamily field mismatch, expected %s got %s", scenario.expectFields[i], got) } } }) } }	17.52 KB	2025-05-25 12:27
📄 model.go // Copyright 2013 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 model contains common data structures that are shared across // Prometheus components and libraries. package model	719 B	2025-05-25 12:27
📄 signature.go // Copyright 2014 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package model import ( "sort" ) // SeparatorByte is a byte that cannot occur in valid UTF-8 sequences and is // used to separate label names, label values, and other strings from each other // when calculating their combined hash value (aka signature aka fingerprint). const SeparatorByte byte = 255 // cache the signature of an empty label set. var emptyLabelSignature = hashNew() // LabelsToSignature returns a quasi-unique signature (i.e., fingerprint) for a // given label set. (Collisions are possible but unlikely if the number of label // sets the function is applied to is small.) func LabelsToSignature(labels map[string]string) uint64 { if len(labels) == 0 { return emptyLabelSignature } labelNames := make([]string, 0, len(labels)) for labelName := range labels { labelNames = append(labelNames, labelName) } sort.Strings(labelNames) sum := hashNew() for _, labelName := range labelNames { sum = hashAdd(sum, labelName) sum = hashAddByte(sum, SeparatorByte) sum = hashAdd(sum, labels[labelName]) sum = hashAddByte(sum, SeparatorByte) } return sum } // labelSetToFingerprint works exactly as LabelsToSignature but takes a LabelSet as // parameter (rather than a label map) and returns a Fingerprint. func labelSetToFingerprint(ls LabelSet) Fingerprint { if len(ls) == 0 { return Fingerprint(emptyLabelSignature) } labelNames := make(LabelNames, 0, len(ls)) for labelName := range ls { labelNames = append(labelNames, labelName) } sort.Sort(labelNames) sum := hashNew() for _, labelName := range labelNames { sum = hashAdd(sum, string(labelName)) sum = hashAddByte(sum, SeparatorByte) sum = hashAdd(sum, string(ls[labelName])) sum = hashAddByte(sum, SeparatorByte) } return Fingerprint(sum) } // labelSetToFastFingerprint works similar to labelSetToFingerprint but uses a // faster and less allocation-heavy hash function, which is more susceptible to // create hash collisions. Therefore, collision detection should be applied. func labelSetToFastFingerprint(ls LabelSet) Fingerprint { if len(ls) == 0 { return Fingerprint(emptyLabelSignature) } var result uint64 for labelName, labelValue := range ls { sum := hashNew() sum = hashAdd(sum, string(labelName)) sum = hashAddByte(sum, SeparatorByte) sum = hashAdd(sum, string(labelValue)) result ^= sum } return Fingerprint(result) } // SignatureForLabels works like LabelsToSignature but takes a Metric as // parameter (rather than a label map) and only includes the labels with the // specified LabelNames into the signature calculation. The labels passed in // will be sorted by this function. func SignatureForLabels(m Metric, labels ...LabelName) uint64 { if len(labels) == 0 { return emptyLabelSignature } sort.Sort(LabelNames(labels)) sum := hashNew() for _, label := range labels { sum = hashAdd(sum, string(label)) sum = hashAddByte(sum, SeparatorByte) sum = hashAdd(sum, string(m[label])) sum = hashAddByte(sum, SeparatorByte) } return sum } // SignatureWithoutLabels works like LabelsToSignature but takes a Metric as // parameter (rather than a label map) and excludes the labels with any of the // specified LabelNames from the signature calculation. func SignatureWithoutLabels(m Metric, labels map[LabelName]struct{}) uint64 { if len(m) == 0 { return emptyLabelSignature } labelNames := make(LabelNames, 0, len(m)) for labelName := range m { if _, exclude := labels[labelName]; !exclude { labelNames = append(labelNames, labelName) } } if len(labelNames) == 0 { return emptyLabelSignature } sort.Sort(labelNames) sum := hashNew() for _, labelName := range labelNames { sum = hashAdd(sum, string(labelName)) sum = hashAddByte(sum, SeparatorByte) sum = hashAdd(sum, string(m[labelName])) sum = hashAddByte(sum, SeparatorByte) } return sum }	4.33 KB	2025-05-25 12:27
📄 signature_test.go // Copyright 2014 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package model import ( "fmt" "runtime" "sync" "testing" "github.com/stretchr/testify/require" ) func TestLabelsToSignature(t testing.T) { scenarios := []struct { in map[string]string out uint64 }{ { in: map[string]string{}, out: 14695981039346656037, }, { in: map[string]string{"name": "garland, briggs", "fear": "love is not enough"}, out: 5799056148416392346, }, } for i, scenario := range scenarios { actual := LabelsToSignature(scenario.in) if actual != scenario.out { t.Errorf("%d. expected %d, got %d", i, scenario.out, actual) } } } func TestMetricToFingerprint(t testing.T) { scenarios := []struct { in LabelSet out Fingerprint }{ { in: LabelSet{}, out: 14695981039346656037, }, { in: LabelSet{"name": "garland, briggs", "fear": "love is not enough"}, out: 5799056148416392346, }, } for i, scenario := range scenarios { actual := labelSetToFingerprint(scenario.in) if actual != scenario.out { t.Errorf("%d. expected %d, got %d", i, scenario.out, actual) } } } func TestMetricToFastFingerprint(t testing.T) { scenarios := []struct { in LabelSet out Fingerprint }{ { in: LabelSet{}, out: 14695981039346656037, }, { in: LabelSet{"name": "garland, briggs", "fear": "love is not enough"}, out: 12952432476264840823, }, } for i, scenario := range scenarios { actual := labelSetToFastFingerprint(scenario.in) if actual != scenario.out { t.Errorf("%d. expected %d, got %d", i, scenario.out, actual) } } } func TestSignatureForLabels(t testing.T) { scenarios := []struct { in Metric labels LabelNames out uint64 }{ { in: Metric{}, labels: nil, out: 14695981039346656037, }, { in: Metric{}, labels: LabelNames{"empty"}, out: 7187873163539638612, }, { in: Metric{"name": "garland, briggs", "fear": "love is not enough"}, labels: LabelNames{"empty"}, out: 7187873163539638612, }, { in: Metric{"name": "garland, briggs", "fear": "love is not enough"}, labels: LabelNames{"fear", "name"}, out: 5799056148416392346, }, { in: Metric{"name": "garland, briggs", "fear": "love is not enough", "foo": "bar"}, labels: LabelNames{"fear", "name"}, out: 5799056148416392346, }, { in: Metric{"name": "garland, briggs", "fear": "love is not enough"}, labels: LabelNames{}, out: 14695981039346656037, }, { in: Metric{"name": "garland, briggs", "fear": "love is not enough"}, labels: nil, out: 14695981039346656037, }, } for i, scenario := range scenarios { actual := SignatureForLabels(scenario.in, scenario.labels...) if actual != scenario.out { t.Errorf("%d. expected %d, got %d", i, scenario.out, actual) } } } func TestSignatureWithoutLabels(t testing.T) { scenarios := []struct { in Metric labels map[LabelName]struct{} out uint64 }{ { in: Metric{}, labels: nil, out: 14695981039346656037, }, { in: Metric{"name": "garland, briggs", "fear": "love is not enough"}, labels: map[LabelName]struct{}{"fear": {}, "name": {}}, out: 14695981039346656037, }, { in: Metric{"name": "garland, briggs", "fear": "love is not enough", "foo": "bar"}, labels: map[LabelName]struct{}{"foo": {}}, out: 5799056148416392346, }, { in: Metric{"name": "garland, briggs", "fear": "love is not enough"}, labels: map[LabelName]struct{}{}, out: 5799056148416392346, }, { in: Metric{"name": "garland, briggs", "fear": "love is not enough"}, labels: nil, out: 5799056148416392346, }, } for i, scenario := range scenarios { actual := SignatureWithoutLabels(scenario.in, scenario.labels) if actual != scenario.out { t.Errorf("%d. expected %d, got %d", i, scenario.out, actual) } } } func benchmarkLabelToSignature(b testing.B, l map[string]string, e uint64) { for i := 0; i < b.N; i++ { a := LabelsToSignature(l) require.Equalf(b, a, e, "expected signature of %d for %s, got %d", e, l, a) } } func BenchmarkLabelToSignatureScalar(b testing.B) { benchmarkLabelToSignature(b, nil, 14695981039346656037) } func BenchmarkLabelToSignatureSingle(b testing.B) { benchmarkLabelToSignature(b, map[string]string{"first-label": "first-label-value"}, 5146282821936882169) } func BenchmarkLabelToSignatureDouble(b testing.B) { benchmarkLabelToSignature(b, map[string]string{"first-label": "first-label-value", "second-label": "second-label-value"}, 3195800080984914717) } func BenchmarkLabelToSignatureTriple(b testing.B) { benchmarkLabelToSignature(b, map[string]string{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 13843036195897128121) } func benchmarkMetricToFingerprint(b testing.B, ls LabelSet, e Fingerprint) { for i := 0; i < b.N; i++ { a := labelSetToFingerprint(ls) require.Equalf(b, a, e, "expected signature of %d for %s, got %d", e, ls, a) } } func BenchmarkMetricToFingerprintScalar(b testing.B) { benchmarkMetricToFingerprint(b, nil, 14695981039346656037) } func BenchmarkMetricToFingerprintSingle(b testing.B) { benchmarkMetricToFingerprint(b, LabelSet{"first-label": "first-label-value"}, 5146282821936882169) } func BenchmarkMetricToFingerprintDouble(b testing.B) { benchmarkMetricToFingerprint(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value"}, 3195800080984914717) } func BenchmarkMetricToFingerprintTriple(b testing.B) { benchmarkMetricToFingerprint(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 13843036195897128121) } func benchmarkMetricToFastFingerprint(b testing.B, ls LabelSet, e Fingerprint) { for i := 0; i < b.N; i++ { a := labelSetToFastFingerprint(ls) require.Equalf(b, a, e, "expected signature of %d for %s, got %d", e, ls, a) } } func BenchmarkMetricToFastFingerprintScalar(b testing.B) { benchmarkMetricToFastFingerprint(b, nil, 14695981039346656037) } func BenchmarkMetricToFastFingerprintSingle(b testing.B) { benchmarkMetricToFastFingerprint(b, LabelSet{"first-label": "first-label-value"}, 5147259542624943964) } func BenchmarkMetricToFastFingerprintDouble(b testing.B) { benchmarkMetricToFastFingerprint(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value"}, 18269973311206963528) } func BenchmarkMetricToFastFingerprintTriple(b testing.B) { benchmarkMetricToFastFingerprint(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676) } func BenchmarkEmptyLabelSignature(b testing.B) { input := []map[string]string{nil, {}} var ms runtime.MemStats runtime.ReadMemStats(&ms) alloc := ms.Alloc for _, labels := range input { LabelsToSignature(labels) } runtime.ReadMemStats(&ms) got := ms.Alloc require.Equalf(b, alloc, got, "expected LabelsToSignature with empty labels not to perform allocations") } func benchmarkMetricToFastFingerprintConc(b testing.B, ls LabelSet, e Fingerprint, concLevel int) { var start, end sync.WaitGroup start.Add(1) end.Add(concLevel) errc := make(chan error, 1) for i := 0; i < concLevel; i++ { go func() { start.Wait() for j := b.N / concLevel; j >= 0; j-- { if a := labelSetToFastFingerprint(ls); a != e { select { case errc <- fmt.Errorf("expected signature of %d for %s, got %d", e, ls, a): default: } } } end.Done() }() } b.ResetTimer() start.Done() end.Wait() select { case err := <-errc: b.Fatal(err) default: } } func BenchmarkMetricToFastFingerprintTripleConc1(b testing.B) { benchmarkMetricToFastFingerprintConc(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676, 1) } func BenchmarkMetricToFastFingerprintTripleConc2(b testing.B) { benchmarkMetricToFastFingerprintConc(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676, 2) } func BenchmarkMetricToFastFingerprintTripleConc4(b testing.B) { benchmarkMetricToFastFingerprintConc(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676, 4) } func BenchmarkMetricToFastFingerprintTripleConc8(b testing.B) { benchmarkMetricToFastFingerprintConc(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676, 8) }	9.1 KB	2025-05-25 12:27
📄 silence.go // Copyright 2015 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package model import ( "encoding/json" "errors" "fmt" "regexp" "time" ) // Matcher describes a matches the value of a given label. type Matcher struct { Name LabelName `json:"name"` Value string `json:"value"` IsRegex bool `json:"isRegex"` } func (m Matcher) UnmarshalJSON(b []byte) error { type plain Matcher if err := json.Unmarshal(b, (plain)(m)); err != nil { return err } if len(m.Name) == 0 { return errors.New("label name in matcher must not be empty") } if m.IsRegex { if _, err := regexp.Compile(m.Value); err != nil { return err } } return nil } // Validate returns true iff all fields of the matcher have valid values. func (m Matcher) Validate() error { if !m.Name.IsValid() { return fmt.Errorf("invalid name %q", m.Name) } if m.IsRegex { if _, err := regexp.Compile(m.Value); err != nil { return fmt.Errorf("invalid regular expression %q", m.Value) } } else if !LabelValue(m.Value).IsValid() \|\| len(m.Value) == 0 { return fmt.Errorf("invalid value %q", m.Value) } return nil } // Silence defines the representation of a silence definition in the Prometheus // eco-system. type Silence struct { ID uint64 `json:"id,omitempty"` Matchers []Matcher `json:"matchers"` StartsAt time.Time `json:"startsAt"` EndsAt time.Time `json:"endsAt"` CreatedAt time.Time `json:"createdAt,omitempty"` CreatedBy string `json:"createdBy"` Comment string `json:"comment,omitempty"` } // Validate returns true iff all fields of the silence have valid values. func (s *Silence) Validate() error { if len(s.Matchers) == 0 { return errors.New("at least one matcher required") } for _, m := range s.Matchers { if err := m.Validate(); err != nil { return fmt.Errorf("invalid matcher: %w", err) } } if s.StartsAt.IsZero() { return errors.New("start time missing") } if s.EndsAt.IsZero() { return errors.New("end time missing") } if s.EndsAt.Before(s.StartsAt) { return errors.New("start time must be before end time") } if s.CreatedBy == "" { return errors.New("creator information missing") } if s.Comment == "" { return errors.New("comment missing") } if s.CreatedAt.IsZero() { return errors.New("creation timestamp missing") } return nil }	2.78 KB	2025-05-25 12:27
📄 silence_test.go // Copyright 2015 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package model import ( "strings" "testing" "time" ) func TestMatcherValidate(t testing.T) { cases := []struct { matcher Matcher legacyErr string utf8Err string }{ { matcher: &Matcher{ Name: "name", Value: "value", }, }, { matcher: &Matcher{ Name: "name", Value: "value", IsRegex: true, }, }, { matcher: &Matcher{ Name: "name!", Value: "value", }, legacyErr: "invalid name", }, { matcher: &Matcher{ Name: "", Value: "value", }, legacyErr: "invalid name", utf8Err: "invalid name", }, { matcher: &Matcher{ Name: "name", Value: "value\xff", }, legacyErr: "invalid value", utf8Err: "invalid value", }, { matcher: &Matcher{ Name: "name", Value: "", }, legacyErr: "invalid value", utf8Err: "invalid value", }, { matcher: &Matcher{ Name: "a\xc5z", Value: "", }, legacyErr: "invalid name", utf8Err: "invalid name", }, } for i, c := range cases { NameValidationScheme = LegacyValidation legacyErr := c.matcher.Validate() NameValidationScheme = UTF8Validation utf8Err := c.matcher.Validate() if legacyErr == nil && utf8Err == nil { if c.legacyErr == "" && c.utf8Err == "" { continue } if c.legacyErr != "" { t.Errorf("%d. Expected error for legacy validation %q but got none", i, c.legacyErr) } if c.utf8Err != "" { t.Errorf("%d. Expected error for utf-8 validation %q but got none", i, c.utf8Err) } continue } if legacyErr != nil { if c.legacyErr == "" { t.Errorf("%d. Expected no legacy validation error but got %q", i, legacyErr) } else if !strings.Contains(legacyErr.Error(), c.legacyErr) { t.Errorf("%d. Expected error to contain %q but got %q", i, c.legacyErr, legacyErr) } } if utf8Err != nil { if c.utf8Err == "" { t.Errorf("%d. Expected no utf-8 validation error but got %q", i, utf8Err) continue } if !strings.Contains(utf8Err.Error(), c.utf8Err) { t.Errorf("%d. Expected error to contain %q but got %q", i, c.utf8Err, utf8Err) } } } } func TestSilenceValidate(t testing.T) { ts := time.Now() cases := []struct { sil Silence err string }{ { sil: &Silence{ Matchers: []Matcher{ {Name: "name", Value: "value"}, }, StartsAt: ts, EndsAt: ts, CreatedAt: ts, CreatedBy: "name", Comment: "comment", }, }, { sil: &Silence{ Matchers: []Matcher{ {Name: "name", Value: "value"}, {Name: "name", Value: "value"}, {Name: "name", Value: "value"}, {Name: "name", Value: "value", IsRegex: true}, }, StartsAt: ts, EndsAt: ts, CreatedAt: ts, CreatedBy: "name", Comment: "comment", }, }, { sil: &Silence{ Matchers: []Matcher{ {Name: "name", Value: "value"}, }, StartsAt: ts, EndsAt: ts.Add(-1 time.Minute), CreatedAt: ts, CreatedBy: "name", Comment: "comment", }, err: "start time must be before end time", }, { sil: &Silence{ Matchers: []Matcher{ {Name: "name", Value: "value"}, }, StartsAt: ts, CreatedAt: ts, CreatedBy: "name", Comment: "comment", }, err: "end time missing", }, { sil: &Silence{ Matchers: []Matcher{ {Name: "name", Value: "value"}, }, EndsAt: ts, CreatedAt: ts, CreatedBy: "name", Comment: "comment", }, err: "start time missing", }, { sil: &Silence{ Matchers: []Matcher{ {Name: "!name", Value: "value"}, }, StartsAt: ts, EndsAt: ts, CreatedAt: ts, CreatedBy: "name", Comment: "comment", }, err: "invalid matcher", }, { sil: &Silence{ Matchers: []Matcher{ {Name: "name", Value: "value"}, }, StartsAt: ts, EndsAt: ts, CreatedAt: ts, CreatedBy: "name", }, err: "comment missing", }, { sil: &Silence{ Matchers: []Matcher{ {Name: "name", Value: "value"}, }, StartsAt: ts, EndsAt: ts, CreatedBy: "name", Comment: "comment", }, err: "creation timestamp missing", }, { sil: &Silence{ Matchers: []Matcher{ {Name: "name", Value: "value"}, }, StartsAt: ts, EndsAt: ts, CreatedAt: ts, Comment: "comment", }, err: "creator information missing", }, { sil: &Silence{ Matchers: []*Matcher{}, StartsAt: ts, EndsAt: ts, CreatedAt: ts, Comment: "comment", }, err: "at least one matcher required", }, } for i, c := range cases { NameValidationScheme = LegacyValidation err := c.sil.Validate() if err == nil { if c.err == "" { continue } t.Errorf("%d. Expected error %q but got none", i, c.err) continue } if c.err == "" { t.Errorf("%d. Expected no error but got %q", i, err) continue } if !strings.Contains(err.Error(), c.err) { t.Errorf("%d. Expected error to contain %q but got %q", i, c.err, err) } } }	5.5 KB	2025-05-25 12:27
📄 time.go // Copyright 2013 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 model import ( "encoding/json" "errors" "fmt" "math" "strconv" "strings" "time" ) const ( // MinimumTick is the minimum supported time resolution. This has to be // at least time.Second in order for the code below to work. minimumTick = time.Millisecond // second is the Time duration equivalent to one second. second = int64(time.Second / minimumTick) // The number of nanoseconds per minimum tick. nanosPerTick = int64(minimumTick / time.Nanosecond) // Earliest is the earliest Time representable. Handy for // initializing a high watermark. Earliest = Time(math.MinInt64) // Latest is the latest Time representable. Handy for initializing // a low watermark. Latest = Time(math.MaxInt64) ) // Time is the number of milliseconds since the epoch // (1970-01-01 00:00 UTC) excluding leap seconds. type Time int64 // Interval describes an interval between two timestamps. type Interval struct { Start, End Time } // Now returns the current time as a Time. func Now() Time { return TimeFromUnixNano(time.Now().UnixNano()) } // TimeFromUnix returns the Time equivalent to the Unix Time t // provided in seconds. func TimeFromUnix(t int64) Time { return Time(t * second) } // TimeFromUnixNano returns the Time equivalent to the Unix Time // t provided in nanoseconds. func TimeFromUnixNano(t int64) Time { return Time(t / nanosPerTick) } // Equal reports whether two Times represent the same instant. func (t Time) Equal(o Time) bool { return t == o } // Before reports whether the Time t is before o. func (t Time) Before(o Time) bool { return t < o } // After reports whether the Time t is after o. func (t Time) After(o Time) bool { return t > o } // Add returns the Time t + d. func (t Time) Add(d time.Duration) Time { return t + Time(d/minimumTick) } // Sub returns the Duration t - o. func (t Time) Sub(o Time) time.Duration { return time.Duration(t-o) * minimumTick } // Time returns the time.Time representation of t. func (t Time) Time() time.Time { return time.Unix(int64(t)/second, (int64(t)%second)nanosPerTick) } // Unix returns t as a Unix time, the number of seconds elapsed // since January 1, 1970 UTC. func (t Time) Unix() int64 { return int64(t) / second } // UnixNano returns t as a Unix time, the number of nanoseconds elapsed // since January 1, 1970 UTC. func (t Time) UnixNano() int64 { return int64(t) nanosPerTick } // The number of digits after the dot. var dotPrecision = int(math.Log10(float64(second))) // String returns a string representation of the Time. func (t Time) String() string { return strconv.FormatFloat(float64(t)/float64(second), 'f', -1, 64) } // MarshalJSON implements the json.Marshaler interface. func (t Time) MarshalJSON() ([]byte, error) { return []byte(t.String()), nil } // UnmarshalJSON implements the json.Unmarshaler interface. func (t Time) UnmarshalJSON(b []byte) error { p := strings.Split(string(b), ".") switch len(p) { case 1: v, err := strconv.ParseInt(string(p[0]), 10, 64) if err != nil { return err } t = Time(v * second) case 2: v, err := strconv.ParseInt(string(p[0]), 10, 64) if err != nil { return err } v = second prec := dotPrecision - len(p[1]) if prec < 0 { p[1] = p[1][:dotPrecision] } else if prec > 0 { p[1] = p[1] + strings.Repeat("0", prec) } va, err := strconv.ParseInt(p[1], 10, 32) if err != nil { return err } // If the value was something like -0.1 the negative is lost in the // parsing because of the leading zero, this ensures that we capture it. if len(p[0]) > 0 && p[0][0] == '-' && v+va > 0 { t = Time(v+va) * -1 } else { t = Time(v + va) } default: return fmt.Errorf("invalid time %q", string(b)) } return nil } // Duration wraps time.Duration. It is used to parse the custom duration format // from YAML. // This type should not propagate beyond the scope of input/output processing. type Duration time.Duration // Set implements pflag/flag.Value func (d Duration) Set(s string) error { var err error d, err = ParseDuration(s) return err } // Type implements pflag.Value func (d Duration) Type() string { return "duration" } func isdigit(c byte) bool { return c >= '0' && c <= '9' } // Units are required to go in order from biggest to smallest. // This guards against confusion from "1m1d" being 1 minute + 1 day, not 1 month + 1 day. var unitMap = map[string]struct { pos int mult uint64 }{ "ms": {7, uint64(time.Millisecond)}, "s": {6, uint64(time.Second)}, "m": {5, uint64(time.Minute)}, "h": {4, uint64(time.Hour)}, "d": {3, uint64(24 * time.Hour)}, "w": {2, uint64(7 * 24 * time.Hour)}, "y": {1, uint64(365 * 24 * time.Hour)}, } // ParseDuration parses a string into a time.Duration, assuming that a year // always has 365d, a week always has 7d, and a day always has 24h. func ParseDuration(s string) (Duration, error) { switch s { case "0": // Allow 0 without a unit. return 0, nil case "": return 0, errors.New("empty duration string") } orig := s var dur uint64 lastUnitPos := 0 for s != "" { if !isdigit(s[0]) { return 0, fmt.Errorf("not a valid duration string: %q", orig) } // Consume [0-9]* i := 0 for ; i < len(s) && isdigit(s[i]); i++ { } v, err := strconv.ParseUint(s[:i], 10, 0) if err != nil { return 0, fmt.Errorf("not a valid duration string: %q", orig) } s = s[i:] // Consume unit. for i = 0; i < len(s) && !isdigit(s[i]); i++ { } if i == 0 { return 0, fmt.Errorf("not a valid duration string: %q", orig) } u := s[:i] s = s[i:] unit, ok := unitMap[u] if !ok { return 0, fmt.Errorf("unknown unit %q in duration %q", u, orig) } if unit.pos <= lastUnitPos { // Units must go in order from biggest to smallest. return 0, fmt.Errorf("not a valid duration string: %q", orig) } lastUnitPos = unit.pos // Check if the provided duration overflows time.Duration (> ~ 290years). if v > 1<<63/unit.mult { return 0, errors.New("duration out of range") } dur += v * unit.mult if dur > 1<<63-1 { return 0, errors.New("duration out of range") } } return Duration(dur), nil } func (d Duration) String() string { var ( ms = int64(time.Duration(d) / time.Millisecond) r = "" ) if ms == 0 { return "0s" } f := func(unit string, mult int64, exact bool) { if exact && ms%mult != 0 { return } if v := ms / mult; v > 0 { r += fmt.Sprintf("%d%s", v, unit) ms -= v * mult } } // Only format years and weeks if the remainder is zero, as it is often // easier to read 90d than 12w6d. f("y", 1000606024365, true) f("w", 10006060247, true) f("d", 1000606024, false) f("h", 10006060, false) f("m", 100060, false) f("s", 1000, false) f("ms", 1, false) return r } // MarshalJSON implements the json.Marshaler interface. func (d Duration) MarshalJSON() ([]byte, error) { return json.Marshal(d.String()) } // UnmarshalJSON implements the json.Unmarshaler interface. func (d Duration) UnmarshalJSON(bytes []byte) error { var s string if err := json.Unmarshal(bytes, &s); err != nil { return err } dur, err := ParseDuration(s) if err != nil { return err } d = dur return nil } // MarshalText implements the encoding.TextMarshaler interface. func (d Duration) MarshalText() ([]byte, error) { return []byte(d.String()), nil } // UnmarshalText implements the encoding.TextUnmarshaler interface. func (d Duration) UnmarshalText(text []byte) error { var err error d, err = ParseDuration(string(text)) return err } // MarshalYAML implements the yaml.Marshaler interface. func (d Duration) MarshalYAML() (interface{}, error) { return d.String(), nil } // UnmarshalYAML implements the yaml.Unmarshaler interface. func (d Duration) UnmarshalYAML(unmarshal func(interface{}) error) error { var s string if err := unmarshal(&s); err != nil { return err } dur, err := ParseDuration(s) if err != nil { return err } *d = dur return nil }	8.36 KB	2025-05-25 12:27
📄 time_test.go // Copyright 2013 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 model import ( "encoding/json" "strconv" "testing" "time" "github.com/stretchr/testify/require" ) func TestComparators(t testing.T) { t1a := TimeFromUnix(0) t1b := TimeFromUnix(0) t2 := TimeFromUnix(2second - 1) require.Truef(t, t1a.Equal(t1b), "Expected %s to be equal to %s", t1a, t1b) require.Falsef(t, t1a.Equal(t2), "Expected %s to not be equal to %s", t1a, t2) require.Truef(t, t1a.Before(t2), "Expected %s to be before %s", t1a, t2) require.Falsef(t, t1a.Before(t1b), "Expected %s to not be before %s", t1a, t1b) require.Truef(t, t2.After(t1a), "Expected %s to be after %s", t2, t1a) require.Falsef(t, t1b.After(t1a), "Expected %s to not be after %s", t1b, t1a) } func TestTimeConversions(t testing.T) { unixSecs := int64(1136239445) unixNsecs := int64(123456789) unixNano := unixSecs1e9 + unixNsecs t1 := time.Unix(unixSecs, unixNsecs-unixNsecs%nanosPerTick) t2 := time.Unix(unixSecs, unixNsecs) ts := TimeFromUnixNano(unixNano) require.Truef(t, ts.Time().Equal(t1), "Expected %s, got %s", t1, ts.Time()) // Test available precision. ts = TimeFromUnixNano(t2.UnixNano()) require.Truef(t, ts.Time().Equal(t1), "Expected %s, got %s", t1, ts.Time()) require.Equalf(t, ts.UnixNano(), unixNano-unixNano%nanosPerTick, "Expected %d, got %d", unixNano, ts.UnixNano()) } func TestDuration(t testing.T) { duration := time.Second + time.Minute + time.Hour goTime := time.Unix(1136239445, 0) ts := TimeFromUnix(goTime.Unix()) require.Truef(t, goTime.Add(duration).Equal(ts.Add(duration).Time()), "Expected %s to be equal to %s", goTime.Add(duration), ts.Add(duration)) earlier := ts.Add(-duration) delta := ts.Sub(earlier) require.Equalf(t, delta, duration, "Expected %s to be equal to %s", delta, duration) } func TestParseDuration(t testing.T) { cases := []struct { in string out time.Duration expectedString string }{ { in: "0", out: 0, expectedString: "0s", }, { in: "0w", out: 0, expectedString: "0s", }, { in: "0s", out: 0, }, { in: "324ms", out: 324 * time.Millisecond, }, { in: "3s", out: 3 * time.Second, }, { in: "5m", out: 5 * time.Minute, }, { in: "1h", out: time.Hour, }, { in: "4d", out: 4 * 24 * time.Hour, }, { in: "4d1h", out: 424time.Hour + time.Hour, }, { in: "14d", out: 14 * 24 * time.Hour, expectedString: "2w", }, { in: "3w", out: 3 * 7 * 24 * time.Hour, }, { in: "3w2d1h", out: 3724time.Hour + 224time.Hour + time.Hour, expectedString: "23d1h", }, { in: "10y", out: 10 365 * 24 * time.Hour, }, } for _, c := range cases { d, err := ParseDuration(c.in) if err != nil { t.Errorf("Unexpected error on input %q", c.in) } if time.Duration(d) != c.out { t.Errorf("Expected %v but got %v", c.out, d) } expectedString := c.expectedString if c.expectedString == "" { expectedString = c.in } if d.String() != expectedString { t.Errorf("Expected duration string %q but got %q", c.in, d.String()) } } } func TestDuration_UnmarshalText(t testing.T) { cases := []struct { in string out time.Duration expectedString string }{ { in: "0", out: 0, expectedString: "0s", }, { in: "0w", out: 0, expectedString: "0s", }, { in: "0s", out: 0, }, { in: "324ms", out: 324 time.Millisecond, }, { in: "3s", out: 3 * time.Second, }, { in: "5m", out: 5 * time.Minute, }, { in: "1h", out: time.Hour, }, { in: "4d", out: 4 * 24 * time.Hour, }, { in: "4d1h", out: 424time.Hour + time.Hour, }, { in: "14d", out: 14 * 24 * time.Hour, expectedString: "2w", }, { in: "3w", out: 3 * 7 * 24 * time.Hour, }, { in: "3w2d1h", out: 3724time.Hour + 224time.Hour + time.Hour, expectedString: "23d1h", }, { in: "10y", out: 10 365 * 24 * time.Hour, }, } for _, c := range cases { var d Duration err := d.UnmarshalText([]byte(c.in)) if err != nil { t.Errorf("Unexpected error on input %q", c.in) } if time.Duration(d) != c.out { t.Errorf("Expected %v but got %v", c.out, d) } expectedString := c.expectedString if c.expectedString == "" { expectedString = c.in } text, _ := d.MarshalText() // MarshalText returns hardcoded nil if string(text) != expectedString { t.Errorf("Expected duration string %q but got %q", c.in, d.String()) } } } func TestDuration_UnmarshalJSON(t testing.T) { cases := []struct { in string out time.Duration expectedString string }{ { in: `"0"`, out: 0, expectedString: `"0s"`, }, { in: `"0w"`, out: 0, expectedString: `"0s"`, }, { in: `"0s"`, out: 0, }, { in: `"324ms"`, out: 324 time.Millisecond, }, { in: `"3s"`, out: 3 * time.Second, }, { in: `"5m"`, out: 5 * time.Minute, }, { in: `"1h"`, out: time.Hour, }, { in: `"4d"`, out: 4 * 24 * time.Hour, }, { in: `"4d1h"`, out: 424time.Hour + time.Hour, }, { in: `"14d"`, out: 14 * 24 * time.Hour, expectedString: `"2w"`, }, { in: `"3w"`, out: 3 * 7 * 24 * time.Hour, }, { in: `"3w2d1h"`, out: 3724time.Hour + 224time.Hour + time.Hour, expectedString: `"23d1h"`, }, { in: `"10y"`, out: 10 365 * 24 * time.Hour, }, { in: `"289y"`, out: 289 * 365 * 24 * time.Hour, }, } for _, c := range cases { var d Duration err := json.Unmarshal([]byte(c.in), &d) if err != nil { t.Errorf("Unexpected error on input %q", c.in) } if time.Duration(d) != c.out { t.Errorf("Expected %v but got %v", c.out, d) } expectedString := c.expectedString if c.expectedString == "" { expectedString = c.in } bytes, err := json.Marshal(d) if err != nil { t.Errorf("Unexpected error on marshal of %v: %s", d, err) } if string(bytes) != expectedString { t.Errorf("Expected duration string %q but got %q", c.in, d.String()) } } } func TestParseBadDuration(t testing.T) { cases := []string{ "1", "1y1m1d", "-1w", "1.5d", "d", "294y", "200y10400w", "107675d", "2584200h", "", } for _, c := range cases { _, err := ParseDuration(c) if err == nil { t.Errorf("Expected error on input %s", c) } } } func TestTimeJSON(t testing.T) { tests := []struct { in Time out string }{ {Time(1), `0.001`}, {Time(-1), `-0.001`}, } for i, test := range tests { t.Run(strconv.Itoa(i), func(t testing.T) { b, err := test.in.MarshalJSON() require.NoErrorf(t, err, "Error marshaling time: %v", err) if string(b) != test.out { t.Errorf("Mismatch in marshal expected=%s actual=%s", test.out, b) } var tm Time err = tm.UnmarshalJSON(b) require.NoErrorf(t, err, "Error Unmarshaling time: %v", err) require.Truef(t, test.in.Equal(tm), "Mismatch after Unmarshal expected=%v actual=%v", test.in, tm) }) } } func BenchmarkParseDuration(b testing.B) { const data = "30s" for i := 0; i < b.N; i++ { _, err := ParseDuration(data) require.NoError(b, err) } }	7.78 KB	2025-05-25 12:27
📄 value.go // Copyright 2013 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 model import ( "encoding/json" "fmt" "sort" "strconv" "strings" ) // ZeroSample is the pseudo zero-value of Sample used to signal a // non-existing sample. It is a Sample with timestamp Earliest, value 0.0, // and metric nil. Note that the natural zero value of Sample has a timestamp // of 0, which is possible to appear in a real Sample and thus not suitable // to signal a non-existing Sample. var ZeroSample = Sample{Timestamp: Earliest} // Sample is a sample pair associated with a metric. A single sample must either // define Value or Histogram but not both. Histogram == nil implies the Value // field is used, otherwise it should be ignored. type Sample struct { Metric Metric `json:"metric"` Value SampleValue `json:"value"` Timestamp Time `json:"timestamp"` Histogram SampleHistogram `json:"histogram"` } // Equal compares first the metrics, then the timestamp, then the value. The // semantics of value equality is defined by SampleValue.Equal. func (s Sample) Equal(o Sample) bool { if s == o { return true } if !s.Metric.Equal(o.Metric) { return false } if !s.Timestamp.Equal(o.Timestamp) { return false } if s.Histogram != nil { return s.Histogram.Equal(o.Histogram) } return s.Value.Equal(o.Value) } func (s Sample) String() string { if s.Histogram != nil { return fmt.Sprintf("%s => %s", s.Metric, SampleHistogramPair{ Timestamp: s.Timestamp, Histogram: s.Histogram, }) } return fmt.Sprintf("%s => %s", s.Metric, SamplePair{ Timestamp: s.Timestamp, Value: s.Value, }) } // MarshalJSON implements json.Marshaler. func (s Sample) MarshalJSON() ([]byte, error) { if s.Histogram != nil { v := struct { Metric Metric `json:"metric"` Histogram SampleHistogramPair `json:"histogram"` }{ Metric: s.Metric, Histogram: SampleHistogramPair{ Timestamp: s.Timestamp, Histogram: s.Histogram, }, } return json.Marshal(&v) } v := struct { Metric Metric `json:"metric"` Value SamplePair `json:"value"` }{ Metric: s.Metric, Value: SamplePair{ Timestamp: s.Timestamp, Value: s.Value, }, } return json.Marshal(&v) } // UnmarshalJSON implements json.Unmarshaler. func (s Sample) UnmarshalJSON(b []byte) error { v := struct { Metric Metric `json:"metric"` Value SamplePair `json:"value"` Histogram SampleHistogramPair `json:"histogram"` }{ Metric: s.Metric, Value: SamplePair{ Timestamp: s.Timestamp, Value: s.Value, }, Histogram: SampleHistogramPair{ Timestamp: s.Timestamp, Histogram: s.Histogram, }, } if err := json.Unmarshal(b, &v); err != nil { return err } s.Metric = v.Metric if v.Histogram.Histogram != nil { s.Timestamp = v.Histogram.Timestamp s.Histogram = v.Histogram.Histogram } else { s.Timestamp = v.Value.Timestamp s.Value = v.Value.Value } return nil } // Samples is a sortable Sample slice. It implements sort.Interface. type Samples []Sample func (s Samples) Len() int { return len(s) } // Less compares first the metrics, then the timestamp. func (s Samples) Less(i, j int) bool { switch { case s[i].Metric.Before(s[j].Metric): return true case s[j].Metric.Before(s[i].Metric): return false case s[i].Timestamp.Before(s[j].Timestamp): return true default: return false } } func (s Samples) Swap(i, j int) { s[i], s[j] = s[j], s[i] } // Equal compares two sets of samples and returns true if they are equal. func (s Samples) Equal(o Samples) bool { if len(s) != len(o) { return false } for i, sample := range s { if !sample.Equal(o[i]) { return false } } return true } // SampleStream is a stream of Values belonging to an attached COWMetric. type SampleStream struct { Metric Metric `json:"metric"` Values []SamplePair `json:"values"` Histograms []SampleHistogramPair `json:"histograms"` } func (ss SampleStream) String() string { valuesLength := len(ss.Values) vals := make([]string, valuesLength+len(ss.Histograms)) for i, v := range ss.Values { vals[i] = v.String() } for i, v := range ss.Histograms { vals[i+valuesLength] = v.String() } return fmt.Sprintf("%s =>\n%s", ss.Metric, strings.Join(vals, "\n")) } func (ss SampleStream) MarshalJSON() ([]byte, error) { if len(ss.Histograms) > 0 && len(ss.Values) > 0 { v := struct { Metric Metric `json:"metric"` Values []SamplePair `json:"values"` Histograms []SampleHistogramPair `json:"histograms"` }{ Metric: ss.Metric, Values: ss.Values, Histograms: ss.Histograms, } return json.Marshal(&v) } else if len(ss.Histograms) > 0 { v := struct { Metric Metric `json:"metric"` Histograms []SampleHistogramPair `json:"histograms"` }{ Metric: ss.Metric, Histograms: ss.Histograms, } return json.Marshal(&v) } else { v := struct { Metric Metric `json:"metric"` Values []SamplePair `json:"values"` }{ Metric: ss.Metric, Values: ss.Values, } return json.Marshal(&v) } } func (ss SampleStream) UnmarshalJSON(b []byte) error { v := struct { Metric Metric `json:"metric"` Values []SamplePair `json:"values"` Histograms []SampleHistogramPair `json:"histograms"` }{ Metric: ss.Metric, Values: ss.Values, Histograms: ss.Histograms, } if err := json.Unmarshal(b, &v); err != nil { return err } ss.Metric = v.Metric ss.Values = v.Values ss.Histograms = v.Histograms return nil } // Scalar is a scalar value evaluated at the set timestamp. type Scalar struct { Value SampleValue `json:"value"` Timestamp Time `json:"timestamp"` } func (s Scalar) String() string { return fmt.Sprintf("scalar: %v @[%v]", s.Value, s.Timestamp) } // MarshalJSON implements json.Marshaler. func (s Scalar) MarshalJSON() ([]byte, error) { v := strconv.FormatFloat(float64(s.Value), 'f', -1, 64) return json.Marshal([...]interface{}{s.Timestamp, string(v)}) } // UnmarshalJSON implements json.Unmarshaler. func (s Scalar) UnmarshalJSON(b []byte) error { var f string v := [...]interface{}{&s.Timestamp, &f} if err := json.Unmarshal(b, &v); err != nil { return err } value, err := strconv.ParseFloat(f, 64) if err != nil { return fmt.Errorf("error parsing sample value: %w", err) } s.Value = SampleValue(value) return nil } // String is a string value evaluated at the set timestamp. type String struct { Value string `json:"value"` Timestamp Time `json:"timestamp"` } func (s String) String() string { return s.Value } // MarshalJSON implements json.Marshaler. func (s String) MarshalJSON() ([]byte, error) { return json.Marshal([]interface{}{s.Timestamp, s.Value}) } // UnmarshalJSON implements json.Unmarshaler. func (s String) UnmarshalJSON(b []byte) error { v := [...]interface{}{&s.Timestamp, &s.Value} return json.Unmarshal(b, &v) } // Vector is basically only an alias for Samples, but the // contract is that in a Vector, all Samples have the same timestamp. type Vector []Sample func (vec Vector) String() string { entries := make([]string, len(vec)) for i, s := range vec { entries[i] = s.String() } return strings.Join(entries, "\n") } func (vec Vector) Len() int { return len(vec) } func (vec Vector) Swap(i, j int) { vec[i], vec[j] = vec[j], vec[i] } // Less compares first the metrics, then the timestamp. func (vec Vector) Less(i, j int) bool { switch { case vec[i].Metric.Before(vec[j].Metric): return true case vec[j].Metric.Before(vec[i].Metric): return false case vec[i].Timestamp.Before(vec[j].Timestamp): return true default: return false } } // Equal compares two sets of samples and returns true if they are equal. func (vec Vector) Equal(o Vector) bool { if len(vec) != len(o) { return false } for i, sample := range vec { if !sample.Equal(o[i]) { return false } } return true } // Matrix is a list of time series. type Matrix []*SampleStream func (m Matrix) Len() int { return len(m) } func (m Matrix) Less(i, j int) bool { return m[i].Metric.Before(m[j].Metric) } func (m Matrix) Swap(i, j int) { m[i], m[j] = m[j], m[i] } func (mat Matrix) String() string { matCp := make(Matrix, len(mat)) copy(matCp, mat) sort.Sort(matCp) strs := make([]string, len(matCp)) for i, ss := range matCp { strs[i] = ss.String() } return strings.Join(strs, "\n") }	8.86 KB	2025-05-25 12:27
📄 value_float.go // Copyright 2013 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 model import ( "encoding/json" "errors" "fmt" "math" "strconv" ) // ZeroSamplePair is the pseudo zero-value of SamplePair used to signal a // non-existing sample pair. It is a SamplePair with timestamp Earliest and // value 0.0. Note that the natural zero value of SamplePair has a timestamp // of 0, which is possible to appear in a real SamplePair and thus not // suitable to signal a non-existing SamplePair. var ZeroSamplePair = SamplePair{Timestamp: Earliest} // A SampleValue is a representation of a value for a given sample at a given // time. type SampleValue float64 // MarshalJSON implements json.Marshaler. func (v SampleValue) MarshalJSON() ([]byte, error) { return json.Marshal(v.String()) } // UnmarshalJSON implements json.Unmarshaler. func (v SampleValue) UnmarshalJSON(b []byte) error { if len(b) < 2 \|\| b[0] != '"' \|\| b[len(b)-1] != '"' { return errors.New("sample value must be a quoted string") } f, err := strconv.ParseFloat(string(b[1:len(b)-1]), 64) if err != nil { return err } v = SampleValue(f) return nil } // Equal returns true if the value of v and o is equal or if both are NaN. Note // that v==o is false if both are NaN. If you want the conventional float // behavior, use == to compare two SampleValues. func (v SampleValue) Equal(o SampleValue) bool { if v == o { return true } return math.IsNaN(float64(v)) && math.IsNaN(float64(o)) } func (v SampleValue) String() string { return strconv.FormatFloat(float64(v), 'f', -1, 64) } // SamplePair pairs a SampleValue with a Timestamp. type SamplePair struct { Timestamp Time Value SampleValue } func (s SamplePair) MarshalJSON() ([]byte, error) { t, err := json.Marshal(s.Timestamp) if err != nil { return nil, err } v, err := json.Marshal(s.Value) if err != nil { return nil, err } return []byte(fmt.Sprintf("[%s,%s]", t, v)), nil } // UnmarshalJSON implements json.Unmarshaler. func (s SamplePair) UnmarshalJSON(b []byte) error { v := [...]json.Unmarshaler{&s.Timestamp, &s.Value} return json.Unmarshal(b, &v) } // Equal returns true if this SamplePair and o have equal Values and equal // Timestamps. The semantics of Value equality is defined by SampleValue.Equal. func (s SamplePair) Equal(o *SamplePair) bool { return s == o \|\| (s.Value.Equal(o.Value) && s.Timestamp.Equal(o.Timestamp)) } func (s SamplePair) String() string { return fmt.Sprintf("%s @[%s]", s.Value, s.Timestamp) }	2.96 KB	2025-05-25 12:27
📄 value_float_test.go // Copyright 2013 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 model import ( "encoding/json" "math" "reflect" "testing" "github.com/stretchr/testify/require" ) var ( samplePairMatrixPlain = `[{"metric":{"__name__":"test_metric"},"values":[[1234.567,"123.1"],[12345.678,"123.12"]]},{"metric":{"foo":"bar"},"values":[[2234.567,"223.1"],[22345.678,"223.12"]]}]` samplePairMatrixValue = Matrix{ &SampleStream{ Metric: Metric{ MetricNameLabel: "test_metric", }, Values: []SamplePair{ { Value: 123.1, Timestamp: 1234567, }, { Value: 123.12, Timestamp: 12345678, }, }, }, &SampleStream{ Metric: Metric{ "foo": "bar", }, Values: []SamplePair{ { Value: 223.1, Timestamp: 2234567, }, { Value: 223.12, Timestamp: 22345678, }, }, }, } ) func TestEqualValues(t testing.T) { tests := map[string]struct { in1, in2 SampleValue want bool }{ "equal floats": { in1: 3.14, in2: 3.14, want: true, }, "unequal floats": { in1: 3.14, in2: 3.1415, want: false, }, "positive infinities": { in1: SampleValue(math.Inf(+1)), in2: SampleValue(math.Inf(+1)), want: true, }, "negative infinities": { in1: SampleValue(math.Inf(-1)), in2: SampleValue(math.Inf(-1)), want: true, }, "different infinities": { in1: SampleValue(math.Inf(+1)), in2: SampleValue(math.Inf(-1)), want: false, }, "number and infinity": { in1: 42, in2: SampleValue(math.Inf(+1)), want: false, }, "number and NaN": { in1: 42, in2: SampleValue(math.NaN()), want: false, }, "NaNs": { in1: SampleValue(math.NaN()), in2: SampleValue(math.NaN()), want: true, // !!! }, } for name, test := range tests { got := test.in1.Equal(test.in2) if got != test.want { t.Errorf("Comparing %s, %f and %f: got %t, want %t", name, test.in1, test.in2, got, test.want) } } } func TestSamplePairJSON(t testing.T) { input := []struct { plain string value SamplePair }{ { plain: `[1234.567,"123.1"]`, value: SamplePair{ Value: 123.1, Timestamp: 1234567, }, }, } for _, test := range input { b, err := json.Marshal(test.value) if err != nil { t.Error(err) continue } if string(b) != test.plain { t.Errorf("encoding error: expected %q, got %q", test.plain, b) continue } var sp SamplePair err = json.Unmarshal(b, &sp) if err != nil { t.Error(err) continue } if sp != test.value { t.Errorf("decoding error: expected %v, got %v", test.value, sp) } } } func TestSampleJSON(t testing.T) { input := []struct { plain string value Sample }{ { plain: `{"metric":{"__name__":"test_metric"},"value":[1234.567,"123.1"]}`, value: Sample{ Metric: Metric{ MetricNameLabel: "test_metric", }, Value: 123.1, Timestamp: 1234567, }, }, } for _, test := range input { b, err := json.Marshal(test.value) if err != nil { t.Error(err) continue } if string(b) != test.plain { t.Errorf("encoding error: expected %q, got %q", test.plain, b) continue } var sv Sample err = json.Unmarshal(b, &sv) if err != nil { t.Error(err) continue } if !reflect.DeepEqual(sv, test.value) { t.Errorf("decoding error: expected %v, got %v", test.value, sv) } } } func TestVectorJSON(t testing.T) { input := []struct { plain string value Vector }{ { plain: `[]`, value: Vector{}, }, { plain: `[{"metric":{"__name__":"test_metric"},"value":[1234.567,"123.1"]}]`, value: Vector{&Sample{ Metric: Metric{ MetricNameLabel: "test_metric", }, Value: 123.1, Timestamp: 1234567, }}, }, { plain: `[{"metric":{"__name__":"test_metric"},"value":[1234.567,"123.1"]},{"metric":{"foo":"bar"},"value":[1.234,"+Inf"]}]`, value: Vector{ &Sample{ Metric: Metric{ MetricNameLabel: "test_metric", }, Value: 123.1, Timestamp: 1234567, }, &Sample{ Metric: Metric{ "foo": "bar", }, Value: SampleValue(math.Inf(1)), Timestamp: 1234, }, }, }, } for _, test := range input { b, err := json.Marshal(test.value) if err != nil { t.Error(err) continue } if string(b) != test.plain { t.Errorf("encoding error: expected %q, got %q", test.plain, b) continue } var vec Vector err = json.Unmarshal(b, &vec) if err != nil { t.Error(err) continue } if !reflect.DeepEqual(vec, test.value) { t.Errorf("decoding error: expected %v, got %v", test.value, vec) } } } func TestMatrixJSON(t testing.T) { input := []struct { plain string value Matrix }{ { plain: `[]`, value: Matrix{}, }, { plain: samplePairMatrixPlain, value: samplePairMatrixValue, }, } for _, test := range input { b, err := json.Marshal(test.value) if err != nil { t.Error(err) continue } if string(b) != test.plain { t.Errorf("encoding error: expected %q, got %q", test.plain, b) continue } var mat Matrix err = json.Unmarshal(b, &mat) if err != nil { t.Error(err) continue } if !reflect.DeepEqual(mat, test.value) { t.Errorf("decoding error: expected %v, got %v", test.value, mat) } } } func BenchmarkJSONMarshallingSamplePairMatrix(b testing.B) { for i := 0; i < b.N; i++ { _, err := json.Marshal(samplePairMatrixValue) require.NoErrorf(b, err, "error marshalling") } }	5.9 KB	2025-05-25 12:27
📄 value_histogram.go // Copyright 2013 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 model import ( "encoding/json" "errors" "fmt" "strconv" "strings" ) type FloatString float64 func (v FloatString) String() string { return strconv.FormatFloat(float64(v), 'f', -1, 64) } func (v FloatString) MarshalJSON() ([]byte, error) { return json.Marshal(v.String()) } func (v FloatString) UnmarshalJSON(b []byte) error { if len(b) < 2 \|\| b[0] != '"' \|\| b[len(b)-1] != '"' { return errors.New("float value must be a quoted string") } f, err := strconv.ParseFloat(string(b[1:len(b)-1]), 64) if err != nil { return err } v = FloatString(f) return nil } type HistogramBucket struct { Boundaries int32 Lower FloatString Upper FloatString Count FloatString } func (s HistogramBucket) MarshalJSON() ([]byte, error) { b, err := json.Marshal(s.Boundaries) if err != nil { return nil, err } l, err := json.Marshal(s.Lower) if err != nil { return nil, err } u, err := json.Marshal(s.Upper) if err != nil { return nil, err } c, err := json.Marshal(s.Count) if err != nil { return nil, err } return []byte(fmt.Sprintf("[%s,%s,%s,%s]", b, l, u, c)), nil } func (s HistogramBucket) UnmarshalJSON(buf []byte) error { tmp := []interface{}{&s.Boundaries, &s.Lower, &s.Upper, &s.Count} wantLen := len(tmp) if err := json.Unmarshal(buf, &tmp); err != nil { return err } if gotLen := len(tmp); gotLen != wantLen { return fmt.Errorf("wrong number of fields: %d != %d", gotLen, wantLen) } return nil } func (s HistogramBucket) Equal(o HistogramBucket) bool { return s == o \|\| (s.Boundaries == o.Boundaries && s.Lower == o.Lower && s.Upper == o.Upper && s.Count == o.Count) } func (b HistogramBucket) String() string { var sb strings.Builder lowerInclusive := b.Boundaries == 1 \|\| b.Boundaries == 3 upperInclusive := b.Boundaries == 0 \|\| b.Boundaries == 3 if lowerInclusive { sb.WriteRune('[') } else { sb.WriteRune('(') } fmt.Fprintf(&sb, "%g,%g", b.Lower, b.Upper) if upperInclusive { sb.WriteRune(']') } else { sb.WriteRune(')') } fmt.Fprintf(&sb, ":%v", b.Count) return sb.String() } type HistogramBuckets []HistogramBucket func (s HistogramBuckets) Equal(o HistogramBuckets) bool { if len(s) != len(o) { return false } for i, bucket := range s { if !bucket.Equal(o[i]) { return false } } return true } type SampleHistogram struct { Count FloatString `json:"count"` Sum FloatString `json:"sum"` Buckets HistogramBuckets `json:"buckets"` } func (s SampleHistogram) String() string { return fmt.Sprintf("Count: %f, Sum: %f, Buckets: %v", s.Count, s.Sum, s.Buckets) } func (s SampleHistogram) Equal(o SampleHistogram) bool { return s == o \|\| (s.Count == o.Count && s.Sum == o.Sum && s.Buckets.Equal(o.Buckets)) } type SampleHistogramPair struct { Timestamp Time // Histogram should never be nil, it's only stored as pointer for efficiency. Histogram SampleHistogram } func (s SampleHistogramPair) MarshalJSON() ([]byte, error) { if s.Histogram == nil { return nil, errors.New("histogram is nil") } t, err := json.Marshal(s.Timestamp) if err != nil { return nil, err } v, err := json.Marshal(s.Histogram) if err != nil { return nil, err } return []byte(fmt.Sprintf("[%s,%s]", t, v)), nil } func (s SampleHistogramPair) UnmarshalJSON(buf []byte) error { tmp := []interface{}{&s.Timestamp, &s.Histogram} wantLen := len(tmp) if err := json.Unmarshal(buf, &tmp); err != nil { return err } if gotLen := len(tmp); gotLen != wantLen { return fmt.Errorf("wrong number of fields: %d != %d", gotLen, wantLen) } if s.Histogram == nil { return errors.New("histogram is null") } return nil } func (s SampleHistogramPair) String() string { return fmt.Sprintf("%s @[%s]", s.Histogram, s.Timestamp) } func (s SampleHistogramPair) Equal(o SampleHistogramPair) bool { return s == o \|\| (s.Histogram.Equal(o.Histogram) && s.Timestamp.Equal(o.Timestamp)) }	4.41 KB	2025-05-25 12:27
📄 value_histogram_test.go // Copyright 2013 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 model import ( "encoding/json" "reflect" "regexp" "testing" "github.com/stretchr/testify/require" ) var ( noWhitespace = regexp.MustCompile(`\s`) sampleHistogramPairMatrixPlain = `[ { "metric":{ "__name__":"test_metric" }, "histograms":[ [ 1234.567, { "count":"6", "sum":"3897", "buckets":[ [ 1, "-4870.992343051145", "-4466.7196729968955", "1" ], [ 1, "-861.0779292198035", "-789.6119426088657", "1" ], [ 1, "-558.3399591246119", "-512", "1" ], [ 0, "2048", "2233.3598364984477", "1" ], [ 0, "2896.3093757400984", "3158.4477704354626", "1" ], [ 0, "4466.7196729968955", "4870.992343051145", "1" ] ] } ], [ 12345.678, { "count":"6", "sum":"3897", "buckets":[ [ 1, "-4870.992343051145", "-4466.7196729968955", "1" ], [ 1, "-861.0779292198035", "-789.6119426088657", "1" ], [ 1, "-558.3399591246119", "-512", "1" ], [ 0, "2048", "2233.3598364984477", "1" ], [ 0, "2896.3093757400984", "3158.4477704354626", "1" ], [ 0, "4466.7196729968955", "4870.992343051145", "1" ] ] } ] ] }, { "metric":{ "foo":"bar" }, "histograms":[ [ 2234.567, { "count":"6", "sum":"3897", "buckets":[ [ 1, "-4870.992343051145", "-4466.7196729968955", "1" ], [ 1, "-861.0779292198035", "-789.6119426088657", "1" ], [ 1, "-558.3399591246119", "-512", "1" ], [ 0, "2048", "2233.3598364984477", "1" ], [ 0, "2896.3093757400984", "3158.4477704354626", "1" ], [ 0, "4466.7196729968955", "4870.992343051145", "1" ] ] } ], [ 22345.678, { "count":"6", "sum":"3897", "buckets":[ [ 1, "-4870.992343051145", "-4466.7196729968955", "1" ], [ 1, "-861.0779292198035", "-789.6119426088657", "1" ], [ 1, "-558.3399591246119", "-512", "1" ], [ 0, "2048", "2233.3598364984477", "1" ], [ 0, "2896.3093757400984", "3158.4477704354626", "1" ], [ 0, "4466.7196729968955", "4870.992343051145", "1" ] ] } ] ] } ]` sampleHistogramPairMatrixValue = Matrix{ &SampleStream{ Metric: Metric{ MetricNameLabel: "test_metric", }, Histograms: []SampleHistogramPair{ { Histogram: genSampleHistogram(), Timestamp: 1234567, }, { Histogram: genSampleHistogram(), Timestamp: 12345678, }, }, }, &SampleStream{ Metric: Metric{ "foo": "bar", }, Histograms: []SampleHistogramPair{ { Histogram: genSampleHistogram(), Timestamp: 2234567, }, { Histogram: genSampleHistogram(), Timestamp: 22345678, }, }, }, } ) func genSampleHistogram() SampleHistogram { return &SampleHistogram{ Count: 6, Sum: 3897, Buckets: HistogramBuckets{ { Boundaries: 1, Lower: -4870.992343051145, Upper: -4466.7196729968955, Count: 1, }, { Boundaries: 1, Lower: -861.0779292198035, Upper: -789.6119426088657, Count: 1, }, { Boundaries: 1, Lower: -558.3399591246119, Upper: -512, Count: 1, }, { Boundaries: 0, Lower: 2048, Upper: 2233.3598364984477, Count: 1, }, { Boundaries: 0, Lower: 2896.3093757400984, Upper: 3158.4477704354626, Count: 1, }, { Boundaries: 0, Lower: 4466.7196729968955, Upper: 4870.992343051145, Count: 1, }, }, } } func TestSampleHistogramPairJSON(t testing.T) { input := []struct { plain string value SampleHistogramPair }{ { plain: `[ 1234.567, { "count":"6", "sum":"3897", "buckets":[ [ 1, "-4870.992343051145", "-4466.7196729968955", "1" ], [ 1, "-861.0779292198035", "-789.6119426088657", "1" ], [ 1, "-558.3399591246119", "-512", "1" ], [ 0, "2048", "2233.3598364984477", "1" ], [ 0, "2896.3093757400984", "3158.4477704354626", "1" ], [ 0, "4466.7196729968955", "4870.992343051145", "1" ] ] } ]`, value: SampleHistogramPair{ Histogram: genSampleHistogram(), Timestamp: 1234567, }, }, } for _, test := range input { b, err := json.Marshal(test.value) if err != nil { t.Error(err) continue } trimmed := noWhitespace.ReplaceAllString(test.plain, "") if string(b) != trimmed { t.Errorf("encoding error: expected %q, got %q", trimmed, b) continue } var sp SampleHistogramPair err = json.Unmarshal(b, &sp) if err != nil { t.Error(err) continue } if !sp.Equal(&test.value) { t.Errorf("decoding error: expected %v, got %v", test.value, sp) } } } func TestInvalidSampleHistogramPairJSON(t testing.T) { s1 := SampleHistogramPair{ Timestamp: 1, Histogram: nil, } d, err := json.Marshal(s1) if err == nil { t.Errorf("expected error when trying to marshal invalid SampleHistogramPair %s", string(d)) } var s2 SampleHistogramPair plain := "[0.001,null]" err = json.Unmarshal([]byte(plain), &s2) if err == nil { t.Errorf("expected error when trying to unmarshal invalid SampleHistogramPair %s", plain) } } func TestSampleHistogramJSON(t testing.T) { input := []struct { plain string value Sample }{ { plain: `{ "metric":{ "__name__":"test_metric" }, "histogram":[ 1234.567, { "count":"6", "sum":"3897", "buckets":[ [ 1, "-4870.992343051145", "-4466.7196729968955", "1" ], [ 1, "-861.0779292198035", "-789.6119426088657", "1" ], [ 1, "-558.3399591246119", "-512", "1" ], [ 0, "2048", "2233.3598364984477", "1" ], [ 0, "2896.3093757400984", "3158.4477704354626", "1" ], [ 0, "4466.7196729968955", "4870.992343051145", "1" ] ] } ] }`, value: Sample{ Metric: Metric{ MetricNameLabel: "test_metric", }, Histogram: genSampleHistogram(), Timestamp: 1234567, }, }, } for _, test := range input { b, err := json.Marshal(test.value) if err != nil { t.Error(err) continue } trimmed := noWhitespace.ReplaceAllString(test.plain, "") if string(b) != trimmed { t.Errorf("encoding error: expected %q, got %q", trimmed, b) continue } var sv Sample err = json.Unmarshal(b, &sv) if err != nil { t.Error(err) continue } if !reflect.DeepEqual(sv, test.value) { t.Errorf("decoding error: expected %v, got %v", test.value, sv) } } } func TestVectorHistogramJSON(t testing.T) { input := []struct { plain string value Vector }{ { plain: `[ { "metric":{ "__name__":"test_metric" }, "histogram":[ 1234.567, { "count":"6", "sum":"3897", "buckets":[ [ 1, "-4870.992343051145", "-4466.7196729968955", "1" ], [ 1, "-861.0779292198035", "-789.6119426088657", "1" ], [ 1, "-558.3399591246119", "-512", "1" ], [ 0, "2048", "2233.3598364984477", "1" ], [ 0, "2896.3093757400984", "3158.4477704354626", "1" ], [ 0, "4466.7196729968955", "4870.992343051145", "1" ] ] } ] } ]`, value: Vector{&Sample{ Metric: Metric{ MetricNameLabel: "test_metric", }, Histogram: genSampleHistogram(), Timestamp: 1234567, }}, }, { plain: `[ { "metric":{ "__name__":"test_metric" }, "histogram":[ 1234.567, { "count":"6", "sum":"3897", "buckets":[ [ 1, "-4870.992343051145", "-4466.7196729968955", "1" ], [ 1, "-861.0779292198035", "-789.6119426088657", "1" ], [ 1, "-558.3399591246119", "-512", "1" ], [ 0, "2048", "2233.3598364984477", "1" ], [ 0, "2896.3093757400984", "3158.4477704354626", "1" ], [ 0, "4466.7196729968955", "4870.992343051145", "1" ] ] } ] }, { "metric":{ "foo":"bar" }, "histogram":[ 1.234, { "count":"6", "sum":"3897", "buckets":[ [ 1, "-4870.992343051145", "-4466.7196729968955", "1" ], [ 1, "-861.0779292198035", "-789.6119426088657", "1" ], [ 1, "-558.3399591246119", "-512", "1" ], [ 0, "2048", "2233.3598364984477", "1" ], [ 0, "2896.3093757400984", "3158.4477704354626", "1" ], [ 0, "4466.7196729968955", "4870.992343051145", "1" ] ] } ] } ]`, value: Vector{ &Sample{ Metric: Metric{ MetricNameLabel: "test_metric", }, Histogram: genSampleHistogram(), Timestamp: 1234567, }, &Sample{ Metric: Metric{ "foo": "bar", }, Histogram: genSampleHistogram(), Timestamp: 1234, }, }, }, } for _, test := range input { b, err := json.Marshal(test.value) if err != nil { t.Error(err) continue } trimmed := noWhitespace.ReplaceAllString(test.plain, "") if string(b) != trimmed { t.Errorf("encoding error: expected %q, got %q", trimmed, b) continue } var vec Vector err = json.Unmarshal(b, &vec) if err != nil { t.Error(err) continue } if !reflect.DeepEqual(vec, test.value) { t.Errorf("decoding error: expected %v, got %v", test.value, vec) } } } func TestMatrixHistogramJSON(t testing.T) { input := []struct { plain string value Matrix }{ { plain: `[]`, value: Matrix{}, }, { plain: sampleHistogramPairMatrixPlain, value: sampleHistogramPairMatrixValue, }, } for _, test := range input { b, err := json.Marshal(test.value) if err != nil { t.Error(err) continue } trimmed := noWhitespace.ReplaceAllString(test.plain, "") if string(b) != trimmed { t.Errorf("encoding error: expected %q, got %q", trimmed, b) continue } var mat Matrix err = json.Unmarshal(b, &mat) if err != nil { t.Error(err) continue } if !reflect.DeepEqual(mat, test.value) { t.Errorf("decoding error: expected %v, got %v", test.value, mat) } } } func BenchmarkJSONMarshallingSampleHistogramPairMatrix(b *testing.B) { for i := 0; i < b.N; i++ { _, err := json.Marshal(sampleHistogramPairMatrixValue) require.NoErrorf(b, err, "error marshalling") } }	12.47 KB	2025-05-25 12:27
📄 value_test.go // Copyright 2013 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 model import ( "encoding/json" "math" "sort" "testing" "github.com/stretchr/testify/require" ) func TestEqualSamples(t testing.T) { testSample := &Sample{} tests := map[string]struct { in1, in2 Sample want bool }{ "equal pointers": { in1: testSample, in2: testSample, want: true, }, "different metrics": { in1: &Sample{Metric: Metric{"foo": "bar"}}, in2: &Sample{Metric: Metric{"foo": "biz"}}, want: false, }, "different timestamp": { in1: &Sample{Timestamp: 0}, in2: &Sample{Timestamp: 1}, want: false, }, "different value": { in1: &Sample{Value: 0}, in2: &Sample{Value: 1}, want: false, }, "equal samples": { in1: &Sample{ Metric: Metric{"foo": "bar"}, Timestamp: 0, Value: 1, }, in2: &Sample{ Metric: Metric{"foo": "bar"}, Timestamp: 0, Value: 1, }, want: true, }, "equal histograms": { in1: &Sample{ Metric: Metric{"foo": "bar"}, Timestamp: 0, Histogram: genSampleHistogram(), }, in2: &Sample{ Metric: Metric{"foo": "bar"}, Timestamp: 0, Histogram: genSampleHistogram(), }, want: true, }, "different histogram counts": { in1: &Sample{ Metric: Metric{"foo": "bar"}, Timestamp: 0, Histogram: &SampleHistogram{ Count: 2, Sum: 4500, Buckets: HistogramBuckets{ { Boundaries: 0, Lower: 4466.7196729968955, Upper: 4870.992343051145, Count: 1, }, }, }, }, in2: &Sample{ Metric: Metric{"foo": "bar"}, Timestamp: 0, Histogram: genSampleHistogram(), }, want: false, }, "different histogram sums": { in1: &Sample{ Metric: Metric{"foo": "bar"}, Timestamp: 0, Histogram: &SampleHistogram{ Count: 1, Sum: 4500.01, Buckets: HistogramBuckets{ { Boundaries: 0, Lower: 4466.7196729968955, Upper: 4870.992343051145, Count: 1, }, }, }, }, in2: &Sample{ Metric: Metric{"foo": "bar"}, Timestamp: 0, Histogram: genSampleHistogram(), }, want: false, }, "different histogram inner counts": { in1: &Sample{ Metric: Metric{"foo": "bar"}, Timestamp: 0, Histogram: &SampleHistogram{ Count: 1, Sum: 4500, Buckets: HistogramBuckets{ { Boundaries: 0, Lower: 4466.7196729968955, Upper: 4870.992343051145, Count: 2, }, }, }, }, in2: &Sample{ Metric: Metric{"foo": "bar"}, Timestamp: 0, Histogram: genSampleHistogram(), }, want: false, }, } for name, test := range tests { got := test.in1.Equal(test.in2) if got != test.want { t.Errorf("Comparing %s, %v and %v: got %t, want %t", name, test.in1, test.in2, got, test.want) } } } func TestScalarJSON(t testing.T) { input := []struct { plain string value Scalar }{ { plain: `[123.456,"456"]`, value: Scalar{ Timestamp: 123456, Value: 456, }, }, { plain: `[123123.456,"+Inf"]`, value: Scalar{ Timestamp: 123123456, Value: SampleValue(math.Inf(1)), }, }, { plain: `[123123.456,"-Inf"]`, value: Scalar{ Timestamp: 123123456, Value: SampleValue(math.Inf(-1)), }, }, } for _, test := range input { b, err := json.Marshal(test.value) if err != nil { t.Error(err) continue } if string(b) != test.plain { t.Errorf("encoding error: expected %q, got %q", test.plain, b) continue } var sv Scalar err = json.Unmarshal(b, &sv) if err != nil { t.Error(err) continue } if sv != test.value { t.Errorf("decoding error: expected %v, got %v", test.value, sv) } } } func TestStringJSON(t testing.T) { input := []struct { plain string value String }{ { plain: `[123.456,"test"]`, value: String{ Timestamp: 123456, Value: "test", }, }, { plain: `[123123.456,"台北"]`, value: String{ Timestamp: 123123456, Value: "台北", }, }, } for _, test := range input { b, err := json.Marshal(test.value) if err != nil { t.Error(err) continue } if string(b) != test.plain { t.Errorf("encoding error: expected %q, got %q", test.plain, b) continue } var sv String err = json.Unmarshal(b, &sv) if err != nil { t.Error(err) continue } if sv != test.value { t.Errorf("decoding error: expected %v, got %v", test.value, sv) } } } func TestVectorSort(t *testing.T) { input := Vector{ &Sample{ Metric: Metric{ MetricNameLabel: "A", }, Timestamp: 1, }, &Sample{ Metric: Metric{ MetricNameLabel: "A", }, Timestamp: 2, }, &Sample{ Metric: Metric{ MetricNameLabel: "C", }, Timestamp: 1, }, &Sample{ Metric: Metric{ MetricNameLabel: "C", }, Timestamp: 2, }, &Sample{ Metric: Metric{ MetricNameLabel: "B", }, Timestamp: 3, }, &Sample{ Metric: Metric{ MetricNameLabel: "B", }, Timestamp: 2, }, &Sample{ Metric: Metric{ MetricNameLabel: "B", }, Timestamp: 1, }, } expected := Vector{ &Sample{ Metric: Metric{ MetricNameLabel: "A", }, Timestamp: 1, }, &Sample{ Metric: Metric{ MetricNameLabel: "A", }, Timestamp: 2, }, &Sample{ Metric: Metric{ MetricNameLabel: "B", }, Timestamp: 1, }, &Sample{ Metric: Metric{ MetricNameLabel: "B", }, Timestamp: 2, }, &Sample{ Metric: Metric{ MetricNameLabel: "B", }, Timestamp: 3, }, &Sample{ Metric: Metric{ MetricNameLabel: "C", }, Timestamp: 1, }, &Sample{ Metric: Metric{ MetricNameLabel: "C", }, Timestamp: 2, }, } sort.Sort(input) for i, actual := range input { actualFp := actual.Metric.Fingerprint() expectedFp := expected[i].Metric.Fingerprint() require.Equalf(t, expectedFp, actualFp, "%d. Incorrect fingerprint. Got %s; want %s", i, actualFp.String(), expectedFp.String()) require.Equalf(t, actual.Timestamp, expected[i].Timestamp, "%d. Incorrect timestamp. Got %s; want %s", i, actual.Timestamp, expected[i].Timestamp) } }	6.67 KB	2025-05-25 12:27
📄 value_type.go // Copyright 2013 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 model import ( "encoding/json" "fmt" ) // Value is a generic interface for values resulting from a query evaluation. type Value interface { Type() ValueType String() string } func (Matrix) Type() ValueType { return ValMatrix } func (Vector) Type() ValueType { return ValVector } func (Scalar) Type() ValueType { return ValScalar } func (String) Type() ValueType { return ValString } type ValueType int const ( ValNone ValueType = iota ValScalar ValVector ValMatrix ValString ) // MarshalJSON implements json.Marshaler. func (et ValueType) MarshalJSON() ([]byte, error) { return json.Marshal(et.String()) } func (et ValueType) UnmarshalJSON(b []byte) error { var s string if err := json.Unmarshal(b, &s); err != nil { return err } switch s { case "<ValNone>": et = ValNone case "scalar": et = ValScalar case "vector": et = ValVector case "matrix": et = ValMatrix case "string": et = ValString default: return fmt.Errorf("unknown value type %q", s) } return nil } func (e ValueType) String() string { switch e { case ValNone: return "<ValNone>" case ValScalar: return "scalar" case ValVector: return "vector" case ValMatrix: return "matrix" case ValString: return "string" } panic("ValueType.String: unhandled value type") }	1.85 KB	2025-05-25 12:27

Edit File:

Terminal