Merge pull request #6515 from grafana/influxdb_alias_seriename

[Influxdb] Backend support for seriename alias

pkg/tsdb/influxdb/influxdb.go

@@ -51,11 +51,16 @@ func (e *InfluxDBExecutor) Execute(ctx context.Context, queries tsdb.QuerySlice,
 		return result.WithError(err)
 	}
 
-	if setting.Env == setting.DEV {
+	rawQuery, err := e.QueryBuilder.Build(query, context)
-		glog.Debug("Influxdb query", "raw query", query)
+	if err != nil {
+		return result.WithError(err)
 	}
 
-	req, err := e.createRequest(query)
+	if setting.Env == setting.DEV {
+		glog.Debug("Influxdb query", "raw query", rawQuery)
+	}
+
+	req, err := e.createRequest(rawQuery)
 	if err != nil {
 		return result.WithError(err)
 	}
@@ -80,28 +85,23 @@ func (e *InfluxDBExecutor) Execute(ctx context.Context, queries tsdb.QuerySlice,
 	}
 
 	result.QueryResults = make(map[string]*tsdb.QueryResult)
-	result.QueryResults["A"] = e.ResponseParser.Parse(&response)
+	result.QueryResults["A"] = e.ResponseParser.Parse(&response, query)
 
 	return result
 }
 
-func (e *InfluxDBExecutor) getQuery(queries tsdb.QuerySlice, context *tsdb.QueryContext) (string, error) {
+func (e *InfluxDBExecutor) getQuery(queries tsdb.QuerySlice, context *tsdb.QueryContext) (*Query, error) {
 	for _, v := range queries {
 
 		query, err := e.QueryParser.Parse(v.Model, e.DataSourceInfo)
 		if err != nil {
-			return "", err
+			return nil, err
 		}
 
-		rawQuery, err := e.QueryBuilder.Build(query, context)
+		return query, nil
-		if err != nil {
-			return "", err
-		}
-
-		return rawQuery, nil
 	}
 
-	return "", fmt.Errorf("query request contains no queries")
+	return nil, fmt.Errorf("query request contains no queries")
 }
 
 func (e *InfluxDBExecutor) createRequest(query string) (*http.Request, error) {

pkg/tsdb/influxdb/model_parser.go

@@ -12,6 +12,7 @@ type InfluxdbQueryParser struct{}
 func (qp *InfluxdbQueryParser) Parse(model *simplejson.Json, dsInfo *tsdb.DataSourceInfo) (*Query, error) {
 	policy := model.Get("policy").MustString("default")
 	rawQuery := model.Get("query").MustString("")
+	alias := model.Get("alias").MustString("")
 
 	measurement := model.Get("measurement").MustString("")
 
@@ -52,6 +53,7 @@ func (qp *InfluxdbQueryParser) Parse(model *simplejson.Json, dsInfo *tsdb.DataSo
 		Selects:      selects,
 		RawQuery:     rawQuery,
 		Interval:     interval,
+		Alias:        alias,
 	}, nil
 }
 

pkg/tsdb/influxdb/model_parser_test.go

@@ -90,6 +90,7 @@ func TestInfluxdbQueryParser(t *testing.T) {
             }
           ]
         ],
