func TestDependency_OtherAlert_UnknownChain(t *testing.T) {
ab := expr.AlertKey("a{host=b}")
bb := expr.AlertKey("b{host=b}")
cb := expr.AlertKey("c{host=b}")
as := NewStatus(ab)
as.Touched = queryTime.Add(-time.Hour)
as.Append(&Event{Status: StNormal})
bs := NewStatus(ab)
bs.Touched = queryTime
bs.Append(&Event{Status: StNormal})
cs := NewStatus(ab)
cs.Touched = queryTime
cs.Append(&Event{Status: StNormal})
s := testSched(t, &schedTest{
conf: `
alert a {
warn = avg(q("avg:a{host=*}", "5m", "")) && 0
}
alert b {
depends = alert("a", "warn")
warn = avg(q("avg:b{host=*}", "5m", "")) > 0
}
alert c {
depends = alert("b", "warn")
warn = avg(q("avg:b{host=*}", "5m", "")) > 0
}
`,
queries: map[string]opentsdb.ResponseSet{
`q("avg:a{host=*}", ` + window5Min + `)`: {},
`q("avg:b{host=*}", ` + window5Min + `)`: {{
Metric: "b",
Tags: opentsdb.TagSet{"host": "b"},
DPS: map[string]opentsdb.Point{"0": 0},
}},
},
state: map[schedState]bool{
schedState{string(ab), "unknown"}: true,
},
previous: map[expr.AlertKey]*State{
ab: as,
bb: bs,
cb: cs,
},
})
if s.status[ab].Unevaluated {
t.Errorf("should not be unevaluated: %s", ab)
}
if !s.status[bb].Unevaluated {
t.Errorf("should be unevaluated: %s", bb)
}
if !s.status[cb].Unevaluated {
t.Errorf("should be unevaluated: %s", cb)
}
}
func TestError_To_Unknown(t *testing.T) {
ak := expr.NewAlertKey("a", nil)
state := NewStatus(ak)
state.Touched = queryTime.Add(-10 * time.Minute)
state.Append(&Event{Status: StError, Time: state.Touched})
s := testSched(t, &schedTest{
conf: `alert a {
crit = avg(q("avg:m{a=*}", "5m", "")) > 0
}`,
queries: map[string]opentsdb.ResponseSet{
`q("avg:m{a=*}", ` + window5Min + `)`: {},
},
state: map[schedState]bool{
//No abnormal events
},
previous: map[expr.AlertKey]*State{
ak: state,
},
})
st := s.GetStatus(expr.AlertKey(ak))
if st.Status() != StError {
t.Errorf("Expected status to be %s but was %s", StError, st.Status())
}
}
func TestActionNotificationGrouping(t *testing.T) {
c, err := conf.New("", `
template t{
subject = 2
}
notification n1 {
print = true
}
notification n2{
print = true
}
notification n3{
print = true
runOnActions = true
}
notification n4{
print = true
runOnActions = false
}
alert a {
template = t
warnNotification = n1
critNotification = n2
warnNotification = n4
crit = 1
warn = 1
}
alert b{
template = t
warnNotification = n2
critNotification = n3
crit = 1
warn = 1
}
lookup byHost{
entry host=a{
main_contact = n2
}
entry host=b{
main_contact = n3
}
}
alert c{
template = t
warnNotification = n1
warnNotification = lookup("byHost", "main_contact")
warn = 1
}
`)
if err != nil {
t.Fatal(err)
}
s, err := initSched(c)
if err != nil {
t.Fatal(err)
}
awarn := expr.AlertKey("a{host=w}")
acrit := expr.AlertKey("a{host=c}")
bwarn := expr.AlertKey("b{host=w}")
bcrit := expr.AlertKey("b{host=c}")
cA := expr.AlertKey("c{host=a}")
cB := expr.AlertKey("c{host=b}")
s.status[awarn] = &State{Alert: "a", Group: opentsdb.TagSet{"host": "w"}, History: []Event{{Status: StWarning}}}
s.status[acrit] = &State{Alert: "a", Group: opentsdb.TagSet{"host": "c"}, History: []Event{{Status: StCritical}}}
s.status[bwarn] = &State{Alert: "b", Group: opentsdb.TagSet{"host": "w"}, History: []Event{{Status: StWarning}}}
s.status[bcrit] = &State{Alert: "b", Group: opentsdb.TagSet{"host": "c"}, History: []Event{{Status: StCritical}}}
s.status[cA] = &State{Alert: "c", Group: opentsdb.TagSet{"host": "a"}, History: []Event{{Status: StWarning}}}
s.status[cB] = &State{Alert: "c", Group: opentsdb.TagSet{"host": "b"}, History: []Event{{Status: StWarning}}}
groups := s.groupActionNotifications([]expr.AlertKey{awarn, acrit, bwarn, bcrit, cA, cB})
expect := func(not string, aks ...expr.AlertKey) {
n := c.Notifications[not]
actualAks, ok := groups[n]
if !ok {
t.Fatalf("Notification %s not present in groupings.", not)
}
if len(actualAks) != len(aks) {
t.Fatalf("Count mismatch for grouping %s. %d != %d.", not, len(actualAks), len(aks))
}
for i, ak := range aks {
if actualAks[i].AlertKey() != ak {
t.Fatalf("Alert key mismatch at index %d. %s != %s.", i, actualAks[i].AlertKey(), ak)
}
}
}
expect("n1", awarn, cA, cB)
expect("n2", acrit, bwarn, cA)
expect("n3", bcrit, cB)
}