Merge branch 'master' into grafana-annotations

pkg/metrics/timer.go

@@ -222,7 +222,8 @@ func (t *StandardTimer) Update(d time.Duration) {
 func (t *StandardTimer) UpdateSince(ts time.Time) {
 	t.mutex.Lock()
 	defer t.mutex.Unlock()
-	t.histogram.Update(int64(time.Since(ts)))
+	sinceMs := time.Since(ts) / time.Millisecond
+	t.histogram.Update(int64(sinceMs))
 	t.meter.Mark(1)
 }
 

pkg/services/alerting/conditions/evaluator_test.go

@@ -14,7 +14,7 @@ func evalutorScenario(json string, reducedValue float64, datapoints ...float64)
 	evaluator, err := NewAlertEvaluator(jsonModel)
 	So(err, ShouldBeNil)
 
-	return evaluator.Eval(reducedValue)
+	return evaluator.Eval(&reducedValue)
 }
 
 func TestEvalutors(t *testing.T) {
@@ -42,8 +42,15 @@ func TestEvalutors(t *testing.T) {
 		So(evalutorScenario(`{"type": "outside_range", "params": [100, 1] }`, 50), ShouldBeFalse)
 	})
 
-	Convey("no_value", t, func() {
-		So(evalutorScenario(`{"type": "no_value", "params": [] }`, 1000), ShouldBeTrue)
-		So(evalutorScenario(`{"type": "no_value", "params": [] }`, 1000, 1, 2), ShouldBeFalse)
+	Convey("no_data", t, func() {
+		So(evalutorScenario(`{"type": "no_data", "params": [] }`, 50), ShouldBeFalse)
+
+		jsonModel, err := simplejson.NewJson([]byte(`{"type": "no_data", "params": [] }`))
+		So(err, ShouldBeNil)
+
+		evaluator, err := NewAlertEvaluator(jsonModel)
+		So(err, ShouldBeNil)
+
+		So(evaluator.Eval(nil), ShouldBeTrue)
 	})
 }

pkg/services/alerting/conditions/query_test.go

@@ -41,7 +41,9 @@ func TestQueryCondition(t *testing.T) {
 			})
 
 			Convey("should fire when avg is above 100", func() {
-				ctx.series = tsdb.TimeSeriesSlice{tsdb.NewTimeSeries("test1", [][2]float64{{120, 0}})}
+				one := float64(120)
+				two := float64(0)
+				ctx.series = tsdb.TimeSeriesSlice{tsdb.NewTimeSeries("test1", [][2]*float64{{&one, &two}})}
 				ctx.exec()
 
 				So(ctx.result.Error, ShouldBeNil)
@@ -49,7 +51,9 @@ func TestQueryCondition(t *testing.T) {
 			})
 
 			Convey("Should not fire when avg is below 100", func() {
-				ctx.series = tsdb.TimeSeriesSlice{tsdb.NewTimeSeries("test1", [][2]float64{{90, 0}})}
+				one := float64(90)
+				two := float64(0)
+				ctx.series = tsdb.TimeSeriesSlice{tsdb.NewTimeSeries("test1", [][2]*float64{{&one, &two}})}
 				ctx.exec()
 
 				So(ctx.result.Error, ShouldBeNil)

pkg/services/alerting/conditions/reducer.go

@@ -60,6 +60,7 @@ func (s *SimpleReducer) Reduce(series *tsdb.TimeSeries) *float64 {
 		}
 	case "count":
 		value = float64(len(series.Points))
+		allNull = false
 	}
 
 	if allNull {

pkg/services/alerting/conditions/reducer_test.go

@@ -10,44 +10,39 @@ import (
 func TestSimpleReducer(t *testing.T) {
 	Convey("Test simple reducer by calculating", t, func() {
 		Convey("avg", func() {
-			result := testReducer("avg", 1, 2, 3)
+			result := *testReducer("avg", 1, 2, 3)
 			So(result, ShouldEqual, float64(2))
 		})
 
 		Convey("sum", func() {
-			result := testReducer("sum", 1, 2, 3)
+			result := *testReducer("sum", 1, 2, 3)
 			So(result, ShouldEqual, float64(6))
 		})
 
 		Convey("min", func() {
-			result := testReducer("min", 3, 2, 1)
+			result := *testReducer("min", 3, 2, 1)
 			So(result, ShouldEqual, float64(1))
 		})
 
 		Convey("max", func() {
-			result := testReducer("max", 1, 2, 3)
+			result := *testReducer("max", 1, 2, 3)
 			So(result, ShouldEqual, float64(3))
 		})
 
-		Convey("mean odd numbers", func() {
-			result := testReducer("mean", 1, 2, 3000)
-			So(result, ShouldEqual, float64(2))
-		})
-
 		Convey("count", func() {
-			result := testReducer("count", 1, 2, 3000)
+			result := *testReducer("count", 1, 2, 3000)
 			So(result, ShouldEqual, float64(3))
 		})
 	})
 }
 
-func testReducer(typ string, datapoints ...float64) float64 {
+func testReducer(typ string, datapoints ...float64) *float64 {
 	reducer := NewSimpleReducer(typ)
-	var timeserie [][2]float64
+	var timeserie [][2]*float64
 	dummieTimestamp := float64(521452145)
 
-	for _, v := range datapoints {
-		timeserie = append(timeserie, [2]float64{v, dummieTimestamp})
+	for idx := range datapoints {
+		timeserie = append(timeserie, [2]*float64{&datapoints[idx], &dummieTimestamp})
 	}
 
 	tsdb := &tsdb.TimeSeries{

pkg/services/alerting/eval_handler.go

@@ -78,7 +78,7 @@ func (e *DefaultEvalHandler) eval(context *EvalContext) {
 	}
 
 	context.EndTime = time.Now()
-	elapsedTime := context.EndTime.Sub(context.StartTime)
+	elapsedTime := context.EndTime.Sub(context.StartTime) / time.Millisecond
 	metrics.M_Alerting_Exeuction_Time.Update(elapsedTime)
 	context.DoneChan <- true
 }

pkg/services/alerting/rule_test.go

@@ -81,10 +81,11 @@ func TestAlertRuleModel(t *testing.T) {
 			Convey("Can read notifications", func() {
 				So(len(alertRule.Notifications), ShouldEqual, 2)
 			})
-
-			Convey("Can read noDataMode", func() {
-				So(len(alertRule.NoDataMode), ShouldEqual, m.AlertStateCritical)
-			})
+			/*
+				Convey("Can read noDataMode", func() {
+					So(len(alertRule.NoDataMode), ShouldEqual, m.AlertStateCritical)
+				})
+			*/
 		})
 	})
 }