+        "alias": "serie alias",
         "tags": [
           {
             "key": "datacenter",
@@ -115,6 +116,7 @@ func TestInfluxdbQueryParser(t *testing.T) {
 			So(len(res.Selects), ShouldEqual, 3)
 			So(len(res.Tags), ShouldEqual, 2)
 			So(res.Interval, ShouldEqual, ">20s")
+			So(res.Alias, ShouldEqual, "serie alias")
 		})
 
 		Convey("can part raw query json model", func() {

pkg/tsdb/influxdb/models.go

@@ -8,6 +8,7 @@ type Query struct {
 	GroupBy      []*QueryPart
 	Selects      []*Select
 	RawQuery     string
+	Alias        string
 
 	Interval string
 }

pkg/tsdb/influxdb/response_parser.go

@@ -3,6 +3,8 @@ package influxdb
 import (
 	"encoding/json"
 	"fmt"
+	"regexp"
+	"strconv"
 	"strings"
 
 	"github.com/grafana/grafana/pkg/tsdb"
@@ -11,17 +13,25 @@ import (
 
 type ResponseParser struct{}
 
-func (rp *ResponseParser) Parse(response *Response) *tsdb.QueryResult {
+var (
+	legendFormat *regexp.Regexp
+)
+
+func init() {
+	legendFormat = regexp.MustCompile(`\[\[(\w+?)*\]\]*|\$\s*(\w+?)*`)
+}
+
+func (rp *ResponseParser) Parse(response *Response, query *Query) *tsdb.QueryResult {
 	queryRes := tsdb.NewQueryResult()
 
 	for _, result := range response.Results {
-		queryRes.Series = append(queryRes.Series, rp.transformRows(result.Series, queryRes)...)
+		queryRes.Series = append(queryRes.Series, rp.transformRows(result.Series, queryRes, query)...)
 	}
 
 	return queryRes
 }
 
-func (rp *ResponseParser) transformRows(rows []Row, queryResult *tsdb.QueryResult) tsdb.TimeSeriesSlice {
+func (rp *ResponseParser) transformRows(rows []Row, queryResult *tsdb.QueryResult, query *Query) tsdb.TimeSeriesSlice {
 	var result tsdb.TimeSeriesSlice
 
 	for _, row := range rows {
@@ -38,7 +48,7 @@ func (rp *ResponseParser) transformRows(rows []Row, queryResult *tsdb.QueryResul
 				}
 			}
 			result = append(result, &tsdb.TimeSeries{
-				Name:   rp.formatSerieName(row, column),
+				Name:   rp.formatSerieName(row, column, query),
 				Points: points,
 			})
 		}
@@ -47,7 +57,48 @@ func (rp *ResponseParser) transformRows(rows []Row, queryResult *tsdb.QueryResul
 	return result
 }
 
-func (rp *ResponseParser) formatSerieName(row Row, column string) string {
+func (rp *ResponseParser) formatSerieName(row Row, column string, query *Query) string {
+	if query.Alias == "" {
+		return rp.buildSerieNameFromQuery(row, column)
+	}
+
+	nameSegment := strings.Split(row.Name, ".")
+
+	result := legendFormat.ReplaceAllFunc([]byte(query.Alias), func(in []byte) []byte {
+		aliasFormat := string(in)
+		aliasFormat = strings.Replace(aliasFormat, "[[", "", 1)
+		aliasFormat = strings.Replace(aliasFormat, "]]", "", 1)
+		aliasFormat = strings.Replace(aliasFormat, "$", "", 1)
+
+		if aliasFormat == "m" || aliasFormat == "measurement" {
+			return []byte(query.Measurement)
+		}
+		if aliasFormat == "col" {
+			return []byte(column)
+		}
+
+		pos, err := strconv.Atoi(aliasFormat)
+		if err == nil && len(nameSegment) >= pos {
+			return []byte(nameSegment[pos])
+		}
+
+		if !strings.HasPrefix(aliasFormat, "tag_") {
+			return in
+		}
+
+		tagKey := strings.Replace(aliasFormat, "tag_", "", 1)
+		tagValue, exist := row.Tags[tagKey]
+		if exist {
+			return []byte(tagValue)
+		}
+
+		return in
+	})
+
+	return string(result)
+}
+
+func (rp *ResponseParser) buildSerieNameFromQuery(row Row, column string) string {
 	var tags []string
 
 	for k, v := range row.Tags {

pkg/tsdb/influxdb/response_parser_test.go

@@ -4,56 +4,161 @@ import (
 	"encoding/json"
 	"testing"
 
+	"github.com/grafana/grafana/pkg/setting"
 	. "github.com/smartystreets/goconvey/convey"
 )
 
 func TestInfluxdbResponseParser(t *testing.T) {
 	Convey("Influxdb response parser", t, func() {
+		Convey("Response parser", func() {
+			parser := &ResponseParser{}
 
-		parser := &ResponseParser{}
+			setting.NewConfigContext(&setting.CommandLineArgs{
+				HomePath: "../../../",
+			})
 
-		response := &Response{
+			response := &Response{
-			Results: []Result{
+				Results: []Result{
-				Result{
+					Result{
-					Series: []Row{
+						Series: []Row{
-						{
+							{
-							Name:    "cpu",
+								Name:    "cpu",
-							Columns: []string{"time", "mean", "sum"},
+								Columns: []string{"time", "mean", "sum"},
-							Tags:    map[string]string{"datacenter": "America"},
+								Tags:    map[string]string{"datacenter": "America"},
-							Values: [][]interface{}{
+								Values: [][]interface{}{
-								{json.Number("111"), json.Number("222"), json.Number("333")},
+									{json.Number("111"), json.Number("222"), json.Number("333")},
-								{json.Number("111"), json.Number("222"), json.Number("333")},
+									{json.Number("111"), json.Number("222"), json.Number("333")},
-								{json.Number("111"), json.Number("null"), json.Number("333")},
+									{json.Number("111"), json.Number("null"), json.Number("333")},
+								},
 							},
 						},
 					},
 				},
-			},
+			}
-		}
 
-		result := parser.Parse(response)
+			query := &Query{}
 
-		Convey("can parse all series", func() {
+			result := parser.Parse(response, query)
-			So(len(result.Series), ShouldEqual, 2)
+
+			Convey("can parse all series", func() {
+				So(len(result.Series), ShouldEqual, 2)
+			})
+
+			Convey("can parse all points", func() {
+				So(len(result.Series[0].Points), ShouldEqual, 3)
+				So(len(result.Series[1].Points), ShouldEqual, 3)
+			})
+
+			Convey("can parse multi row result", func() {
+				So(result.Series[0].Points[1][0].Float64, ShouldEqual, float64(222))
+				So(result.Series[1].Points[1][0].Float64, ShouldEqual, float64(333))
+			})
+
+			Convey("can parse null points", func() {
+				So(result.Series[0].Points[2][0].Valid, ShouldBeFalse)
+			})
+
+			Convey("can format serie names", func() {
+				So(result.Series[0].Name, ShouldEqual, "cpu.mean { datacenter: America }")
+				So(result.Series[1].Name, ShouldEqual, "cpu.sum { datacenter: America }")
+			})
 		})
 
-		Convey("can parse all points", func() {
+		Convey("Response parser with alias", func() {
-			So(len(result.Series[0].Points), ShouldEqual, 3)
+			parser := &ResponseParser{}
-			So(len(result.Series[1].Points), ShouldEqual, 3)
-		})
 
-		Convey("can parse multi row result", func() {
+			response := &Response{
-			So(result.Series[0].Points[1][0].Float64, ShouldEqual, float64(222))
+				Results: []Result{
-			So(result.Series[1].Points[1][0].Float64, ShouldEqual, float64(333))
+					Result{
-		})
+						Series: []Row{
+							{
+								Name:    "cpu.upc",
+								Columns: []string{"time", "mean", "sum"},
+								Tags:    map[string]string{"datacenter": "America"},
+								Values: [][]interface{}{
+									{json.Number("111"), json.Number("222"), json.Number("333")},
+								},
+							},
+						},
+					},
+				},
+			}
 
-		Convey("can parse null points", func() {
+			Convey("$ alias", func() {
-			So(result.Series[0].Points[2][0].Valid, ShouldBeFalse)
+				Convey("simple alias", func() {
-		})
+					query := &Query{Alias: "serie alias"}
+					result := parser.Parse(response, query)
 
-		Convey("can format serie names", func() {
+					So(result.Series[0].Name, ShouldEqual, "serie alias")
-			So(result.Series[0].Name, ShouldEqual, "cpu.mean { datacenter: America }")
+				})
-			So(result.Series[1].Name, ShouldEqual, "cpu.sum { datacenter: America }")
+
+				Convey("measurement alias", func() {
+					query := &Query{Alias: "alias $m $measurement", Measurement: "10m"}
+					result := parser.Parse(response, query)
+
+					So(result.Series[0].Name, ShouldEqual, "alias 10m 10m")
+				})
+
+				Convey("column alias", func() {
+					query := &Query{Alias: "alias $col", Measurement: "10m"}
+					result := parser.Parse(response, query)
+
+					So(result.Series[0].Name, ShouldEqual, "alias mean")
+					So(result.Series[1].Name, ShouldEqual, "alias sum")
+				})
+
+				Convey("tag alias", func() {
+					query := &Query{Alias: "alias $tag_datacenter"}
+					result := parser.Parse(response, query)
+
+					So(result.Series[0].Name, ShouldEqual, "alias America")
+				})
+
+				Convey("segment alias", func() {
+					query := &Query{Alias: "alias $1"}
+					result := parser.Parse(response, query)
+
+					So(result.Series[0].Name, ShouldEqual, "alias upc")
+				})
+
+				Convey("segment position out of bound", func() {
+					query := &Query{Alias: "alias $5"}
+					result := parser.Parse(response, query)
+
+					So(result.Series[0].Name, ShouldEqual, "alias $5")
+				})
+			})
+
+			Convey("[[]] alias", func() {
+				Convey("simple alias", func() {
+					query := &Query{Alias: "serie alias"}
+					result := parser.Parse(response, query)
+
+					So(result.Series[0].Name, ShouldEqual, "serie alias")
+				})
+
+				Convey("measurement alias", func() {
+					query := &Query{Alias: "alias [[m]] [[measurement]]", Measurement: "10m"}
+					result := parser.Parse(response, query)
+
+					So(result.Series[0].Name, ShouldEqual, "alias 10m 10m")
+				})
+
+				Convey("column alias", func() {
+					query := &Query{Alias: "alias [[col]]", Measurement: "10m"}
+					result := parser.Parse(response, query)
+
+					So(result.Series[0].Name, ShouldEqual, "alias mean")
+					So(result.Series[1].Name, ShouldEqual, "alias sum")
+				})
+
+				Convey("tag alias", func() {
+					query := &Query{Alias: "alias [[tag_datacenter]]"}
+					result := parser.Parse(response, query)
+
+					So(result.Series[0].Name, ShouldEqual, "alias America")
+				})
+			})
 		})
 	})
 }

pkg/tsdb/prometheus/prometheus.go

@@ -24,12 +24,14 @@ func NewPrometheusExecutor(dsInfo *tsdb.DataSourceInfo) tsdb.Executor {
 }
 
 var (
-	plog log.Logger
+	plog         log.Logger
+	legendFormat *regexp.Regexp
 )
 
 func init() {
 	plog = log.New("tsdb.prometheus")
 	tsdb.RegisterExecutor("prometheus", NewPrometheusExecutor)
+	legendFormat = regexp.MustCompile(`\{\{\s*(.+?)\s*\}\}`)
 }
 
 func (e *PrometheusExecutor) getClient() (prometheus.QueryAPI, error) {
@@ -79,13 +81,11 @@ func (e *PrometheusExecutor) Execute(ctx context.Context, queries tsdb.QuerySlic
 }
 
 func formatLegend(metric pmodel.Metric, query *PrometheusQuery) string {
-	reg, _ := regexp.Compile(`\{\{\s*(.+?)\s*\}\}`)
-
 	if query.LegendFormat == "" {
 		return metric.String()
 	}
 
-	result := reg.ReplaceAllFunc([]byte(query.LegendFormat), func(in []byte) []byte {
+	result := legendFormat.ReplaceAllFunc([]byte(query.LegendFormat), func(in []byte) []byte {
 		labelName := strings.Replace(string(in), "{{", "", 1)
 		labelName = strings.Replace(labelName, "}}", "", 1)
 		labelName = strings.TrimSpace(labelName)

public/app/plugins/datasource/influxdb/partials/query.options.html

@@ -4,16 +4,15 @@
 			<div class="gf-form">
 				<span class="gf-form-label"><i class="fa fa-wrench"></i></span>
 				<span class="gf-form-label width-11">Group by time interval</span>
-				<input type="text" class="gf-form-input" ng-model="ctrl.panelCtrl.panel.interval" ng-blur="ctrl.panelCtrl.refresh();"
+				<input type="text" class="gf-form-input width-16" ng-model="ctrl.panelCtrl.panel.interval" ng-blur="ctrl.panelCtrl.refresh();"
 				spellcheck='false' placeholder="example: >10s">
-				<span class="gf-form-label"><i class="fa fa-question-circle" bs-tooltip="'Set a low limit by having a greater sign: example: >60s'" data-placement="right"></i></span>
+				<info-popover mode="right-absolute">
+          Set a low limit by having a greater sign: example: >60s
+        </info-popover>
 			</div>
 		</div>
 		<div class="gf-form-inline">
 			<div class="gf-form">
-				<!--span class="gf-form-label">
-					<i class="fa fa-info-circle"></i>
-				</span-->
 				<span class="gf-form-label width-10">
 					<a ng-click="ctrl.panelCtrl.toggleEditorHelp(1);" bs-tooltip="'click to show helpful info'" data-placement="bottom">
 						<i class="fa fa-info-circle"></i>