chore(tsdb): tidy up code

Author: bergquist

pkg/tsdb/influxdb/influxdb.go

@@ -127,6 +127,6 @@ func (e *InfluxDBExecutor) createRequest(query string) (*http.Request, error) {
 		req.SetBasicAuth(e.BasicAuthUser, e.BasicAuthPassword)
 	}
 
-	glog.Debug("influxdb request", "url", req.URL.String())
+	glog.Debug("Influxdb request", "url", req.URL.String())
 	return req, nil
 }

pkg/tsdb/influxdb/model_parser.go

@@ -134,7 +134,6 @@ func (*InfluxdbQueryParser) parseQueryPart(model *simplejson.Json) (*QueryPart,
 	}
 
 	return qp, nil
-	//return &QueryPart{Type: typ, Params: params}, nil
 }
 
 func (qp *InfluxdbQueryParser) parseGroupBy(model *simplejson.Json) ([]*QueryPart, error) {

pkg/tsdb/influxdb/query_builder.go

@@ -9,7 +9,17 @@ import (
 
 type QueryBuilder struct{}
 
-func renderTags(query *Query) []string {
+func (qb *QueryBuilder) Build(query *Query, queryContext *tsdb.QueryContext) (string, error) {
+	res := qb.renderSelectors(query, queryContext)
+	res += qb.renderMeasurement(query)
+	res += qb.renderWhereClause(query)
+	res += qb.renderTimeFilter(query, queryContext)
+	res += qb.renderGroupBy(query, queryContext)
+
+	return res, nil
+}
+
+func (qb *QueryBuilder) renderTags(query *Query) []string {
 	var res []string
 	for i, tag := range query.Tags {
 		str := ""
@@ -29,17 +39,7 @@ func renderTags(query *Query) []string {
 	return res
 }
 
-func (*QueryBuilder) Build(query *Query, queryContext *tsdb.QueryContext) (string, error) {
-	res := renderSelectors(query, queryContext)
-	res += renderMeasurement(query)
-	res += renderWhereClause(query)
-	res += renderTimeFilter(query, queryContext)
-	res += renderGroupBy(query, queryContext)
-
-	return res, nil
-}
-
-func renderTimeFilter(query *Query, queryContext *tsdb.QueryContext) string {
+func (qb *QueryBuilder) renderTimeFilter(query *Query, queryContext *tsdb.QueryContext) string {
 	from := "now() - " + queryContext.TimeRange.From
 	to := ""
 
@@ -50,7 +50,7 @@ func renderTimeFilter(query *Query, queryContext *tsdb.QueryContext) string {
 	return fmt.Sprintf("time > %s%s", from, to)
 }
 
-func renderSelectors(query *Query, queryContext *tsdb.QueryContext) string {
+func (qb *QueryBuilder) renderSelectors(query *Query, queryContext *tsdb.QueryContext) string {
 	res := "SELECT "
 
 	var selectors []string
@@ -66,7 +66,7 @@ func renderSelectors(query *Query, queryContext *tsdb.QueryContext) string {
 	return res + strings.Join(selectors, ", ")
 }
 
-func renderMeasurement(query *Query) string {
+func (qb *QueryBuilder) renderMeasurement(query *Query) string {
 	policy := ""
 	if query.Policy == "" || query.Policy == "default" {
 		policy = ""
@@ -76,9 +76,9 @@ func renderMeasurement(query *Query) string {
 	return fmt.Sprintf(` FROM %s"%s"`, policy, query.Measurement)
 }
 
-func renderWhereClause(query *Query) string {
+func (qb *QueryBuilder) renderWhereClause(query *Query) string {
 	res := " WHERE "
-	conditions := renderTags(query)
+	conditions := qb.renderTags(query)
 	res += strings.Join(conditions, " ")
 	if len(conditions) > 0 {
 		res += " AND "
@@ -87,7 +87,7 @@ func renderWhereClause(query *Query) string {
 	return res
 }
 
-func renderGroupBy(query *Query, queryContext *tsdb.QueryContext) string {
+func (qb *QueryBuilder) renderGroupBy(query *Query, queryContext *tsdb.QueryContext) string {
 	groupBy := ""
 	for i, group := range query.GroupBy {
 		if i == 0 {

pkg/tsdb/influxdb/query_builder_test.go

@@ -56,15 +56,16 @@ func TestInfluxdbQueryBuilder(t *testing.T) {
 
 		Convey("can render time range", func() {
 			query := Query{}
+			builder := &QueryBuilder{}
 			Convey("render from: 2h to now-1h", func() {
 				query := Query{}
 				queryContext := &tsdb.QueryContext{TimeRange: tsdb.NewTimeRange("2h", "now-1h")}
-				So(renderTimeFilter(&query, queryContext), ShouldEqual, "time > now() - 2h and time < now() - 1h")
+				So(builder.renderTimeFilter(&query, queryContext), ShouldEqual, "time > now() - 2h and time < now() - 1h")
 			})
 
 			Convey("render from: 10m", func() {
 				queryContext := &tsdb.QueryContext{TimeRange: tsdb.NewTimeRange("10m", "now")}
-				So(renderTimeFilter(&query, queryContext), ShouldEqual, "time > now() - 10m")
+				So(builder.renderTimeFilter(&query, queryContext), ShouldEqual, "time > now() - 10m")
 			})
 		})
 	})

pkg/tsdb/influxdb/response_parser.go

@@ -15,33 +15,39 @@ func (rp *ResponseParser) Parse(response *Response) *tsdb.QueryResult {
 	queryRes := tsdb.NewQueryResult()
 
 	for _, result := range response.Results {
-		rp.parseResult(result.Series, queryRes)
+		queryRes.Series = append(queryRes.Series, rp.transformRows(result.Series, queryRes)...)
 	}
 
 	return queryRes
 }
 
-func (rp *ResponseParser) parseResult(result []Row, queryResult *tsdb.QueryResult) {
-	for _, r := range result {
-		for columnIndex, column := range r.Columns {
+func (rp *ResponseParser) transformRows(rows []Row, queryResult *tsdb.QueryResult) tsdb.TimeSeriesSlice {
+	var result tsdb.TimeSeriesSlice
+
+	for _, row := range rows {
+		for columnIndex, column := range row.Columns {
 			if column == "time" {
 				continue
 			}
 
 			var points tsdb.TimeSeriesPoints
-			for _, k := range r.Values {
-				points = append(points, rp.parseTimepoint(k, columnIndex))
+			for _, valuePair := range row.Values {
+				point, err := rp.parseTimepoint(valuePair, columnIndex)
+				if err == nil {
+					points = append(points, point)
+				}
 			}
-
-			queryResult.Series = append(queryResult.Series, &tsdb.TimeSeries{
-				Name:   rp.formatName(r, column),
+			result = append(result, &tsdb.TimeSeries{
+				Name:   rp.formatSerieName(row, column),
 				Points: points,
 			})
 		}
 	}
+
+	return result
 }
 
-func (rp *ResponseParser) formatName(row Row, column string) string {
+func (rp *ResponseParser) formatSerieName(row Row, column string) string {
 	var tags []string
 
 	for k, v := range row.Tags {
@@ -56,30 +62,30 @@ func (rp *ResponseParser) formatName(row Row, column string) string {
 	return fmt.Sprintf("%s.%s%s", row.Name, column, tagText)
 }
 
-func (rp *ResponseParser) parseTimepoint(k []interface{}, valuePosition int) tsdb.TimePoint {
-	var value null.Float = rp.parseValue(k[valuePosition])
+func (rp *ResponseParser) parseTimepoint(valuePair []interface{}, valuePosition int) (tsdb.TimePoint, error) {
+	var value null.Float = rp.parseValue(valuePair[valuePosition])
 
-	timestampNumber, _ := k[0].(json.Number)
+	timestampNumber, _ := valuePair[0].(json.Number)
 	timestamp, err := timestampNumber.Float64()
 	if err != nil {
-		glog.Error("Invalid timestamp format. This should never happen!")
+		return tsdb.TimePoint{}, err
 	}
 
-	return tsdb.NewTimePoint(value, timestamp)
+	return tsdb.NewTimePoint(value, timestamp), nil
 }
 
 func (rp *ResponseParser) parseValue(value interface{}) null.Float {
-	num, ok := value.(json.Number)
+	number, ok := value.(json.Number)
 	if !ok {
 		return null.FloatFromPtr(nil)
 	}
 
-	fvalue, err := num.Float64()
+	fvalue, err := number.Float64()
 	if err == nil {
 		return null.FloatFrom(fvalue)
 	}
 
-	ivalue, err := num.Int64()
+	ivalue, err := number.Int64()
 	if err == nil {
 		return null.FloatFrom(float64(ivalue))
 	}