feat(alerting): add timeserie aggregation functions

pkg/services/alerting/executor.go

@@ -11,6 +11,15 @@ type Executor interface {
 
 type ExecutorImpl struct{}
 
+type fn func(float64, float64) bool
+
+var operators map[string]fn = map[string]fn{
+	">":  func(num1, num2 float64) bool { return num1 > num2 },
+	">=": func(num1, num2 float64) bool { return num1 >= num2 },
+	"<":  func(num1, num2 float64) bool { return num1 < num2 },
+	"<=": func(num1, num2 float64) bool { return num1 <= num2 },
+}
+
 func (this *ExecutorImpl) Execute(rule m.AlertRule, responseQueue chan *AlertResult) {
 	response, err := graphite.GraphiteClient{}.GetSeries(rule)
 
@@ -18,10 +27,10 @@ func (this *ExecutorImpl) Execute(rule m.AlertRule, responseQueue chan *AlertRes
 		responseQueue <- &AlertResult{State: "CRITICAL", Id: rule.Id}
 	}
 
-	responseQueue <- this.executeRules(response, rule)
+	responseQueue <- this.ValidateRule(rule, response)
 }
 
-func (this *ExecutorImpl) executeRules(series m.TimeSeriesSlice, rule m.AlertRule) *AlertResult {
+func (this *ExecutorImpl) ValidateRule(rule m.AlertRule, series m.TimeSeriesSlice) *AlertResult {
 	for _, v := range series {
 		var avg float64
 		var sum float64
@@ -31,19 +40,19 @@ func (this *ExecutorImpl) executeRules(series m.TimeSeriesSlice, rule m.AlertRul
 
 		avg = sum / float64(len(v.Points))
 
-		if float64(rule.CritLevel) < avg {
+		if rule.CritOperator != "" && operators[rule.CritOperator](float64(rule.CritLevel), avg) {
 			return &AlertResult{State: m.AlertStateCritical, Id: rule.Id, ActualValue: avg}
 		}
 
-		if float64(rule.WarnLevel) < avg {
+		if rule.WarnOperator != "" && operators[rule.WarnOperator](float64(rule.WarnLevel), avg) {
 			return &AlertResult{State: m.AlertStateWarn, Id: rule.Id, ActualValue: avg}
 		}
 
-		if float64(rule.CritLevel) < sum {
+		if rule.CritOperator != "" && operators[rule.CritOperator](float64(rule.CritLevel), sum) {
 			return &AlertResult{State: m.AlertStateCritical, Id: rule.Id, ActualValue: sum}
 		}
 
-		if float64(rule.WarnLevel) < sum {
+		if rule.WarnOperator != "" && operators[rule.WarnOperator](float64(rule.WarnLevel), sum) {
 			return &AlertResult{State: m.AlertStateWarn, Id: rule.Id, ActualValue: sum}
 		}
 	}

pkg/services/alerting/executor_test.go

@@ -0,0 +1,58 @@
+package alerting
+
+import (
+	m "github.com/grafana/grafana/pkg/models"
+	. "github.com/smartystreets/goconvey/convey"
+	"testing"
+)
+
+func TestAlertingExecutor(t *testing.T) {
+	Convey("Test alert execution", t, func() {
+		executor := &ExecutorImpl{}
+
+		Convey("Show return ok since avg is above 2", func() {
+			rule := m.AlertRule{CritLevel: 10, CritOperator: "<", Aggregator: "sum"}
+
+			timeseries := []*m.TimeSeries{
+				m.NewTimeSeries("test1", [][2]float64{{2, 0}}),
+			}
+
+			result := executor.ValidateRule(rule, timeseries)
+			So(result.State, ShouldEqual, m.AlertStateOk)
+		})
+
+		Convey("Show return critical since below 2", func() {
+			rule := m.AlertRule{CritLevel: 10, CritOperator: ">", Aggregator: "sum"}
+
+			timeseries := []*m.TimeSeries{
+				m.NewTimeSeries("test1", [][2]float64{{2, 0}}),
+			}
+
+			result := executor.ValidateRule(rule, timeseries)
+			So(result.State, ShouldEqual, m.AlertStateCritical)
+		})
+
+		Convey("Show return critical since sum is above 10", func() {
+			rule := m.AlertRule{CritLevel: 10, CritOperator: "<", Aggregator: "sum"}
+
+			timeseries := []*m.TimeSeries{
+				m.NewTimeSeries("test1", [][2]float64{{9, 0}, {9, 0}}),
+			}
+
+			result := executor.ValidateRule(rule, timeseries)
+			So(result.State, ShouldEqual, m.AlertStateCritical)
+		})
+		/*
+			Convey("Show return ok since avg is below 10", func() {
+				rule := m.AlertRule{CritLevel: 10, CritOperator: "<", Aggregator: "avg"}
+
+				timeseries := []*m.TimeSeries{
+					m.NewTimeSeries("test1", [][2]float64{{9, 0}, {9, 0}}),
+				}
+
+				result := executor.ValidateRule(rule, timeseries)
+				So(result.State, ShouldEqual, m.AlertStateOk)
+			})
+		*/
+	})
+}