mudhorn/prometheus
1
0
Fork 0
mirror of https://github.com/prometheus/prometheus.git synced 2025-03-05 20:59:13 -08:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

rules: in tests use labels.FromStrings

Browse source 
And a number of `EmptyLabels()` instead of `nil`.
Replacing code which assumes the internal structure of `Labels`.

Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
This commit is contained in:
Bryan Boreham 2022-07-21 16:44:35 +00:00 committed by Julien Pivotto
parent 3029320ce6
commit 8297f5cb6b
2 changed files with 62 additions and 62 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
rules/alerting_test.go
View file

@ -63,7 +63,7 @@ func TestAlertingRuleState(t *testing.T) {
} }
for i, test := range tests { for i, test := range tests {
rule := NewAlertingRule(test.name, nil, 0, nil, nil, nil, "", true, nil) rule := NewAlertingRule(test.name, nil, 0, labels.EmptyLabels(), labels.EmptyLabels(), labels.EmptyLabels(), "", true, nil)
rule.active = test.active rule.active = test.active
got := rule.State() got := rule.State()
require.Equal(t, test.want, got, "test case %d unexpected AlertState, want:%d got:%d", i, test.want, got) require.Equal(t, test.want, got, "test case %d unexpected AlertState, want:%d got:%d", i, test.want, got)
@ -91,7 +91,7 @@ func TestAlertingRuleLabelsUpdate(t *testing.T) {
// If an alert is going back and forth between two label values it will never fire. // If an alert is going back and forth between two label values it will never fire.
// Instead, you should write two alerts with constant labels. // Instead, you should write two alerts with constant labels.
labels.FromStrings("severity", "{{ if lt $value 80.0 }}critical{{ else }}warning{{ end }}"), labels.FromStrings("severity", "{{ if lt $value 80.0 }}critical{{ else }}warning{{ end }}"),
nil, nil, "", true, nil, labels.EmptyLabels(), labels.EmptyLabels(), "", true, nil,
) )
results := []promql.Vector{ results := []promql.Vector{
@ -190,8 +190,8 @@ func TestAlertingRuleExternalLabelsInTemplate(t *testing.T) {
expr, expr,
time.Minute, time.Minute,
labels.FromStrings("templated_label", "There are {{ len $externalLabels }} external Labels, of which foo is {{ $externalLabels.foo }}."), labels.FromStrings("templated_label", "There are {{ len $externalLabels }} external Labels, of which foo is {{ $externalLabels.foo }}."),
nil, labels.EmptyLabels(),
nil, labels.EmptyLabels(),
"", "",
true, log.NewNopLogger(), true, log.NewNopLogger(),
) )
@ -200,7 +200,7 @@ func TestAlertingRuleExternalLabelsInTemplate(t *testing.T) {
expr, expr,
time.Minute, time.Minute,
labels.FromStrings("templated_label", "There are {{ len $externalLabels }} external Labels, of which foo is {{ $externalLabels.foo }}."), labels.FromStrings("templated_label", "There are {{ len $externalLabels }} external Labels, of which foo is {{ $externalLabels.foo }}."),
nil, labels.EmptyLabels(),
labels.FromStrings("foo", "bar", "dings", "bums"), labels.FromStrings("foo", "bar", "dings", "bums"),
"", "",
true, log.NewNopLogger(), true, log.NewNopLogger(),
@ -284,8 +284,8 @@ func TestAlertingRuleExternalURLInTemplate(t *testing.T) {
expr, expr,
time.Minute, time.Minute,
labels.FromStrings("templated_label", "The external URL is {{ $externalURL }}."), labels.FromStrings("templated_label", "The external URL is {{ $externalURL }}."),
nil, labels.EmptyLabels(),
nil, labels.EmptyLabels(),
"", "",
true, log.NewNopLogger(), true, log.NewNopLogger(),
) )
@ -294,8 +294,8 @@ func TestAlertingRuleExternalURLInTemplate(t *testing.T) {
expr, expr,
time.Minute, time.Minute,
labels.FromStrings("templated_label", "The external URL is {{ $externalURL }}."), labels.FromStrings("templated_label", "The external URL is {{ $externalURL }}."),
nil, labels.EmptyLabels(),
nil, labels.EmptyLabels(),
"http://localhost:1234", "http://localhost:1234",
true, log.NewNopLogger(), true, log.NewNopLogger(),
) )
@ -378,8 +378,8 @@ func TestAlertingRuleEmptyLabelFromTemplate(t *testing.T) {
expr, expr,
time.Minute, time.Minute,
labels.FromStrings("empty_label", ""), labels.FromStrings("empty_label", ""),
nil, labels.EmptyLabels(),
nil, labels.EmptyLabels(),
"", "",
true, log.NewNopLogger(), true, log.NewNopLogger(),
) )
@ -440,7 +440,7 @@ instance: {{ $v.Labels.instance }}, value: {{ printf "%.0f" $v.Value }};
{{- end -}} {{- end -}}
{{- end -}} {{- end -}}
`), `),
nil, labels.EmptyLabels(),
"", "",
true, log.NewNopLogger(), true, log.NewNopLogger(),
) )
@ -477,7 +477,7 @@ instance: {{ $v.Labels.instance }}, value: {{ printf "%.0f" $v.Value }};
func BenchmarkAlertingRuleAtomicField(b *testing.B) { func BenchmarkAlertingRuleAtomicField(b *testing.B) {
b.ReportAllocs() b.ReportAllocs()
rule := NewAlertingRule("bench", nil, 0, nil, nil, nil, "", true, nil) rule := NewAlertingRule("bench", nil, 0, labels.EmptyLabels(), labels.EmptyLabels(), labels.EmptyLabels(), "", true, nil)
done := make(chan struct{}) done := make(chan struct{})
go func() { go func() {
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
@ -516,8 +516,8 @@ func TestAlertingRuleDuplicate(t *testing.T) {
expr, expr,
time.Minute, time.Minute,
labels.FromStrings("test", "test"), labels.FromStrings("test", "test"),
nil, labels.EmptyLabels(),
nil, labels.EmptyLabels(),
"", "",
true, log.NewNopLogger(), true, log.NewNopLogger(),
) )
@ -562,8 +562,8 @@ func TestAlertingRuleLimit(t *testing.T) {
expr, expr,
time.Minute, time.Minute,
labels.FromStrings("test", "test"), labels.FromStrings("test", "test"),
nil, labels.EmptyLabels(),
nil, labels.EmptyLabels(),
"", "",
true, log.NewNopLogger(), true, log.NewNopLogger(),
) )
@ -634,13 +634,13 @@ func TestQueryForStateSeries(t *testing.T) {
nil, nil,
time.Minute, time.Minute,
labels.FromStrings("severity", "critical"), labels.FromStrings("severity", "critical"),
nil, nil, "", true, nil, labels.EmptyLabels(), labels.EmptyLabels(), "", true, nil,
) )
alert := &Alert{ alert := &Alert{
State: 0, State: 0,
Labels: nil, Labels: labels.EmptyLabels(),
Annotations: nil, Annotations: labels.EmptyLabels(),
Value: 0, Value: 0,
ActiveAt: time.Time{}, ActiveAt: time.Time{},
FiredAt: time.Time{}, FiredAt: time.Time{},

84
rules/manager_test.go
View file

@ -64,7 +64,7 @@ func TestAlertingRule(t *testing.T) {
expr, expr,
time.Minute, time.Minute,
labels.FromStrings("severity", "{{\"c\"}}ritical"), labels.FromStrings("severity", "{{\"c\"}}ritical"),
nil, nil, "", true, nil, labels.EmptyLabels(), labels.EmptyLabels(), "", true, nil,
) )
result := promql.Vector{ result := promql.Vector{
{ {
@ -207,7 +207,7 @@ func TestForStateAddSamples(t *testing.T) {
expr, expr,
time.Minute, time.Minute,
labels.FromStrings("severity", "{{\"c\"}}ritical"), labels.FromStrings("severity", "{{\"c\"}}ritical"),
nil, nil, "", true, nil, labels.EmptyLabels(), labels.EmptyLabels(), "", true, nil,
) )
result := promql.Vector{ result := promql.Vector{
{ {
@ -381,7 +381,7 @@ func TestForStateRestore(t *testing.T) {
expr, expr,
alertForDuration, alertForDuration,
labels.FromStrings("severity", "critical"), labels.FromStrings("severity", "critical"),
nil, nil, "", true, nil, labels.EmptyLabels(), labels.EmptyLabels(), "", true, nil,
) )
group := NewGroup(GroupOptions{ group := NewGroup(GroupOptions{
@ -447,7 +447,7 @@ func TestForStateRestore(t *testing.T) {
expr, expr,
alertForDuration, alertForDuration,
labels.FromStrings("severity", "critical"), labels.FromStrings("severity", "critical"),
nil, nil, "", false, nil, labels.EmptyLabels(), labels.EmptyLabels(), "", false, nil,
) )
newGroup := NewGroup(GroupOptions{ newGroup := NewGroup(GroupOptions{
Name: "default", Name: "default",
@ -611,36 +611,36 @@ func readSeriesSet(ss storage.SeriesSet) (map[string][]promql.Point, error) {
func TestCopyState(t *testing.T) { func TestCopyState(t *testing.T) {
oldGroup := &Group{ oldGroup := &Group{
rules: []Rule{ rules: []Rule{
NewAlertingRule("alert", nil, 0, nil, nil, nil, "", true, nil), NewAlertingRule("alert", nil, 0, labels.EmptyLabels(), labels.EmptyLabels(), labels.EmptyLabels(), "", true, nil),
NewRecordingRule("rule1", nil, nil), NewRecordingRule("rule1", nil, labels.EmptyLabels()),
NewRecordingRule("rule2", nil, nil), NewRecordingRule("rule2", nil, labels.EmptyLabels()),
NewRecordingRule("rule3", nil, labels.Labels{{Name: "l1", Value: "v1"}}), NewRecordingRule("rule3", nil, labels.FromStrings("l1", "v1")),
NewRecordingRule("rule3", nil, labels.Labels{{Name: "l1", Value: "v2"}}), NewRecordingRule("rule3", nil, labels.FromStrings("l1", "v2")),
NewRecordingRule("rule3", nil, labels.Labels{{Name: "l1", Value: "v3"}}), NewRecordingRule("rule3", nil, labels.FromStrings("l1", "v3")),
NewAlertingRule("alert2", nil, 0, labels.Labels{{Name: "l2", Value: "v1"}}, nil, nil, "", true, nil), NewAlertingRule("alert2", nil, 0, labels.FromStrings("l2", "v1"), labels.EmptyLabels(), labels.EmptyLabels(), "", true, nil),
}, },
seriesInPreviousEval: []map[string]labels.Labels{ seriesInPreviousEval: []map[string]labels.Labels{
{}, {},
{}, {},
{}, {},
{"r3a": labels.Labels{{Name: "l1", Value: "v1"}}}, {"r3a": labels.FromStrings("l1", "v1")},
{"r3b": labels.Labels{{Name: "l1", Value: "v2"}}}, {"r3b": labels.FromStrings("l1", "v2")},
{"r3c": labels.Labels{{Name: "l1", Value: "v3"}}}, {"r3c": labels.FromStrings("l1", "v3")},
{"a2": labels.Labels{{Name: "l2", Value: "v1"}}}, {"a2": labels.FromStrings("l2", "v1")},
}, },
evaluationTime: time.Second, evaluationTime: time.Second,
} }
oldGroup.rules[0].(*AlertingRule).active[42] = nil oldGroup.rules[0].(*AlertingRule).active[42] = nil
newGroup := &Group{ newGroup := &Group{
rules: []Rule{ rules: []Rule{
NewRecordingRule("rule3", nil, labels.Labels{{Name: "l1", Value: "v0"}}), NewRecordingRule("rule3", nil, labels.FromStrings("l1", "v0")),
NewRecordingRule("rule3", nil, labels.Labels{{Name: "l1", Value: "v1"}}), NewRecordingRule("rule3", nil, labels.FromStrings("l1", "v1")),
NewRecordingRule("rule3", nil, labels.Labels{{Name: "l1", Value: "v2"}}), NewRecordingRule("rule3", nil, labels.FromStrings("l1", "v2")),
NewAlertingRule("alert", nil, 0, nil, nil, nil, "", true, nil), NewAlertingRule("alert", nil, 0, labels.EmptyLabels(), labels.EmptyLabels(), labels.EmptyLabels(), "", true, nil),
NewRecordingRule("rule1", nil, nil), NewRecordingRule("rule1", nil, labels.EmptyLabels()),
NewAlertingRule("alert2", nil, 0, labels.Labels{{Name: "l2", Value: "v0"}}, nil, nil, "", true, nil), NewAlertingRule("alert2", nil, 0, labels.FromStrings("l2", "v0"), labels.EmptyLabels(), labels.EmptyLabels(), "", true, nil),
NewAlertingRule("alert2", nil, 0, labels.Labels{{Name: "l2", Value: "v1"}}, nil, nil, "", true, nil), NewAlertingRule("alert2", nil, 0, labels.FromStrings("l2", "v1"), labels.EmptyLabels(), labels.EmptyLabels(), "", true, nil),
NewRecordingRule("rule4", nil, nil), NewRecordingRule("rule4", nil, labels.EmptyLabels()),
}, },
seriesInPreviousEval: make([]map[string]labels.Labels, 8), seriesInPreviousEval: make([]map[string]labels.Labels, 8),
} }
@ -648,19 +648,19 @@ func TestCopyState(t *testing.T) {
want := []map[string]labels.Labels{ want := []map[string]labels.Labels{
nil, nil,
{"r3a": labels.Labels{{Name: "l1", Value: "v1"}}}, {"r3a": labels.FromStrings("l1", "v1")},
{"r3b": labels.Labels{{Name: "l1", Value: "v2"}}}, {"r3b": labels.FromStrings("l1", "v2")},
{}, {},
{}, {},
nil, nil,
{"a2": labels.Labels{{Name: "l2", Value: "v1"}}}, {"a2": labels.FromStrings("l2", "v1")},
nil, nil,
} }
require.Equal(t, want, newGroup.seriesInPreviousEval) require.Equal(t, want, newGroup.seriesInPreviousEval)
require.Equal(t, oldGroup.rules[0], newGroup.rules[3]) require.Equal(t, oldGroup.rules[0], newGroup.rules[3])
require.Equal(t, oldGroup.evaluationTime, newGroup.evaluationTime) require.Equal(t, oldGroup.evaluationTime, newGroup.evaluationTime)
require.Equal(t, oldGroup.lastEvaluation, newGroup.lastEvaluation) require.Equal(t, oldGroup.lastEvaluation, newGroup.lastEvaluation)
require.Equal(t, []labels.Labels{{{Name: "l1", Value: "v3"}}}, newGroup.staleSeries) require.Equal(t, []labels.Labels{labels.FromStrings("l1", "v3")}, newGroup.staleSeries)
} }
func TestDeletedRuleMarkedStale(t *testing.T) { func TestDeletedRuleMarkedStale(t *testing.T) {
@ -668,10 +668,10 @@ func TestDeletedRuleMarkedStale(t *testing.T) {
defer st.Close() defer st.Close()
oldGroup := &Group{ oldGroup := &Group{
rules: []Rule{ rules: []Rule{
NewRecordingRule("rule1", nil, labels.Labels{{Name: "l1", Value: "v1"}}), NewRecordingRule("rule1", nil, labels.FromStrings("l1", "v1")),
}, },
seriesInPreviousEval: []map[string]labels.Labels{ seriesInPreviousEval: []map[string]labels.Labels{
{"r1": labels.Labels{{Name: "l1", Value: "v1"}}}, {"r1": labels.FromStrings("l1", "v1")},
}, },
} }
newGroup := &Group{ newGroup := &Group{
@ -727,7 +727,7 @@ func TestUpdate(t *testing.T) {
ruleManager.start() ruleManager.start()
defer ruleManager.Stop() defer ruleManager.Stop()
err := ruleManager.Update(10*time.Second, files, nil, "", nil) err := ruleManager.Update(10*time.Second, files, labels.EmptyLabels(), "", nil)
require.NoError(t, err) require.NoError(t, err)
require.Greater(t, len(ruleManager.groups), 0, "expected non-empty rule groups") require.Greater(t, len(ruleManager.groups), 0, "expected non-empty rule groups")
ogs := map[string]*Group{} ogs := map[string]*Group{}
@ -738,7 +738,7 @@ func TestUpdate(t *testing.T) {
ogs[h] = g ogs[h] = g
} }
err = ruleManager.Update(10*time.Second, files, nil, "", nil) err = ruleManager.Update(10*time.Second, files, labels.EmptyLabels(), "", nil)
require.NoError(t, err) require.NoError(t, err)
for h, g := range ruleManager.groups { for h, g := range ruleManager.groups {
for _, actual := range g.seriesInPreviousEval { for _, actual := range g.seriesInPreviousEval {
@ -757,7 +757,7 @@ func TestUpdate(t *testing.T) {
defer os.Remove(tmpFile.Name()) defer os.Remove(tmpFile.Name())
defer tmpFile.Close() defer tmpFile.Close()
err = ruleManager.Update(10*time.Second, []string{tmpFile.Name()}, nil, "", nil) err = ruleManager.Update(10*time.Second, []string{tmpFile.Name()}, labels.EmptyLabels(), "", nil)
require.NoError(t, err) require.NoError(t, err)
for h, g := range ruleManager.groups { for h, g := range ruleManager.groups {
@ -835,7 +835,7 @@ func reloadAndValidate(rgs *rulefmt.RuleGroups, t *testing.T, tmpFile *os.File,
tmpFile.Seek(0, 0) tmpFile.Seek(0, 0)
_, err = tmpFile.Write(bs) _, err = tmpFile.Write(bs)
require.NoError(t, err) require.NoError(t, err)
err = ruleManager.Update(10*time.Second, []string{tmpFile.Name()}, nil, "", nil) err = ruleManager.Update(10*time.Second, []string{tmpFile.Name()}, labels.EmptyLabels(), "", nil)
require.NoError(t, err) require.NoError(t, err)
for h, g := range ruleManager.groups { for h, g := range ruleManager.groups {
if ogs[h] == g { if ogs[h] == g {
@ -871,7 +871,7 @@ func TestNotify(t *testing.T) {
expr, err := parser.ParseExpr("a > 1") expr, err := parser.ParseExpr("a > 1")
require.NoError(t, err) require.NoError(t, err)
rule := NewAlertingRule("aTooHigh", expr, 0, labels.Labels{}, labels.Labels{}, nil, "", true, log.NewNopLogger()) rule := NewAlertingRule("aTooHigh", expr, 0, labels.Labels{}, labels.Labels{}, labels.EmptyLabels(), "", true, log.NewNopLogger())
group := NewGroup(GroupOptions{ group := NewGroup(GroupOptions{
Name: "alert", Name: "alert",
Interval: time.Second, Interval: time.Second,
@ -980,7 +980,7 @@ func TestMetricsUpdate(t *testing.T) {
} }
for i, c := range cases { for i, c := range cases {
err := ruleManager.Update(time.Second, c.files, nil, "", nil) err := ruleManager.Update(time.Second, c.files, labels.EmptyLabels(), "", nil)
require.NoError(t, err) require.NoError(t, err)
time.Sleep(2 * time.Second) time.Sleep(2 * time.Second)
require.Equal(t, c.metrics, countMetrics(), "test %d: invalid count of metrics", i) require.Equal(t, c.metrics, countMetrics(), "test %d: invalid count of metrics", i)
@ -1054,7 +1054,7 @@ func TestGroupStalenessOnRemoval(t *testing.T) {
var totalStaleNaN int var totalStaleNaN int
for i, c := range cases { for i, c := range cases {
err := ruleManager.Update(time.Second, c.files, nil, "", nil) err := ruleManager.Update(time.Second, c.files, labels.EmptyLabels(), "", nil)
require.NoError(t, err) require.NoError(t, err)
time.Sleep(3 * time.Second) time.Sleep(3 * time.Second)
totalStaleNaN += c.staleNaN totalStaleNaN += c.staleNaN
@ -1096,11 +1096,11 @@ func TestMetricsStalenessOnManagerShutdown(t *testing.T) {
} }
}() }()
err := ruleManager.Update(2*time.Second, files, nil, "", nil) err := ruleManager.Update(2*time.Second, files, labels.EmptyLabels(), "", nil)
time.Sleep(4 * time.Second) time.Sleep(4 * time.Second)
require.NoError(t, err) require.NoError(t, err)
start := time.Now() start := time.Now()
err = ruleManager.Update(3*time.Second, files[:0], nil, "", nil) err = ruleManager.Update(3*time.Second, files[:0], labels.EmptyLabels(), "", nil)
require.NoError(t, err) require.NoError(t, err)
ruleManager.Stop() ruleManager.Stop()
stopped = true stopped = true
@ -1143,8 +1143,8 @@ func TestGroupHasAlertingRules(t *testing.T) {
group: &Group{ group: &Group{
name: "HasAlertingRule", name: "HasAlertingRule",
rules: []Rule{ rules: []Rule{
NewAlertingRule("alert", nil, 0, nil, nil, nil, "", true, nil), NewAlertingRule("alert", nil, 0, labels.EmptyLabels(), labels.EmptyLabels(), labels.EmptyLabels(), "", true, nil),
NewRecordingRule("record", nil, nil), NewRecordingRule("record", nil, labels.EmptyLabels()),
}, },
}, },
want: true, want: true,
@ -1160,7 +1160,7 @@ func TestGroupHasAlertingRules(t *testing.T) {
group: &Group{ group: &Group{
name: "HasOnlyRecordingRule", name: "HasOnlyRecordingRule",
rules: []Rule{ rules: []Rule{
NewRecordingRule("record", nil, nil), NewRecordingRule("record", nil, labels.EmptyLabels()),
}, },
}, },
want: false, want: false,
@ -1295,7 +1295,7 @@ func TestUpdateMissedEvalMetrics(t *testing.T) {
vector: expr, vector: expr,
holdDuration: 5 * time.Minute, holdDuration: 5 * time.Minute,
labels: labels.FromStrings("severity", "critical"), labels: labels.FromStrings("severity", "critical"),
annotations: nil, annotations: labels.EmptyLabels(),
externalLabels: nil, externalLabels: nil,
externalURL: "", externalURL: "",
active: m, active: m,