CloudWatch: Datasource improvements (#20268)

* CloudWatch: Datasource improvements

* Add statistic as template variale

* Add wildcard to list of values

* Template variable intercept dimension key

* Return row specific errors when transformation error occured

* Add meta feedback

* Make it possible to retrieve values without known metrics

* Add curated dashboard for EC2

* Fix broken tests

* Use correct dashboard name

* Display alert in case multi template var is being used for some certain props in the cloudwatch query

* Minor fixes after feedback

* Update dashboard json

* Update snapshot test

* Make sure region default is intercepted in cloudwatch link

* Update dashboards

* Include ec2 dashboard in ds

* Do not include ec2 dashboard in beta1

* Display actual region

pkg/tsdb/cloudwatch/annotation_query.go

@@ -24,7 +24,7 @@ func (e *CloudWatchExecutor) executeAnnotationQuery(ctx context.Context, queryCo
 	namespace := parameters.Get("namespace").MustString("")
 	metricName := parameters.Get("metricName").MustString("")
 	dimensions := parameters.Get("dimensions").MustMap()
-	statistics, extendedStatistics, err := parseStatistics(parameters)
+	statistics, err := parseStatistics(parameters)
 	if err != nil {
 		return nil, err
 	}
@@ -51,7 +51,7 @@ func (e *CloudWatchExecutor) executeAnnotationQuery(ctx context.Context, queryCo
 		if err != nil {
 			return nil, errors.New("Failed to call cloudwatch:DescribeAlarms")
 		}
-		alarmNames = filterAlarms(resp, namespace, metricName, dimensions, statistics, extendedStatistics, period)
+		alarmNames = filterAlarms(resp, namespace, metricName, dimensions, statistics, period)
 	} else {
 		if region == "" || namespace == "" || metricName == "" || len(statistics) == 0 {
 			return result, nil
@@ -82,22 +82,6 @@ func (e *CloudWatchExecutor) executeAnnotationQuery(ctx context.Context, queryCo
 				alarmNames = append(alarmNames, alarm.AlarmName)
 			}
 		}
-		for _, s := range extendedStatistics {
-			params := &cloudwatch.DescribeAlarmsForMetricInput{
-				Namespace:         aws.String(namespace),
-				MetricName:        aws.String(metricName),
-				Dimensions:        qd,
-				ExtendedStatistic: aws.String(s),
-				Period:            aws.Int64(period),
-			}
-			resp, err := svc.DescribeAlarmsForMetric(params)
-			if err != nil {
-				return nil, errors.New("Failed to call cloudwatch:DescribeAlarmsForMetric")
-			}
-			for _, alarm := range resp.MetricAlarms {
-				alarmNames = append(alarmNames, alarm.AlarmName)
-			}
-		}
 	}
 
 	startTime, err := queryContext.TimeRange.ParseFrom()
@@ -158,7 +142,7 @@ func transformAnnotationToTable(data []map[string]string, result *tsdb.QueryResu
 	result.Meta.Set("rowCount", len(data))
 }
 
-func filterAlarms(alarms *cloudwatch.DescribeAlarmsOutput, namespace string, metricName string, dimensions map[string]interface{}, statistics []string, extendedStatistics []string, period int64) []*string {
+func filterAlarms(alarms *cloudwatch.DescribeAlarmsOutput, namespace string, metricName string, dimensions map[string]interface{}, statistics []string, period int64) []*string {
 	alarmNames := make([]*string, 0)
 
 	for _, alarm := range alarms.MetricAlarms {
@@ -197,18 +181,6 @@ func filterAlarms(alarms *cloudwatch.DescribeAlarmsOutput, namespace string, met
 			}
 		}
 
-		if len(extendedStatistics) != 0 {
-			found := false
-			for _, s := range extendedStatistics {
-				if *alarm.Statistic == s {
-					found = true
-				}
-			}
-			if !found {
-				continue
-			}
-		}
-
 		if period != 0 && *alarm.Period != period {
 			continue
 		}

pkg/tsdb/cloudwatch/cloudwatch.go

@@ -2,18 +2,13 @@ package cloudwatch
 
 import (
 	"context"
-	"fmt"
 	"regexp"
-	"strconv"
-	"strings"
 
-	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
 	"github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi/resourcegroupstaggingapiiface"
 	"github.com/grafana/grafana/pkg/infra/log"
 	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/tsdb"
-	"golang.org/x/sync/errgroup"
 )
 
 type CloudWatchExecutor struct {
@@ -38,21 +33,13 @@ func NewCloudWatchExecutor(dsInfo *models.DataSource) (tsdb.TsdbQueryEndpoint, e
 }
 
 var (
-	plog               log.Logger
-	standardStatistics map[string]bool
-	aliasFormat        *regexp.Regexp
+	plog        log.Logger
+	aliasFormat *regexp.Regexp
 )
 
 func init() {
 	plog = log.New("tsdb.cloudwatch")
 	tsdb.RegisterTsdbQueryEndpoint("cloudwatch", NewCloudWatchExecutor)
-	standardStatistics = map[string]bool{
-		"Average":     true,
-		"Maximum":     true,
-		"Minimum":     true,
-		"Sum":         true,
-		"SampleCount": true,
-	}
 	aliasFormat = regexp.MustCompile(`\{\{\s*(.+?)\s*\}\}`)
 }
 
@@ -75,162 +62,3 @@ func (e *CloudWatchExecutor) Query(ctx context.Context, dsInfo *models.DataSourc
 
 	return result, err
 }
-
-func (e *CloudWatchExecutor) executeTimeSeriesQuery(ctx context.Context, queryContext *tsdb.TsdbQuery) (*tsdb.Response, error) {
-	results := &tsdb.Response{
-		Results: make(map[string]*tsdb.QueryResult),
-	}
-	resultChan := make(chan *tsdb.QueryResult, len(queryContext.Queries))
-
-	eg, ectx := errgroup.WithContext(ctx)
-
-	getMetricDataQueries := make(map[string]map[string]*CloudWatchQuery)
-	for i, model := range queryContext.Queries {
-		queryType := model.Model.Get("type").MustString()
-		if queryType != "timeSeriesQuery" && queryType != "" {
-			continue
-		}
-
-		RefId := queryContext.Queries[i].RefId
-		query, err := parseQuery(queryContext.Queries[i].Model)
-		if err != nil {
-			results.Results[RefId] = &tsdb.QueryResult{
-				Error: err,
-			}
-			return results, nil
-		}
-		query.RefId = RefId
-
-		if query.Id != "" {
-			if _, ok := getMetricDataQueries[query.Region]; !ok {
-				getMetricDataQueries[query.Region] = make(map[string]*CloudWatchQuery)
-			}
-			getMetricDataQueries[query.Region][query.Id] = query
-			continue
-		}
-
-		if query.Id == "" && query.Expression != "" {
-			results.Results[query.RefId] = &tsdb.QueryResult{
-				Error: fmt.Errorf("Invalid query: id should be set if using expression"),
-			}
-			return results, nil
-		}
-
-		eg.Go(func() error {
-			defer func() {
-				if err := recover(); err != nil {
-					plog.Error("Execute Query Panic", "error", err, "stack", log.Stack(1))
-					if theErr, ok := err.(error); ok {
-						resultChan <- &tsdb.QueryResult{
-							RefId: query.RefId,
-							Error: theErr,
-						}
-					}
-				}
-			}()
-
-			queryRes, err := e.executeQuery(ectx, query, queryContext)
-			if ae, ok := err.(awserr.Error); ok && ae.Code() == "500" {
-				return err
-			}
-			if err != nil {
-				resultChan <- &tsdb.QueryResult{
-					RefId: query.RefId,
-					Error: err,
-				}
-				return nil
-			}
-			resultChan <- queryRes
-			return nil
-		})
-	}
-
-	if len(getMetricDataQueries) > 0 {
-		for region, getMetricDataQuery := range getMetricDataQueries {
-			q := getMetricDataQuery
-			eg.Go(func() error {
-				defer func() {
-					if err := recover(); err != nil {
-						plog.Error("Execute Get Metric Data Query Panic", "error", err, "stack", log.Stack(1))
-						if theErr, ok := err.(error); ok {
-							resultChan <- &tsdb.QueryResult{
-								Error: theErr,
-							}
-						}
-					}
-				}()
-
-				queryResponses, err := e.executeGetMetricDataQuery(ectx, region, q, queryContext)
-				if ae, ok := err.(awserr.Error); ok && ae.Code() == "500" {
-					return err
-				}
-				for _, queryRes := range queryResponses {
-					if err != nil {
-						queryRes.Error = err
-					}
-					resultChan <- queryRes
-				}
-				return nil
-			})
-		}
-	}
-
-	if err := eg.Wait(); err != nil {
-		return nil, err
-	}
-	close(resultChan)
-	for result := range resultChan {
-		results.Results[result.RefId] = result
-	}
-
-	return results, nil
-}
-
-func formatAlias(query *CloudWatchQuery, stat string, dimensions map[string]string, label string) string {
-	region := query.Region
-	namespace := query.Namespace
-	metricName := query.MetricName
-	period := strconv.Itoa(query.Period)
-	if len(query.Id) > 0 && len(query.Expression) > 0 {
-		if strings.Index(query.Expression, "SEARCH(") == 0 {
-			pIndex := strings.LastIndex(query.Expression, ",")
-			period = strings.Trim(query.Expression[pIndex+1:], " )")
-			sIndex := strings.LastIndex(query.Expression[:pIndex], ",")
-			stat = strings.Trim(query.Expression[sIndex+1:pIndex], " '")
-		} else if len(query.Alias) > 0 {
-			// expand by Alias
-		} else {
-			return query.Id
-		}
-	}
-
-	data := map[string]string{}
-	data["region"] = region
-	data["namespace"] = namespace
-	data["metric"] = metricName
-	data["stat"] = stat
-	data["period"] = period
-	if len(label) != 0 {
-		data["label"] = label
-	}
-	for k, v := range dimensions {
-		data[k] = v
-	}
-
-	result := aliasFormat.ReplaceAllFunc([]byte(query.Alias), func(in []byte) []byte {
-		labelName := strings.Replace(string(in), "{{", "", 1)
-		labelName = strings.Replace(labelName, "}}", "", 1)
-		labelName = strings.TrimSpace(labelName)
-		if val, exists := data[labelName]; exists {
-			return []byte(val)
-		}
-
-		return in
-	})
-
-	if string(result) == "" {
-		return metricName + "_" + stat
-	}
-
-	return string(result)
-}

pkg/tsdb/cloudwatch/cloudwatch_query.go

@@ -0,0 +1,62 @@
+package cloudwatch
+
+import (
+	"strings"
+)
+
+type cloudWatchQuery struct {
+	RefId                   string
+	Region                  string
+	Id                      string
+	Namespace               string
+	MetricName              string
+	Stats                   string
+	Expression              string
+	ReturnData              bool
+	Dimensions              map[string][]string
+	Period                  int
+	Alias                   string
+	Identifier              string
+	HighResolution          bool
+	MatchExact              bool
+	UsedExpression          string
+	RequestExceededMaxLimit bool
+}
+
+func (q *cloudWatchQuery) isMathExpression() bool {
+	return q.Expression != "" && !q.isUserDefinedSearchExpression()
+}
+
+func (q *cloudWatchQuery) isSearchExpression() bool {
+	return q.isUserDefinedSearchExpression() || q.isInferredSearchExpression()
+}
+
+func (q *cloudWatchQuery) isUserDefinedSearchExpression() bool {
+	return strings.Contains(q.Expression, "SEARCH(")
+}
+
+func (q *cloudWatchQuery) isInferredSearchExpression() bool {
+	if len(q.Dimensions) == 0 {
+		return !q.MatchExact
+	}
+
+	if !q.MatchExact {
+		return true
+	}
+
+	for _, values := range q.Dimensions {
+		if len(values) > 1 {
+			return true
+		}
+		for _, v := range values {
+			if v == "*" {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func (q *cloudWatchQuery) isMetricStat() bool {
+	return !q.isSearchExpression() && !q.isMathExpression()
+}

pkg/tsdb/cloudwatch/cloudwatch_query_test.go

@@ -0,0 +1,175 @@
+package cloudwatch
+
+import (
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestCloudWatchQuery(t *testing.T) {
+	Convey("TestCloudWatchQuery", t, func() {
+		Convey("and SEARCH(someexpression) was specified in the query editor", func() {
+			query := &cloudWatchQuery{
+				RefId:      "A",
+				Region:     "us-east-1",
+				Expression: "SEARCH(someexpression)",
+				Stats:      "Average",
+				Period:     300,
+				Id:         "id1",
+				Identifier: "id1",
+			}
+
+			Convey("it is a search expression", func() {
+				So(query.isSearchExpression(), ShouldBeTrue)
+			})
+
+			Convey("it is not math expressions", func() {
+				So(query.isMathExpression(), ShouldBeFalse)
+			})
+		})
+
+		Convey("and no expression, no multi dimension key values and no * was used", func() {
+			query := &cloudWatchQuery{
+				RefId:      "A",
+				Region:     "us-east-1",
+				Expression: "",
+				Stats:      "Average",
+				Period:     300,
+				Id:         "id1",
+				Identifier: "id1",
+				MatchExact: true,
+				Dimensions: map[string][]string{
+					"InstanceId": {"i-12345678"},
+				},
+			}
+
+			Convey("it is not a search expression", func() {
+				So(query.isSearchExpression(), ShouldBeFalse)
+			})
+
+			Convey("it is not math expressions", func() {
+				So(query.isMathExpression(), ShouldBeFalse)
+			})
+		})
+
+		Convey("and no expression but multi dimension key values exist", func() {
+			query := &cloudWatchQuery{
+				RefId:      "A",
+				Region:     "us-east-1",
+				Expression: "",
+				Stats:      "Average",
+				Period:     300,
+				Id:         "id1",
+				Identifier: "id1",
+				Dimensions: map[string][]string{
+					"InstanceId": {"i-12345678", "i-34562312"},
+				},
+			}
+
+			Convey("it is a search expression", func() {
+				So(query.isSearchExpression(), ShouldBeTrue)
+			})
+
+			Convey("it is not math expressions", func() {
+				So(query.isMathExpression(), ShouldBeFalse)
+			})
+		})
+
+		Convey("and no expression but dimension values has *", func() {
+			query := &cloudWatchQuery{
+				RefId:      "A",
+				Region:     "us-east-1",
+				Expression: "",
+				Stats:      "Average",
+				Period:     300,
+				Id:         "id1",
+				Identifier: "id1",
+				Dimensions: map[string][]string{
+					"InstanceId":   {"i-12345678", "*"},
+					"InstanceType": {"abc", "def"},
+				},
+			}
+
+			Convey("it is not a search expression", func() {
+				So(query.isSearchExpression(), ShouldBeTrue)
+			})
+
+			Convey("it is not math expressions", func() {
+				So(query.isMathExpression(), ShouldBeFalse)
+			})
+		})
+
+		Convey("and no dimensions were added", func() {
+			query := &cloudWatchQuery{
+				RefId:      "A",
+				Region:     "us-east-1",
+				Expression: "",
+				Stats:      "Average",
+				Period:     300,
+				Id:         "id1",
+				MatchExact: false,
+				Identifier: "id1",
+				Dimensions: make(map[string][]string),
+			}
+			Convey("and match exact is false", func() {
+				query.MatchExact = false
+				Convey("it is a search expression", func() {
+					So(query.isSearchExpression(), ShouldBeTrue)
+				})
+
+				Convey("it is not math expressions", func() {
+					So(query.isMathExpression(), ShouldBeFalse)
+				})
+
+				Convey("it is not metric stat", func() {
+					So(query.isMetricStat(), ShouldBeFalse)
+				})
+
+			})
+
+			Convey("and match exact is true", func() {
+				query.MatchExact = true
+				Convey("it is a search expression", func() {
+					So(query.isSearchExpression(), ShouldBeFalse)
+				})
+
+				Convey("it is not math expressions", func() {
+					So(query.isMathExpression(), ShouldBeFalse)
+				})
+
+				Convey("it is a metric stat", func() {
+					So(query.isMetricStat(), ShouldBeTrue)
+				})
+
+			})
+		})
+
+		Convey("and match exact is", func() {
+			query := &cloudWatchQuery{
+				RefId:      "A",
+				Region:     "us-east-1",
+				Expression: "",
+				Stats:      "Average",
+				Period:     300,
+				Id:         "id1",
+				Identifier: "id1",
+				MatchExact: false,
+				Dimensions: map[string][]string{
+					"InstanceId": {"i-12345678"},
+				},
+			}
+
+			Convey("it is a search expression", func() {
+				So(query.isSearchExpression(), ShouldBeTrue)
+			})
+
+			Convey("it is not math expressions", func() {
+				So(query.isMathExpression(), ShouldBeFalse)
+			})
+
+			Convey("it is not metric stat", func() {
+				So(query.isMetricStat(), ShouldBeFalse)
+			})
+		})
+	})
+}

pkg/tsdb/cloudwatch/cloudwatch_test.go

@@ -1,35 +0,0 @@
-package cloudwatch
-
-import (
-	"context"
-	"testing"
-
-	"github.com/grafana/grafana/pkg/models"
-	"github.com/grafana/grafana/pkg/tsdb"
-
-	"github.com/grafana/grafana/pkg/components/simplejson"
-	. "github.com/smartystreets/goconvey/convey"
-)
-
-func TestCloudWatch(t *testing.T) {
-	Convey("CloudWatch", t, func() {
-
-		Convey("executeQuery", func() {
-			e := &CloudWatchExecutor{
-				DataSource: &models.DataSource{
-					JsonData: simplejson.New(),
-				},
-			}
-
-			Convey("End time before start time should result in error", func() {
-				_, err := e.executeQuery(context.Background(), &CloudWatchQuery{}, &tsdb.TsdbQuery{TimeRange: tsdb.NewTimeRange("now-1h", "now-2h")})
-				So(err.Error(), ShouldEqual, "Invalid time range: Start time must be before end time")
-			})
-
-			Convey("End time equals start time should result in error", func() {
-				_, err := e.executeQuery(context.Background(), &CloudWatchQuery{}, &tsdb.TsdbQuery{TimeRange: tsdb.NewTimeRange("now-1h", "now-1h")})
-				So(err.Error(), ShouldEqual, "Invalid time range: Start time must be before end time")
-			})
-		})
-	})
-}

pkg/tsdb/cloudwatch/constants.go

@@ -1,30 +0,0 @@
-package cloudwatch
-
-var cloudwatchUnitMappings = map[string]string{
-	"Seconds":      "s",
-	"Microseconds": "µs",
-	"Milliseconds": "ms",
-	"Bytes":        "bytes",
-	"Kilobytes":    "kbytes",
-	"Megabytes":    "mbytes",
-	"Gigabytes":    "gbytes",
-	//"Terabytes":        "",
-	"Bits": "bits",
-	//"Kilobits":         "",
-	//"Megabits":         "",
-	//"Gigabits":         "",
-	//"Terabits":         "",
-	"Percent": "percent",
-	//"Count":            "",
-	"Bytes/Second":     "Bps",
-	"Kilobytes/Second": "KBs",
-	"Megabytes/Second": "MBs",
-	"Gigabytes/Second": "GBs",
-	//"Terabytes/Second": "",
-	"Bits/Second":     "bps",
-	"Kilobits/Second": "Kbits",
-	"Megabits/Second": "Mbits",
-	"Gigabits/Second": "Gbits",
-	//"Terabits/Second":  "",
-	//"Count/Second":     "",
-}

pkg/tsdb/cloudwatch/credentials.go

@@ -12,9 +12,11 @@ import (
 	"github.com/aws/aws-sdk-go/aws/credentials/endpointcreds"
 	"github.com/aws/aws-sdk-go/aws/defaults"
 	"github.com/aws/aws-sdk-go/aws/ec2metadata"
+	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/cloudwatch"
 	"github.com/aws/aws-sdk-go/service/sts"
+	"github.com/grafana/grafana/pkg/setting"
 )
 
 type cache struct {
@@ -180,6 +182,7 @@ func (e *CloudWatchExecutor) getAwsConfig(dsInfo *DatasourceInfo) (*aws.Config,
 		Region:      aws.String(dsInfo.Region),
 		Credentials: creds,
 	}
+
 	return cfg, nil
 }
 
@@ -196,5 +199,10 @@ func (e *CloudWatchExecutor) getClient(region string) (*cloudwatch.CloudWatch, e
 	}
 
 	client := cloudwatch.New(sess, cfg)
+
+	client.Handlers.Send.PushFront(func(r *request.Request) {
+		r.HTTPRequest.Header.Set("User-Agent", fmt.Sprintf("Grafana/%s", setting.BuildVersion))
+	})
+
 	return client, nil
 }

pkg/tsdb/cloudwatch/get_metric_data.go

@@ -1,171 +0,0 @@
-package cloudwatch
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/cloudwatch"
-	"github.com/grafana/grafana/pkg/components/null"
-	"github.com/grafana/grafana/pkg/components/simplejson"
-	"github.com/grafana/grafana/pkg/infra/metrics"
-	"github.com/grafana/grafana/pkg/tsdb"
-)
-
-func (e *CloudWatchExecutor) executeGetMetricDataQuery(ctx context.Context, region string, queries map[string]*CloudWatchQuery, queryContext *tsdb.TsdbQuery) ([]*tsdb.QueryResult, error) {
-	queryResponses := make([]*tsdb.QueryResult, 0)
-
-	client, err := e.getClient(region)
-	if err != nil {
-		return queryResponses, err
-	}
-
-	params, err := parseGetMetricDataQuery(queries, queryContext)
-	if err != nil {
-		return queryResponses, err
-	}
-
-	nextToken := ""
-	mdr := make(map[string]map[string]*cloudwatch.MetricDataResult)
-	for {
-		if nextToken != "" {
-			params.NextToken = aws.String(nextToken)
-		}
-		resp, err := client.GetMetricDataWithContext(ctx, params)
-		if err != nil {
-			return queryResponses, err
-		}
-		metrics.MAwsCloudWatchGetMetricData.Add(float64(len(params.MetricDataQueries)))
-
-		for _, r := range resp.MetricDataResults {
-			if _, ok := mdr[*r.Id]; !ok {
-				mdr[*r.Id] = make(map[string]*cloudwatch.MetricDataResult)
-				mdr[*r.Id][*r.Label] = r
-			} else if _, ok := mdr[*r.Id][*r.Label]; !ok {
-				mdr[*r.Id][*r.Label] = r
-			} else {
-				mdr[*r.Id][*r.Label].Timestamps = append(mdr[*r.Id][*r.Label].Timestamps, r.Timestamps...)
-				mdr[*r.Id][*r.Label].Values = append(mdr[*r.Id][*r.Label].Values, r.Values...)
-			}
-		}
-
-		if resp.NextToken == nil || *resp.NextToken == "" {
-			break
-		}
-		nextToken = *resp.NextToken
-	}
-
-	for id, lr := range mdr {
-		queryRes, err := parseGetMetricDataResponse(lr, queries[id])
-		if err != nil {
-			return queryResponses, err
-		}
-		queryResponses = append(queryResponses, queryRes)
-	}
-
-	return queryResponses, nil
-}
-
-func parseGetMetricDataQuery(queries map[string]*CloudWatchQuery, queryContext *tsdb.TsdbQuery) (*cloudwatch.GetMetricDataInput, error) {
-	// validate query
-	for _, query := range queries {
-		if !(len(query.Statistics) == 1 && len(query.ExtendedStatistics) == 0) &&
-			!(len(query.Statistics) == 0 && len(query.ExtendedStatistics) == 1) {
-			return nil, errors.New("Statistics count should be 1")
-		}
-	}
-
-	startTime, err := queryContext.TimeRange.ParseFrom()
-	if err != nil {
-		return nil, err
-	}
-
-	endTime, err := queryContext.TimeRange.ParseTo()
-	if err != nil {
-		return nil, err
-	}
-
-	params := &cloudwatch.GetMetricDataInput{
-		StartTime: aws.Time(startTime),
-		EndTime:   aws.Time(endTime),
-		ScanBy:    aws.String("TimestampAscending"),
-	}
-	for _, query := range queries {
-		// 1 minutes resolution metrics is stored for 15 days, 15 * 24 * 60 = 21600
-		if query.HighResolution && (((endTime.Unix() - startTime.Unix()) / int64(query.Period)) > 21600) {
-			return nil, errors.New("too long query period")
-		}
-
-		mdq := &cloudwatch.MetricDataQuery{
-			Id:         aws.String(query.Id),
-			ReturnData: aws.Bool(query.ReturnData),
-		}
-		if query.Expression != "" {
-			mdq.Expression = aws.String(query.Expression)
-		} else {
-			mdq.MetricStat = &cloudwatch.MetricStat{
-				Metric: &cloudwatch.Metric{
-					Namespace:  aws.String(query.Namespace),
-					MetricName: aws.String(query.MetricName),
-				},
-				Period: aws.Int64(int64(query.Period)),
-			}
-			for _, d := range query.Dimensions {
-				mdq.MetricStat.Metric.Dimensions = append(mdq.MetricStat.Metric.Dimensions,
-					&cloudwatch.Dimension{
-						Name:  d.Name,
-						Value: d.Value,
-					})
-			}
-			if len(query.Statistics) == 1 {
-				mdq.MetricStat.Stat = query.Statistics[0]
-			} else {
-				mdq.MetricStat.Stat = query.ExtendedStatistics[0]
-			}
-		}
-		params.MetricDataQueries = append(params.MetricDataQueries, mdq)
-	}
-	return params, nil
-}
-
-func parseGetMetricDataResponse(lr map[string]*cloudwatch.MetricDataResult, query *CloudWatchQuery) (*tsdb.QueryResult, error) {
-	queryRes := tsdb.NewQueryResult()
-	queryRes.RefId = query.RefId
-
-	for label, r := range lr {
-		if *r.StatusCode != "Complete" {
-			return queryRes, fmt.Errorf("Part of query is failed: %s", *r.StatusCode)
-		}
-
-		series := tsdb.TimeSeries{
-			Tags:   map[string]string{},
-			Points: make([]tsdb.TimePoint, 0),
-		}
-		for _, d := range query.Dimensions {
-			series.Tags[*d.Name] = *d.Value
-		}
-		s := ""
-		if len(query.Statistics) == 1 {
-			s = *query.Statistics[0]
-		} else {
-			s = *query.ExtendedStatistics[0]
-		}
-		series.Name = formatAlias(query, s, series.Tags, label)
-
-		for j, t := range r.Timestamps {
-			if j > 0 {
-				expectedTimestamp := r.Timestamps[j-1].Add(time.Duration(query.Period) * time.Second)
-				if expectedTimestamp.Before(*t) {
-					series.Points = append(series.Points, tsdb.NewTimePoint(null.FloatFromPtr(nil), float64(expectedTimestamp.Unix()*1000)))
-				}
-			}
-			series.Points = append(series.Points, tsdb.NewTimePoint(null.FloatFrom(*r.Values[j]), float64((*t).Unix())*1000))
-		}
-
-		queryRes.Series = append(queryRes.Series, &series)
-		queryRes.Meta = simplejson.New()
-	}
-	return queryRes, nil
-}

pkg/tsdb/cloudwatch/get_metric_data_executor.go

@@ -0,0 +1,34 @@
+package cloudwatch
+
+import (
+	"context"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/cloudwatch"
+	"github.com/grafana/grafana/pkg/infra/metrics"
+)
+
+func (e *CloudWatchExecutor) executeRequest(ctx context.Context, client cloudWatchClient, metricDataInput *cloudwatch.GetMetricDataInput) ([]*cloudwatch.GetMetricDataOutput, error) {
+	mdo := make([]*cloudwatch.GetMetricDataOutput, 0)
+
+	nextToken := ""
+	for {
+		if nextToken != "" {
+			metricDataInput.NextToken = aws.String(nextToken)
+		}
+		resp, err := client.GetMetricDataWithContext(ctx, metricDataInput)
+		if err != nil {
+			return mdo, err
+		}
+
+		mdo = append(mdo, resp)
+		metrics.MAwsCloudWatchGetMetricData.Add(float64(len(metricDataInput.MetricDataQueries)))
+
+		if resp.NextToken == nil || *resp.NextToken == "" {
+			break
+		}
+		nextToken = *resp.NextToken
+	}
+
+	return mdo, nil
+}

pkg/tsdb/cloudwatch/get_metric_data_executor_test.go

@@ -0,0 +1,50 @@
+package cloudwatch
+
+import (
+	"context"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/service/cloudwatch"
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var counter = 1
+
+type cloudWatchFakeClient struct {
+}
+
+func (client *cloudWatchFakeClient) GetMetricDataWithContext(ctx aws.Context, input *cloudwatch.GetMetricDataInput, opts ...request.Option) (*cloudwatch.GetMetricDataOutput, error) {
+	nextToken := "next"
+	res := []*cloudwatch.MetricDataResult{{
+		Values: []*float64{aws.Float64(12.3), aws.Float64(23.5)},
+	}}
+	if counter == 0 {
+		nextToken = ""
+		res = []*cloudwatch.MetricDataResult{{
+			Values: []*float64{aws.Float64(100)},
+		}}
+	}
+	counter--
+	return &cloudwatch.GetMetricDataOutput{
+		MetricDataResults: res,
+		NextToken:         aws.String(nextToken),
+	}, nil
+}
+
+func TestGetMetricDataExecutorTest(t *testing.T) {
+	Convey("TestGetMetricDataExecutorTest", t, func() {
+		Convey("pagination works", func() {
+			executor := &CloudWatchExecutor{}
+			inputs := &cloudwatch.GetMetricDataInput{MetricDataQueries: []*cloudwatch.MetricDataQuery{}}
+			res, err := executor.executeRequest(context.Background(), &cloudWatchFakeClient{}, inputs)
+			So(err, ShouldBeNil)
+			So(len(res), ShouldEqual, 2)
+			So(len(res[0].MetricDataResults[0].Values), ShouldEqual, 2)
+			So(*res[0].MetricDataResults[0].Values[1], ShouldEqual, 23.5)
+			So(*res[1].MetricDataResults[0].Values[0], ShouldEqual, 100)
+		})
+	})
+
+}

pkg/tsdb/cloudwatch/get_metric_data_test.go

@@ -1,116 +0,0 @@
-package cloudwatch
-
-import (
-	"testing"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/cloudwatch"
-	"github.com/grafana/grafana/pkg/components/null"
-	"github.com/grafana/grafana/pkg/tsdb"
-	. "github.com/smartystreets/goconvey/convey"
-)
-
-func TestCloudWatchGetMetricData(t *testing.T) {
-	Convey("CloudWatchGetMetricData", t, func() {
-
-		Convey("can parse cloudwatch GetMetricData query", func() {
-			queries := map[string]*CloudWatchQuery{
-				"id1": {
-					RefId:      "A",
-					Region:     "us-east-1",
-					Namespace:  "AWS/EC2",
-					MetricName: "CPUUtilization",
-					Dimensions: []*cloudwatch.Dimension{
-						{
-							Name:  aws.String("InstanceId"),
-							Value: aws.String("i-12345678"),
-						},
-					},
-					Statistics: []*string{aws.String("Average")},
-					Period:     300,
-					Id:         "id1",
-					Expression: "",
-				},
-				"id2": {
-					RefId:      "B",
-					Region:     "us-east-1",
-					Statistics: []*string{aws.String("Average")},
-					Id:         "id2",
-					Expression: "id1 * 2",
-				},
-			}
-
-			queryContext := &tsdb.TsdbQuery{
-				TimeRange: tsdb.NewFakeTimeRange("5m", "now", time.Now()),
-			}
-			res, err := parseGetMetricDataQuery(queries, queryContext)
-			So(err, ShouldBeNil)
-
-			for _, v := range res.MetricDataQueries {
-				if *v.Id == "id1" {
-					So(*v.MetricStat.Metric.Namespace, ShouldEqual, "AWS/EC2")
-					So(*v.MetricStat.Metric.MetricName, ShouldEqual, "CPUUtilization")
-					So(*v.MetricStat.Metric.Dimensions[0].Name, ShouldEqual, "InstanceId")
-					So(*v.MetricStat.Metric.Dimensions[0].Value, ShouldEqual, "i-12345678")
-					So(*v.MetricStat.Period, ShouldEqual, 300)
-					So(*v.MetricStat.Stat, ShouldEqual, "Average")
-					So(*v.Id, ShouldEqual, "id1")
-				} else {
-					So(*v.Id, ShouldEqual, "id2")
-					So(*v.Expression, ShouldEqual, "id1 * 2")
-				}
-			}
-		})
-
-		Convey("can parse cloudwatch response", func() {
-			timestamp := time.Unix(0, 0)
-			resp := map[string]*cloudwatch.MetricDataResult{
-				"label": {
-					Id:    aws.String("id1"),
-					Label: aws.String("label"),
-					Timestamps: []*time.Time{
-						aws.Time(timestamp),
-						aws.Time(timestamp.Add(60 * time.Second)),
-						aws.Time(timestamp.Add(180 * time.Second)),
-					},
-					Values: []*float64{
-						aws.Float64(10),
-						aws.Float64(20),
-						aws.Float64(30),
-					},
-					StatusCode: aws.String("Complete"),
-				},
-			}
-			query := &CloudWatchQuery{
-				RefId:      "refId1",
-				Region:     "us-east-1",
-				Namespace:  "AWS/ApplicationELB",
-				MetricName: "TargetResponseTime",
-				Dimensions: []*cloudwatch.Dimension{
-					{
-						Name:  aws.String("LoadBalancer"),
-						Value: aws.String("lb"),
-					},
-					{
-						Name:  aws.String("TargetGroup"),
-						Value: aws.String("tg"),
-					},
-				},
-				Statistics: []*string{aws.String("Average")},
-				Period:     60,
-				Alias:      "{{namespace}}_{{metric}}_{{stat}}",
-			}
-			queryRes, err := parseGetMetricDataResponse(resp, query)
-			So(err, ShouldBeNil)
-			So(queryRes.RefId, ShouldEqual, "refId1")
-			So(queryRes.Series[0].Name, ShouldEqual, "AWS/ApplicationELB_TargetResponseTime_Average")
-			So(queryRes.Series[0].Tags["LoadBalancer"], ShouldEqual, "lb")
-			So(queryRes.Series[0].Tags["TargetGroup"], ShouldEqual, "tg")
-			So(queryRes.Series[0].Points[0][0].String(), ShouldEqual, null.FloatFrom(10.0).String())
-			So(queryRes.Series[0].Points[1][0].String(), ShouldEqual, null.FloatFrom(20.0).String())
-			So(queryRes.Series[0].Points[2][0].String(), ShouldEqual, null.FloatFromPtr(nil).String())
-			So(queryRes.Series[0].Points[3][0].String(), ShouldEqual, null.FloatFrom(30.0).String())
-		})
-	})
-}

pkg/tsdb/cloudwatch/get_metric_statistics.go

@@ -1,276 +0,0 @@
-package cloudwatch
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"regexp"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/cloudwatch"
-	"github.com/grafana/grafana/pkg/components/null"
-	"github.com/grafana/grafana/pkg/components/simplejson"
-	"github.com/grafana/grafana/pkg/infra/metrics"
-	"github.com/grafana/grafana/pkg/setting"
-	"github.com/grafana/grafana/pkg/tsdb"
-)
-
-func (e *CloudWatchExecutor) executeQuery(ctx context.Context, query *CloudWatchQuery, queryContext *tsdb.TsdbQuery) (*tsdb.QueryResult, error) {
-	client, err := e.getClient(query.Region)
-	if err != nil {
-		return nil, err
-	}
-
-	startTime, err := queryContext.TimeRange.ParseFrom()
-	if err != nil {
-		return nil, err
-	}
-
-	endTime, err := queryContext.TimeRange.ParseTo()
-	if err != nil {
-		return nil, err
-	}
-
-	if !startTime.Before(endTime) {
-		return nil, fmt.Errorf("Invalid time range: Start time must be before end time")
-	}
-
-	params := &cloudwatch.GetMetricStatisticsInput{
-		Namespace:  aws.String(query.Namespace),
-		MetricName: aws.String(query.MetricName),
-		Dimensions: query.Dimensions,
-		Period:     aws.Int64(int64(query.Period)),
-	}
-	if len(query.Statistics) > 0 {
-		params.Statistics = query.Statistics
-	}
-	if len(query.ExtendedStatistics) > 0 {
-		params.ExtendedStatistics = query.ExtendedStatistics
-	}
-
-	// 1 minutes resolution metrics is stored for 15 days, 15 * 24 * 60 = 21600
-	if query.HighResolution && (((endTime.Unix() - startTime.Unix()) / int64(query.Period)) > 21600) {
-		return nil, errors.New("too long query period")
-	}
-	var resp *cloudwatch.GetMetricStatisticsOutput
-	for startTime.Before(endTime) {
-		params.StartTime = aws.Time(startTime)
-		if query.HighResolution {
-			startTime = startTime.Add(time.Duration(1440*query.Period) * time.Second)
-		} else {
-			startTime = endTime
-		}
-		params.EndTime = aws.Time(startTime)
-
-		if setting.Env == setting.DEV {
-			plog.Debug("CloudWatch query", "raw query", params)
-		}
-
-		partResp, err := client.GetMetricStatisticsWithContext(ctx, params, request.WithResponseReadTimeout(10*time.Second))
-		if err != nil {
-			return nil, err
-		}
-		if resp != nil {
-			resp.Datapoints = append(resp.Datapoints, partResp.Datapoints...)
-		} else {
-			resp = partResp
-
-		}
-		metrics.MAwsCloudWatchGetMetricStatistics.Inc()
-	}
-
-	queryRes, err := parseResponse(resp, query)
-	if err != nil {
-		return nil, err
-	}
-
-	return queryRes, nil
-}
-
-func parseQuery(model *simplejson.Json) (*CloudWatchQuery, error) {
-	region, err := model.Get("region").String()
-	if err != nil {
-		return nil, err
-	}
-
-	namespace, err := model.Get("namespace").String()
-	if err != nil {
-		return nil, err
-	}
-
-	metricName, err := model.Get("metricName").String()
-	if err != nil {
-		return nil, err
-	}
-
-	id := model.Get("id").MustString("")
-	expression := model.Get("expression").MustString("")
-
-	dimensions, err := parseDimensions(model)
-	if err != nil {
-		return nil, err
-	}
-
-	statistics, extendedStatistics, err := parseStatistics(model)
-	if err != nil {
-		return nil, err
-	}
-
-	p := model.Get("period").MustString("")
-	if p == "" {
-		if namespace == "AWS/EC2" {
-			p = "300"
-		} else {
-			p = "60"
-		}
-	}
-
-	var period int
-	if regexp.MustCompile(`^\d+$`).Match([]byte(p)) {
-		period, err = strconv.Atoi(p)
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		d, err := time.ParseDuration(p)
-		if err != nil {
-			return nil, err
-		}
-		period = int(d.Seconds())
-	}
-
-	alias := model.Get("alias").MustString()
-
-	returnData := !model.Get("hide").MustBool(false)
-	queryType := model.Get("type").MustString()
-	if queryType == "" {
-		// If no type is provided we assume we are called by alerting service, which requires to return data!
-		// Note, this is sort of a hack, but the official Grafana interfaces do not carry the information
-		// who (which service) called the TsdbQueryEndpoint.Query(...) function.
-		returnData = true
-	}
-	highResolution := model.Get("highResolution").MustBool(false)
-
-	return &CloudWatchQuery{
-		Region:             region,
-		Namespace:          namespace,
-		MetricName:         metricName,
-		Dimensions:         dimensions,
-		Statistics:         aws.StringSlice(statistics),
-		ExtendedStatistics: aws.StringSlice(extendedStatistics),
-		Period:             period,
-		Alias:              alias,
-		Id:                 id,
-		Expression:         expression,
-		ReturnData:         returnData,
-		HighResolution:     highResolution,
-	}, nil
-}
-
-func parseDimensions(model *simplejson.Json) ([]*cloudwatch.Dimension, error) {
-	var result []*cloudwatch.Dimension
-
-	for k, v := range model.Get("dimensions").MustMap() {
-		kk := k
-		if vv, ok := v.(string); ok {
-			result = append(result, &cloudwatch.Dimension{
-				Name:  &kk,
-				Value: &vv,
-			})
-		} else {
-			return nil, errors.New("failed to parse")
-		}
-	}
-
-	sort.Slice(result, func(i, j int) bool {
-		return *result[i].Name < *result[j].Name
-	})
-	return result, nil
-}
-
-func parseStatistics(model *simplejson.Json) ([]string, []string, error) {
-	var statistics []string
-	var extendedStatistics []string
-
-	for _, s := range model.Get("statistics").MustArray() {
-		if ss, ok := s.(string); ok {
-			if _, isStandard := standardStatistics[ss]; isStandard {
-				statistics = append(statistics, ss)
-			} else {
-				extendedStatistics = append(extendedStatistics, ss)
-			}
-		} else {
-			return nil, nil, errors.New("failed to parse")
-		}
-	}
-
-	return statistics, extendedStatistics, nil
-}
-
-func parseResponse(resp *cloudwatch.GetMetricStatisticsOutput, query *CloudWatchQuery) (*tsdb.QueryResult, error) {
-	queryRes := tsdb.NewQueryResult()
-
-	queryRes.RefId = query.RefId
-	var value float64
-	for _, s := range append(query.Statistics, query.ExtendedStatistics...) {
-		series := tsdb.TimeSeries{
-			Tags:   map[string]string{},
-			Points: make([]tsdb.TimePoint, 0),
-		}
-		for _, d := range query.Dimensions {
-			series.Tags[*d.Name] = *d.Value
-		}
-		series.Name = formatAlias(query, *s, series.Tags, "")
-
-		lastTimestamp := make(map[string]time.Time)
-		sort.Slice(resp.Datapoints, func(i, j int) bool {
-			return (*resp.Datapoints[i].Timestamp).Before(*resp.Datapoints[j].Timestamp)
-		})
-		for _, v := range resp.Datapoints {
-			switch *s {
-			case "Average":
-				value = *v.Average
-			case "Maximum":
-				value = *v.Maximum
-			case "Minimum":
-				value = *v.Minimum
-			case "Sum":
-				value = *v.Sum
-			case "SampleCount":
-				value = *v.SampleCount
-			default:
-				if strings.Index(*s, "p") == 0 && v.ExtendedStatistics[*s] != nil {
-					value = *v.ExtendedStatistics[*s]
-				}
-			}
-
-			// terminate gap of data points
-			timestamp := *v.Timestamp
-			if _, ok := lastTimestamp[*s]; ok {
-				nextTimestampFromLast := lastTimestamp[*s].Add(time.Duration(query.Period) * time.Second)
-				for timestamp.After(nextTimestampFromLast) {
-					series.Points = append(series.Points, tsdb.NewTimePoint(null.FloatFromPtr(nil), float64(nextTimestampFromLast.Unix()*1000)))
-					nextTimestampFromLast = nextTimestampFromLast.Add(time.Duration(query.Period) * time.Second)
-				}
-			}
-			lastTimestamp[*s] = timestamp
-
-			series.Points = append(series.Points, tsdb.NewTimePoint(null.FloatFrom(value), float64(timestamp.Unix()*1000)))
-		}
-
-		queryRes.Series = append(queryRes.Series, &series)
-		queryRes.Meta = simplejson.New()
-		if len(resp.Datapoints) > 0 && resp.Datapoints[0].Unit != nil {
-			if unit, ok := cloudwatchUnitMappings[*resp.Datapoints[0].Unit]; ok {
-				queryRes.Meta.Set("unit", unit)
-			}
-		}
-	}
-
-	return queryRes, nil
-}

pkg/tsdb/cloudwatch/get_metric_statistics_test.go

@@ -1,187 +0,0 @@
-package cloudwatch
-
-import (
-	"testing"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/cloudwatch"
-	"github.com/grafana/grafana/pkg/components/null"
-	"github.com/grafana/grafana/pkg/components/simplejson"
-	. "github.com/smartystreets/goconvey/convey"
-)
-
-func TestCloudWatchGetMetricStatistics(t *testing.T) {
-	Convey("CloudWatchGetMetricStatistics", t, func() {
-
-		Convey("can parse cloudwatch json model", func() {
-			json := `
-				{
-					"region": "us-east-1",
-					"namespace": "AWS/ApplicationELB",
-					"metricName": "TargetResponseTime",
-					"dimensions": {
-						"LoadBalancer": "lb",
-						"TargetGroup": "tg"
-					},
-					"statistics": [
-						"Average",
-						"Maximum",
-						"p50.00",
-						"p90.00"
-					],
-					"period": "60",
-					"highResolution": false,
-					"alias": "{{metric}}_{{stat}}"
-				}
-			`
-			modelJson, err := simplejson.NewJson([]byte(json))
-			So(err, ShouldBeNil)
-
-			res, err := parseQuery(modelJson)
-			So(err, ShouldBeNil)
-			So(res.Region, ShouldEqual, "us-east-1")
-			So(res.Namespace, ShouldEqual, "AWS/ApplicationELB")
-			So(res.MetricName, ShouldEqual, "TargetResponseTime")
-			So(len(res.Dimensions), ShouldEqual, 2)
-			So(*res.Dimensions[0].Name, ShouldEqual, "LoadBalancer")
-			So(*res.Dimensions[0].Value, ShouldEqual, "lb")
-			So(*res.Dimensions[1].Name, ShouldEqual, "TargetGroup")
-			So(*res.Dimensions[1].Value, ShouldEqual, "tg")
-			So(len(res.Statistics), ShouldEqual, 2)
-			So(*res.Statistics[0], ShouldEqual, "Average")
-			So(*res.Statistics[1], ShouldEqual, "Maximum")
-			So(len(res.ExtendedStatistics), ShouldEqual, 2)
-			So(*res.ExtendedStatistics[0], ShouldEqual, "p50.00")
-			So(*res.ExtendedStatistics[1], ShouldEqual, "p90.00")
-			So(res.Period, ShouldEqual, 60)
-			So(res.Alias, ShouldEqual, "{{metric}}_{{stat}}")
-		})
-
-		Convey("can parse cloudwatch response", func() {
-			timestamp := time.Unix(0, 0)
-			resp := &cloudwatch.GetMetricStatisticsOutput{
-				Label: aws.String("TargetResponseTime"),
-				Datapoints: []*cloudwatch.Datapoint{
-					{
-						Timestamp: aws.Time(timestamp),
-						Average:   aws.Float64(10.0),
-						Maximum:   aws.Float64(20.0),
-						ExtendedStatistics: map[string]*float64{
-							"p50.00": aws.Float64(30.0),
-							"p90.00": aws.Float64(40.0),
-						},
-						Unit: aws.String("Seconds"),
-					},
-				},
-			}
-			query := &CloudWatchQuery{
-				Region:     "us-east-1",
-				Namespace:  "AWS/ApplicationELB",
-				MetricName: "TargetResponseTime",
-				Dimensions: []*cloudwatch.Dimension{
-					{
-						Name:  aws.String("LoadBalancer"),
-						Value: aws.String("lb"),
-					},
-					{
-						Name:  aws.String("TargetGroup"),
-						Value: aws.String("tg"),
-					},
-				},
-				Statistics:         []*string{aws.String("Average"), aws.String("Maximum")},
-				ExtendedStatistics: []*string{aws.String("p50.00"), aws.String("p90.00")},
-				Period:             60,
-				Alias:              "{{namespace}}_{{metric}}_{{stat}}",
-			}
-
-			queryRes, err := parseResponse(resp, query)
-			So(err, ShouldBeNil)
-			So(queryRes.Series[0].Name, ShouldEqual, "AWS/ApplicationELB_TargetResponseTime_Average")
-			So(queryRes.Series[0].Tags["LoadBalancer"], ShouldEqual, "lb")
-			So(queryRes.Series[0].Tags["TargetGroup"], ShouldEqual, "tg")
-			So(queryRes.Series[0].Points[0][0].String(), ShouldEqual, null.FloatFrom(10.0).String())
-			So(queryRes.Series[1].Points[0][0].String(), ShouldEqual, null.FloatFrom(20.0).String())
-			So(queryRes.Series[2].Points[0][0].String(), ShouldEqual, null.FloatFrom(30.0).String())
-			So(queryRes.Series[3].Points[0][0].String(), ShouldEqual, null.FloatFrom(40.0).String())
-			So(queryRes.Meta.Get("unit").MustString(), ShouldEqual, "s")
-		})
-
-		Convey("terminate gap of data points", func() {
-			timestamp := time.Unix(0, 0)
-			resp := &cloudwatch.GetMetricStatisticsOutput{
-				Label: aws.String("TargetResponseTime"),
-				Datapoints: []*cloudwatch.Datapoint{
-					{
-						Timestamp: aws.Time(timestamp),
-						Average:   aws.Float64(10.0),
-						Maximum:   aws.Float64(20.0),
-						ExtendedStatistics: map[string]*float64{
-							"p50.00": aws.Float64(30.0),
-							"p90.00": aws.Float64(40.0),
-						},
-						Unit: aws.String("Seconds"),
-					},
-					{
-						Timestamp: aws.Time(timestamp.Add(60 * time.Second)),
-						Average:   aws.Float64(20.0),
-						Maximum:   aws.Float64(30.0),
-						ExtendedStatistics: map[string]*float64{
-							"p50.00": aws.Float64(40.0),
-							"p90.00": aws.Float64(50.0),
-						},
-						Unit: aws.String("Seconds"),
-					},
-					{
-						Timestamp: aws.Time(timestamp.Add(180 * time.Second)),
-						Average:   aws.Float64(30.0),
-						Maximum:   aws.Float64(40.0),
-						ExtendedStatistics: map[string]*float64{
-							"p50.00": aws.Float64(50.0),
-							"p90.00": aws.Float64(60.0),
-						},
-						Unit: aws.String("Seconds"),
-					},
-				},
-			}
-			query := &CloudWatchQuery{
-				Region:     "us-east-1",
-				Namespace:  "AWS/ApplicationELB",
-				MetricName: "TargetResponseTime",
-				Dimensions: []*cloudwatch.Dimension{
-					{
-						Name:  aws.String("LoadBalancer"),
-						Value: aws.String("lb"),
-					},
-					{
-						Name:  aws.String("TargetGroup"),
-						Value: aws.String("tg"),
-					},
-				},
-				Statistics:         []*string{aws.String("Average"), aws.String("Maximum")},
-				ExtendedStatistics: []*string{aws.String("p50.00"), aws.String("p90.00")},
-				Period:             60,
-				Alias:              "{{namespace}}_{{metric}}_{{stat}}",
-			}
-
-			queryRes, err := parseResponse(resp, query)
-			So(err, ShouldBeNil)
-			So(queryRes.Series[0].Points[0][0].String(), ShouldEqual, null.FloatFrom(10.0).String())
-			So(queryRes.Series[1].Points[0][0].String(), ShouldEqual, null.FloatFrom(20.0).String())
-			So(queryRes.Series[2].Points[0][0].String(), ShouldEqual, null.FloatFrom(30.0).String())
-			So(queryRes.Series[3].Points[0][0].String(), ShouldEqual, null.FloatFrom(40.0).String())
-			So(queryRes.Series[0].Points[1][0].String(), ShouldEqual, null.FloatFrom(20.0).String())
-			So(queryRes.Series[1].Points[1][0].String(), ShouldEqual, null.FloatFrom(30.0).String())
-			So(queryRes.Series[2].Points[1][0].String(), ShouldEqual, null.FloatFrom(40.0).String())
-			So(queryRes.Series[3].Points[1][0].String(), ShouldEqual, null.FloatFrom(50.0).String())
-			So(queryRes.Series[0].Points[2][0].String(), ShouldEqual, null.FloatFromPtr(nil).String())
-			So(queryRes.Series[1].Points[2][0].String(), ShouldEqual, null.FloatFromPtr(nil).String())
-			So(queryRes.Series[2].Points[2][0].String(), ShouldEqual, null.FloatFromPtr(nil).String())
-			So(queryRes.Series[3].Points[2][0].String(), ShouldEqual, null.FloatFromPtr(nil).String())
-			So(queryRes.Series[0].Points[3][0].String(), ShouldEqual, null.FloatFrom(30.0).String())
-			So(queryRes.Series[1].Points[3][0].String(), ShouldEqual, null.FloatFrom(40.0).String())
-			So(queryRes.Series[2].Points[3][0].String(), ShouldEqual, null.FloatFrom(50.0).String())
-			So(queryRes.Series[3].Points[3][0].String(), ShouldEqual, null.FloatFrom(60.0).String())
-		})
-	})
-}

pkg/tsdb/cloudwatch/metric_data_input_builder.go

@@ -0,0 +1,46 @@
+package cloudwatch
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/cloudwatch"
+	"github.com/grafana/grafana/pkg/tsdb"
+)
+
+func (e *CloudWatchExecutor) buildMetricDataInput(queryContext *tsdb.TsdbQuery, queries map[string]*cloudWatchQuery) (*cloudwatch.GetMetricDataInput, error) {
+	startTime, err := queryContext.TimeRange.ParseFrom()
+	if err != nil {
+		return nil, err
+	}
+
+	endTime, err := queryContext.TimeRange.ParseTo()
+	if err != nil {
+		return nil, err
+	}
+
+	if !startTime.Before(endTime) {
+		return nil, fmt.Errorf("Invalid time range: Start time must be before end time")
+	}
+
+	metricDataInput := &cloudwatch.GetMetricDataInput{
+		StartTime: aws.Time(startTime),
+		EndTime:   aws.Time(endTime),
+		ScanBy:    aws.String("TimestampAscending"),
+	}
+	for _, query := range queries {
+		// 1 minutes resolution metrics is stored for 15 days, 15 * 24 * 60 = 21600
+		if query.HighResolution && (((endTime.Unix() - startTime.Unix()) / int64(query.Period)) > 21600) {
+			return nil, &queryError{errors.New("too long query period"), query.RefId}
+		}
+
+		metricDataQuery, err := e.buildMetricDataQuery(query)
+		if err != nil {
+			return nil, &queryError{err, query.RefId}
+		}
+		metricDataInput.MetricDataQueries = append(metricDataInput.MetricDataQueries, metricDataQuery)
+	}
+
+	return metricDataInput, nil
+}

pkg/tsdb/cloudwatch/metric_data_input_builder_test.go

@@ -0,0 +1,28 @@
+package cloudwatch
+
+import (
+	"testing"
+
+	"github.com/grafana/grafana/pkg/tsdb"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestMetricDataInputBuilder(t *testing.T) {
+	Convey("TestMetricDataInputBuilder", t, func() {
+		executor := &CloudWatchExecutor{}
+		query := make(map[string]*cloudWatchQuery)
+
+		Convey("Time range is valid", func() {
+			Convey("End time before start time should result in error", func() {
+				_, err := executor.buildMetricDataInput(&tsdb.TsdbQuery{TimeRange: tsdb.NewTimeRange("now-1h", "now-2h")}, query)
+				So(err.Error(), ShouldEqual, "Invalid time range: Start time must be before end time")
+			})
+
+			Convey("End time equals start time should result in error", func() {
+				_, err := executor.buildMetricDataInput(&tsdb.TsdbQuery{TimeRange: tsdb.NewTimeRange("now-1h", "now-1h")}, query)
+				So(err.Error(), ShouldEqual, "Invalid time range: Start time must be before end time")
+			})
+		})
+	})
+}

pkg/tsdb/cloudwatch/metric_data_query_builder.go

@@ -0,0 +1,139 @@
+package cloudwatch
+
+import (
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/cloudwatch"
+)
+
+func (e *CloudWatchExecutor) buildMetricDataQuery(query *cloudWatchQuery) (*cloudwatch.MetricDataQuery, error) {
+	mdq := &cloudwatch.MetricDataQuery{
+		Id:         aws.String(query.Id),
+		ReturnData: aws.Bool(query.ReturnData),
+	}
+
+	if query.Expression != "" {
+		mdq.Expression = aws.String(query.Expression)
+	} else {
+		if query.isSearchExpression() {
+			mdq.Expression = aws.String(buildSearchExpression(query, query.Stats))
+		} else {
+			mdq.MetricStat = &cloudwatch.MetricStat{
+				Metric: &cloudwatch.Metric{
+					Namespace:  aws.String(query.Namespace),
+					MetricName: aws.String(query.MetricName),
+					Dimensions: make([]*cloudwatch.Dimension, 0),
+				},
+				Period: aws.Int64(int64(query.Period)),
+			}
+			for key, values := range query.Dimensions {
+				mdq.MetricStat.Metric.Dimensions = append(mdq.MetricStat.Metric.Dimensions,
+					&cloudwatch.Dimension{
+						Name:  aws.String(key),
+						Value: aws.String(values[0]),
+					})
+			}
+			mdq.MetricStat.Stat = aws.String(query.Stats)
+		}
+	}
+
+	if mdq.Expression != nil {
+		query.UsedExpression = *mdq.Expression
+	} else {
+		query.UsedExpression = ""
+	}
+
+	return mdq, nil
+}
+
+func buildSearchExpression(query *cloudWatchQuery, stat string) string {
+	knownDimensions := make(map[string][]string)
+	dimensionNames := []string{}
+	dimensionNamesWithoutKnownValues := []string{}
+
+	for key, values := range query.Dimensions {
+		dimensionNames = append(dimensionNames, key)
+		hasWildcard := false
+		for _, value := range values {
+			if value == "*" {
+				hasWildcard = true
+				break
+			}
+		}
+		if hasWildcard {
+			dimensionNamesWithoutKnownValues = append(dimensionNamesWithoutKnownValues, key)
+		} else {
+			knownDimensions[key] = values
+		}
+	}
+
+	searchTerm := fmt.Sprintf(`MetricName="%s"`, query.MetricName)
+	keys := []string{}
+	for k := range knownDimensions {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	for _, key := range keys {
+		values := escape(knownDimensions[key])
+		valueExpression := join(values, " OR ", `"`, `"`)
+		if len(knownDimensions[key]) > 1 {
+			valueExpression = fmt.Sprintf(`(%s)`, valueExpression)
+		}
+		keyFilter := fmt.Sprintf(`"%s"=%s`, key, valueExpression)
+		searchTerm = appendSearch(searchTerm, keyFilter)
+	}
+
+	if query.MatchExact {
+		schema := query.Namespace
+		if len(dimensionNames) > 0 {
+			sort.Strings(dimensionNames)
+			schema += fmt.Sprintf(",%s", join(dimensionNames, ",", "", ""))
+		}
+
+		return fmt.Sprintf("REMOVE_EMPTY(SEARCH('{%s} %s', '%s', %s))", schema, searchTerm, stat, strconv.Itoa(query.Period))
+	}
+
+	sort.Strings(dimensionNamesWithoutKnownValues)
+	searchTerm = appendSearch(searchTerm, join(dimensionNamesWithoutKnownValues, " ", `"`, `"`))
+	return fmt.Sprintf(`REMOVE_EMPTY(SEARCH('Namespace="%s" %s', '%s', %s))`, query.Namespace, searchTerm, stat, strconv.Itoa(query.Period))
+}
+
+func escape(arr []string) []string {
+	result := []string{}
+	for _, value := range arr {
+		value = strings.ReplaceAll(value, `\`, `\\`)
+		value = strings.ReplaceAll(value, ")", `\)`)
+		value = strings.ReplaceAll(value, "(", `\(`)
+		value = strings.ReplaceAll(value, `"`, `\"`)
+		result = append(result, value)
+	}
+
+	return result
+}
+
+func join(arr []string, delimiter string, valuePrefix string, valueSuffix string) string {
+	result := ""
+	for index, value := range arr {
+		result += valuePrefix + value + valueSuffix
+		if index+1 != len(arr) {
+			result += delimiter
+		}
+	}
+
+	return result
+}
+
+func appendSearch(target string, value string) string {
+	if value != "" {
+		if target == "" {
+			return value
+		}
+		return fmt.Sprintf("%v %v", target, value)
+	}
+
+	return target
+}

pkg/tsdb/cloudwatch/metric_data_query_builder_test.go

@@ -0,0 +1,215 @@
+package cloudwatch
+
+import (
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestMetricDataQueryBuilder(t *testing.T) {
+	Convey("TestMetricDataQueryBuilder", t, func() {
+		Convey("buildSearchExpression", func() {
+			Convey("and query should be matched exact", func() {
+				matchExact := true
+				Convey("and query has three dimension values for a given dimension key", func() {
+					query := &cloudWatchQuery{
+						Namespace:  "AWS/EC2",
+						MetricName: "CPUUtilization",
+						Dimensions: map[string][]string{
+							"LoadBalancer": {"lb1", "lb2", "lb3"},
+						},
+						Period:     300,
+						Identifier: "id1",
+						Expression: "",
+						MatchExact: matchExact,
+					}
+
+					res := buildSearchExpression(query, "Average")
+					So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('{AWS/EC2,LoadBalancer} MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`)
+				})
+
+				Convey("and query has three dimension values for two given dimension keys", func() {
+
+					query := &cloudWatchQuery{
+						Namespace:  "AWS/EC2",
+						MetricName: "CPUUtilization",
+						Dimensions: map[string][]string{
+							"LoadBalancer": {"lb1", "lb2", "lb3"},
+							"InstanceId":   {"i-123", "i-456", "i-789"},
+						},
+						Period:     300,
+						Identifier: "id1",
+						Expression: "",
+						MatchExact: matchExact,
+					}
+
+					res := buildSearchExpression(query, "Average")
+					So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('{AWS/EC2,InstanceId,LoadBalancer} MetricName="CPUUtilization" "InstanceId"=("i-123" OR "i-456" OR "i-789") "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`)
+				})
+
+				Convey("and no OR operator was added if a star was used for dimension value", func() {
+					query := &cloudWatchQuery{
+						Namespace:  "AWS/EC2",
+						MetricName: "CPUUtilization",
+						Dimensions: map[string][]string{
+							"LoadBalancer": {"*"},
+						},
+						Period:     300,
+						Identifier: "id1",
+						Expression: "",
+						MatchExact: matchExact,
+					}
+
+					res := buildSearchExpression(query, "Average")
+					So(res, ShouldNotContainSubstring, "OR")
+				})
+
+				Convey("and query has one dimension key with a * value", func() {
+					query := &cloudWatchQuery{
+						Namespace:  "AWS/EC2",
+						MetricName: "CPUUtilization",
+						Dimensions: map[string][]string{
+							"LoadBalancer": {"*"},
+						},
+						Period:     300,
+						Identifier: "id1",
+						Expression: "",
+						MatchExact: matchExact,
+					}
+
+					res := buildSearchExpression(query, "Average")
+					So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('{AWS/EC2,LoadBalancer} MetricName="CPUUtilization"', 'Average', 300))`)
+				})
+
+				Convey("and query has three dimension values for two given dimension keys, and one value is a star", func() {
+					query := &cloudWatchQuery{
+						Namespace:  "AWS/EC2",
+						MetricName: "CPUUtilization",
+						Dimensions: map[string][]string{
+							"LoadBalancer": {"lb1", "lb2", "lb3"},
+							"InstanceId":   {"i-123", "*", "i-789"},
+						},
+						Period:     300,
+						Identifier: "id1",
+						Expression: "",
+						MatchExact: matchExact,
+					}
+
+					res := buildSearchExpression(query, "Average")
+					So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('{AWS/EC2,InstanceId,LoadBalancer} MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`)
+				})
+			})
+
+			Convey("and query should not be matched exact", func() {
+				matchExact := false
+				Convey("and query has three dimension values for a given dimension key", func() {
+					query := &cloudWatchQuery{
+						Namespace:  "AWS/EC2",
+						MetricName: "CPUUtilization",
+						Dimensions: map[string][]string{
+							"LoadBalancer": {"lb1", "lb2", "lb3"},
+						},
+						Period:     300,
+						Identifier: "id1",
+						Expression: "",
+						MatchExact: matchExact,
+					}
+
+					res := buildSearchExpression(query, "Average")
+					So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`)
+				})
+
+				Convey("and query has three dimension values for two given dimension keys", func() {
+					query := &cloudWatchQuery{
+						Namespace:  "AWS/EC2",
+						MetricName: "CPUUtilization",
+						Dimensions: map[string][]string{
+							"LoadBalancer": {"lb1", "lb2", "lb3"},
+							"InstanceId":   {"i-123", "i-456", "i-789"},
+						},
+						Period:     300,
+						Identifier: "id1",
+						Expression: "",
+						MatchExact: matchExact,
+					}
+
+					res := buildSearchExpression(query, "Average")
+					So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "InstanceId"=("i-123" OR "i-456" OR "i-789") "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`)
+				})
+
+				Convey("and query has one dimension key with a * value", func() {
+					query := &cloudWatchQuery{
+						Namespace:  "AWS/EC2",
+						MetricName: "CPUUtilization",
+						Dimensions: map[string][]string{
+							"LoadBalancer": {"*"},
+						},
+						Period:     300,
+						Identifier: "id1",
+						Expression: "",
+						MatchExact: matchExact,
+					}
+
+					res := buildSearchExpression(query, "Average")
+					So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"', 'Average', 300))`)
+				})
+
+				Convey("and query has three dimension values for two given dimension keys, and one value is a star", func() {
+					query := &cloudWatchQuery{
+						Namespace:  "AWS/EC2",
+						MetricName: "CPUUtilization",
+						Dimensions: map[string][]string{
+							"LoadBalancer": {"lb1", "lb2", "lb3"},
+							"InstanceId":   {"i-123", "*", "i-789"},
+						},
+						Period:     300,
+						Identifier: "id1",
+						Expression: "",
+						MatchExact: matchExact,
+					}
+
+					res := buildSearchExpression(query, "Average")
+					So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3") "InstanceId"', 'Average', 300))`)
+				})
+
+			})
+		})
+
+		Convey("and query has has invalid characters in dimension values", func() {
+			query := &cloudWatchQuery{
+				Namespace:  "AWS/EC2",
+				MetricName: "CPUUtilization",
+				Dimensions: map[string][]string{
+					"lb1": {`lb\1\`},
+					"lb2": {`)lb2`},
+					"lb3": {`l(b3`},
+					"lb4": {`lb4""`},
+					"lb5": {`l\(b5"`},
+					"lb6": {`l\\(b5"`},
+				},
+				Period:     300,
+				Identifier: "id1",
+				Expression: "",
+				MatchExact: true,
+			}
+			res := buildSearchExpression(query, "Average")
+
+			Convey("it should escape backslash", func() {
+				So(res, ShouldContainSubstring, `"lb1"="lb\\1\\"`)
+			})
+
+			Convey("it should escape closing parenthesis", func() {
+				So(res, ShouldContainSubstring, `"lb2"="\)lb2"`)
+			})
+
+			Convey("it should escape open parenthesis", func() {
+				So(res, ShouldContainSubstring, `"lb3"="l\(b3"`)
+			})
+
+			Convey("it should escape double quotes", func() {
+				So(res, ShouldContainSubstring, `"lb6"="l\\\\\(b5\""`)
+			})
+
+		})
+	})
+}

pkg/tsdb/cloudwatch/metric_find_query.go

@@ -637,10 +637,13 @@ func (e *CloudWatchExecutor) cloudwatchListMetrics(region string, namespace stri
 
 	params := &cloudwatch.ListMetricsInput{
 		Namespace:  aws.String(namespace),
-		MetricName: aws.String(metricName),
 		Dimensions: dimensions,
 	}
 
+	if metricName != "" {
+		params.MetricName = aws.String(metricName)
+	}
+
 	var resp cloudwatch.ListMetricsOutput
 	err = svc.ListMetricsPages(params,
 		func(page *cloudwatch.ListMetricsOutput, lastPage bool) bool {

pkg/tsdb/cloudwatch/query_transformer.go

@@ -0,0 +1,103 @@
+package cloudwatch
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+
+	"github.com/grafana/grafana/pkg/components/simplejson"
+	"github.com/grafana/grafana/pkg/tsdb"
+)
+
+// returns a map of queries with query id as key. In the case a q request query
+// has more than one statistic defined, one cloudwatchQuery will be created for each statistic.
+// If the query doesn't have an Id defined by the user, we'll give it an with format `query[RefId]`. In the case
+// the incoming query had more than one stat, it will ge an id like `query[RefId]_[StatName]`, eg queryC_Average
+func (e *CloudWatchExecutor) transformRequestQueriesToCloudWatchQueries(requestQueries []*requestQuery) (map[string]*cloudWatchQuery, error) {
+	cloudwatchQueries := make(map[string]*cloudWatchQuery)
+	for _, requestQuery := range requestQueries {
+		for _, stat := range requestQuery.Statistics {
+			id := requestQuery.Id
+			if id == "" {
+				id = fmt.Sprintf("query%s", requestQuery.RefId)
+			}
+			if len(requestQuery.Statistics) > 1 {
+				id = fmt.Sprintf("%s_%v", id, strings.ReplaceAll(*stat, ".", "_"))
+			}
+
+			query := &cloudWatchQuery{
+				Id:             id,
+				RefId:          requestQuery.RefId,
+				Region:         requestQuery.Region,
+				Namespace:      requestQuery.Namespace,
+				MetricName:     requestQuery.MetricName,
+				Dimensions:     requestQuery.Dimensions,
+				Stats:          *stat,
+				Period:         requestQuery.Period,
+				Alias:          requestQuery.Alias,
+				Expression:     requestQuery.Expression,
+				ReturnData:     requestQuery.ReturnData,
+				HighResolution: requestQuery.HighResolution,
+				MatchExact:     requestQuery.MatchExact,
+			}
+
+			if _, ok := cloudwatchQueries[id]; ok {
+				return nil, fmt.Errorf("Error in query %s. Query id %s is not unique", query.RefId, query.Id)
+			}
+
+			cloudwatchQueries[id] = query
+		}
+	}
+
+	return cloudwatchQueries, nil
+}
+
+func (e *CloudWatchExecutor) transformQueryResponseToQueryResult(cloudwatchResponses []*cloudwatchResponse) map[string]*tsdb.QueryResult {
+	results := make(map[string]*tsdb.QueryResult)
+	responsesByRefID := make(map[string][]*cloudwatchResponse)
+
+	for _, res := range cloudwatchResponses {
+		if _, ok := responsesByRefID[res.RefId]; ok {
+			responsesByRefID[res.RefId] = append(responsesByRefID[res.RefId], res)
+		} else {
+			responsesByRefID[res.RefId] = []*cloudwatchResponse{res}
+		}
+	}
+
+	for refID, responses := range responsesByRefID {
+		queryResult := tsdb.NewQueryResult()
+		queryResult.RefId = refID
+		queryResult.Meta = simplejson.New()
+		queryResult.Series = tsdb.TimeSeriesSlice{}
+		timeSeries := make(tsdb.TimeSeriesSlice, 0)
+
+		requestExceededMaxLimit := false
+		queryMeta := []struct {
+			Expression, ID string
+		}{}
+
+		for _, response := range responses {
+			timeSeries = append(timeSeries, *response.series...)
+			requestExceededMaxLimit = requestExceededMaxLimit || response.RequestExceededMaxLimit
+			queryMeta = append(queryMeta, struct {
+				Expression, ID string
+			}{
+				Expression: response.Expression,
+				ID:         response.Id,
+			})
+		}
+
+		sort.Slice(timeSeries, func(i, j int) bool {
+			return timeSeries[i].Name < timeSeries[j].Name
+		})
+
+		if requestExceededMaxLimit {
+			queryResult.ErrorString = "Cloudwatch GetMetricData error: Maximum number of allowed metrics exceeded. Your search may have been limited."
+		}
+		queryResult.Series = append(queryResult.Series, timeSeries...)
+		queryResult.Meta.Set("gmdMeta", queryMeta)
+		results[refID] = queryResult
+	}
+
+	return results
+}

pkg/tsdb/cloudwatch/query_transformer_test.go

@@ -0,0 +1,167 @@
+package cloudwatch
+
+import (
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestQueryTransformer(t *testing.T) {
+	Convey("TestQueryTransformer", t, func() {
+		Convey("when transforming queries", func() {
+
+			executor := &CloudWatchExecutor{}
+			Convey("one cloudwatchQuery is generated when its request query has one stat", func() {
+				requestQueries := []*requestQuery{
+					{
+						RefId:          "D",
+						Region:         "us-east-1",
+						Namespace:      "ec2",
+						MetricName:     "CPUUtilization",
+						Statistics:     aws.StringSlice([]string{"Average"}),
+						Period:         600,
+						Id:             "",
+						HighResolution: false,
+					},
+				}
+
+				res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
+				So(err, ShouldBeNil)
+				So(len(res), ShouldEqual, 1)
+			})
+
+			Convey("two cloudwatchQuery is generated when there's two stats", func() {
+				requestQueries := []*requestQuery{
+					{
+						RefId:          "D",
+						Region:         "us-east-1",
+						Namespace:      "ec2",
+						MetricName:     "CPUUtilization",
+						Statistics:     aws.StringSlice([]string{"Average", "Sum"}),
+						Period:         600,
+						Id:             "",
+						HighResolution: false,
+					},
+				}
+
+				res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
+				So(err, ShouldBeNil)
+				So(len(res), ShouldEqual, 2)
+			})
+			Convey("and id is given by user", func() {
+				Convey("that id will be used in the cloudwatch query", func() {
+					requestQueries := []*requestQuery{
+						{
+							RefId:          "D",
+							Region:         "us-east-1",
+							Namespace:      "ec2",
+							MetricName:     "CPUUtilization",
+							Statistics:     aws.StringSlice([]string{"Average"}),
+							Period:         600,
+							Id:             "myid",
+							HighResolution: false,
+						},
+					}
+
+					res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
+					So(err, ShouldBeNil)
+					So(len(res), ShouldEqual, 1)
+					So(res, ShouldContainKey, "myid")
+				})
+			})
+
+			Convey("and id is not given by user", func() {
+				Convey("id will be generated based on ref id if query only has one stat", func() {
+					requestQueries := []*requestQuery{
+						{
+							RefId:          "D",
+							Region:         "us-east-1",
+							Namespace:      "ec2",
+							MetricName:     "CPUUtilization",
+							Statistics:     aws.StringSlice([]string{"Average"}),
+							Period:         600,
+							Id:             "",
+							HighResolution: false,
+						},
+					}
+
+					res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
+					So(err, ShouldBeNil)
+					So(len(res), ShouldEqual, 1)
+					So(res, ShouldContainKey, "queryD")
+				})
+
+				Convey("id will be generated based on ref and stat name if query has two stats", func() {
+					requestQueries := []*requestQuery{
+						{
+							RefId:          "D",
+							Region:         "us-east-1",
+							Namespace:      "ec2",
+							MetricName:     "CPUUtilization",
+							Statistics:     aws.StringSlice([]string{"Average", "Sum"}),
+							Period:         600,
+							Id:             "",
+							HighResolution: false,
+						},
+					}
+
+					res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
+					So(err, ShouldBeNil)
+					So(len(res), ShouldEqual, 2)
+					So(res, ShouldContainKey, "queryD_Sum")
+					So(res, ShouldContainKey, "queryD_Average")
+				})
+			})
+
+			Convey("dot should be removed when query has more than one stat and one of them is a percentile", func() {
+				requestQueries := []*requestQuery{
+					{
+						RefId:          "D",
+						Region:         "us-east-1",
+						Namespace:      "ec2",
+						MetricName:     "CPUUtilization",
+						Statistics:     aws.StringSlice([]string{"Average", "p46.32"}),
+						Period:         600,
+						Id:             "",
+						HighResolution: false,
+					},
+				}
+
+				res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
+				So(err, ShouldBeNil)
+				So(len(res), ShouldEqual, 2)
+				So(res, ShouldContainKey, "queryD_p46_32")
+			})
+
+			Convey("should return an error if two queries have the same id", func() {
+				requestQueries := []*requestQuery{
+					{
+						RefId:          "D",
+						Region:         "us-east-1",
+						Namespace:      "ec2",
+						MetricName:     "CPUUtilization",
+						Statistics:     aws.StringSlice([]string{"Average", "p46.32"}),
+						Period:         600,
+						Id:             "myId",
+						HighResolution: false,
+					},
+					{
+						RefId:          "E",
+						Region:         "us-east-1",
+						Namespace:      "ec2",
+						MetricName:     "CPUUtilization",
+						Statistics:     aws.StringSlice([]string{"Average", "p46.32"}),
+						Period:         600,
+						Id:             "myId",
+						HighResolution: false,
+					},
+				}
+
+				res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
+				So(res, ShouldBeNil)
+				So(err, ShouldNotBeNil)
+			})
+		})
+	})
+}

pkg/tsdb/cloudwatch/request_parser.go

@@ -0,0 +1,162 @@
+package cloudwatch
+
+import (
+	"errors"
+	"regexp"
+	"sort"
+	"strconv"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/grafana/grafana/pkg/components/simplejson"
+	"github.com/grafana/grafana/pkg/tsdb"
+)
+
+// Parses the json queries and returns a requestQuery. The requstQuery has a 1 to 1 mapping to a query editor row
+func (e *CloudWatchExecutor) parseQueries(queryContext *tsdb.TsdbQuery) (map[string][]*requestQuery, error) {
+	requestQueries := make(map[string][]*requestQuery)
+
+	for i, model := range queryContext.Queries {
+		queryType := model.Model.Get("type").MustString()
+		if queryType != "timeSeriesQuery" && queryType != "" {
+			continue
+		}
+
+		RefID := queryContext.Queries[i].RefId
+		query, err := parseRequestQuery(queryContext.Queries[i].Model, RefID)
+		if err != nil {
+			return nil, &queryError{err, RefID}
+		}
+		if _, exist := requestQueries[query.Region]; !exist {
+			requestQueries[query.Region] = make([]*requestQuery, 0)
+		}
+		requestQueries[query.Region] = append(requestQueries[query.Region], query)
+	}
+
+	return requestQueries, nil
+}
+
+func parseRequestQuery(model *simplejson.Json, refId string) (*requestQuery, error) {
+	region, err := model.Get("region").String()
+	if err != nil {
+		return nil, err
+	}
+
+	namespace, err := model.Get("namespace").String()
+	if err != nil {
+		return nil, err
+	}
+
+	metricName, err := model.Get("metricName").String()
+	if err != nil {
+		return nil, err
+	}
+
+	dimensions, err := parseDimensions(model)
+	if err != nil {
+		return nil, err
+	}
+
+	statistics, err := parseStatistics(model)
+	if err != nil {
+		return nil, err
+	}
+
+	p := model.Get("period").MustString("")
+	if p == "" {
+		if namespace == "AWS/EC2" {
+			p = "300"
+		} else {
+			p = "60"
+		}
+	}
+
+	var period int
+	if regexp.MustCompile(`^\d+$`).Match([]byte(p)) {
+		period, err = strconv.Atoi(p)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		d, err := time.ParseDuration(p)
+		if err != nil {
+			return nil, err
+		}
+		period = int(d.Seconds())
+	}
+
+	id := model.Get("id").MustString("")
+	expression := model.Get("expression").MustString("")
+	alias := model.Get("alias").MustString()
+	returnData := !model.Get("hide").MustBool(false)
+	queryType := model.Get("type").MustString()
+	if queryType == "" {
+		// If no type is provided we assume we are called by alerting service, which requires to return data!
+		// Note, this is sort of a hack, but the official Grafana interfaces do not carry the information
+		// who (which service) called the TsdbQueryEndpoint.Query(...) function.
+		returnData = true
+	}
+
+	highResolution := model.Get("highResolution").MustBool(false)
+	matchExact := model.Get("matchExact").MustBool(true)
+
+	return &requestQuery{
+		RefId:          refId,
+		Region:         region,
+		Namespace:      namespace,
+		MetricName:     metricName,
+		Dimensions:     dimensions,
+		Statistics:     aws.StringSlice(statistics),
+		Period:         period,
+		Alias:          alias,
+		Id:             id,
+		Expression:     expression,
+		ReturnData:     returnData,
+		HighResolution: highResolution,
+		MatchExact:     matchExact,
+	}, nil
+}
+
+func parseStatistics(model *simplejson.Json) ([]string, error) {
+	var statistics []string
+
+	for _, s := range model.Get("statistics").MustArray() {
+		statistics = append(statistics, s.(string))
+	}
+
+	return statistics, nil
+}
+
+func parseDimensions(model *simplejson.Json) (map[string][]string, error) {
+	parsedDimensions := make(map[string][]string)
+	for k, v := range model.Get("dimensions").MustMap() {
+		// This is for backwards compatibility. Before 6.5 dimensions values were stored as strings and not arrays
+		if value, ok := v.(string); ok {
+			parsedDimensions[k] = []string{value}
+		} else if values, ok := v.([]interface{}); ok {
+			for _, value := range values {
+				parsedDimensions[k] = append(parsedDimensions[k], value.(string))
+			}
+		} else {
+			return nil, errors.New("failed to parse dimensions")
+		}
+	}
+
+	sortedDimensions := sortDimensions(parsedDimensions)
+
+	return sortedDimensions, nil
+}
+
+func sortDimensions(dimensions map[string][]string) map[string][]string {
+	sortedDimensions := make(map[string][]string)
+	var keys []string
+	for k := range dimensions {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+
+	for _, k := range keys {
+		sortedDimensions[k] = dimensions[k]
+	}
+	return sortedDimensions
+}

pkg/tsdb/cloudwatch/request_parser_test.go

@@ -0,0 +1,87 @@
+package cloudwatch
+
+import (
+	"testing"
+
+	"github.com/grafana/grafana/pkg/components/simplejson"
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestRequestParser(t *testing.T) {
+	Convey("TestRequestParser", t, func() {
+		Convey("when parsing query editor row json", func() {
+			Convey("using new dimensions structure", func() {
+				query := simplejson.NewFromAny(map[string]interface{}{
+					"refId":      "ref1",
+					"region":     "us-east-1",
+					"namespace":  "ec2",
+					"metricName": "CPUUtilization",
+					"id":         "",
+					"expression": "",
+					"dimensions": map[string]interface{}{
+						"InstanceId":   []interface{}{"test"},
+						"InstanceType": []interface{}{"test2", "test3"},
+					},
+					"statistics":     []interface{}{"Average"},
+					"period":         "600",
+					"hide":           false,
+					"highResolution": false,
+				})
+
+				res, err := parseRequestQuery(query, "ref1")
+				So(err, ShouldBeNil)
+				So(res.Region, ShouldEqual, "us-east-1")
+				So(res.RefId, ShouldEqual, "ref1")
+				So(res.Namespace, ShouldEqual, "ec2")
+				So(res.MetricName, ShouldEqual, "CPUUtilization")
+				So(res.Id, ShouldEqual, "")
+				So(res.Expression, ShouldEqual, "")
+				So(res.Period, ShouldEqual, 600)
+				So(res.ReturnData, ShouldEqual, true)
+				So(res.HighResolution, ShouldEqual, false)
+				So(len(res.Dimensions), ShouldEqual, 2)
+				So(len(res.Dimensions["InstanceId"]), ShouldEqual, 1)
+				So(len(res.Dimensions["InstanceType"]), ShouldEqual, 2)
+				So(res.Dimensions["InstanceType"][1], ShouldEqual, "test3")
+				So(len(res.Statistics), ShouldEqual, 1)
+				So(*res.Statistics[0], ShouldEqual, "Average")
+			})
+
+			Convey("using old dimensions structure (backwards compatibility)", func() {
+				query := simplejson.NewFromAny(map[string]interface{}{
+					"refId":      "ref1",
+					"region":     "us-east-1",
+					"namespace":  "ec2",
+					"metricName": "CPUUtilization",
+					"id":         "",
+					"expression": "",
+					"dimensions": map[string]interface{}{
+						"InstanceId":   "test",
+						"InstanceType": "test2",
+					},
+					"statistics":     []interface{}{"Average"},
+					"period":         "600",
+					"hide":           false,
+					"highResolution": false,
+				})
+
+				res, err := parseRequestQuery(query, "ref1")
+				So(err, ShouldBeNil)
+				So(res.Region, ShouldEqual, "us-east-1")
+				So(res.RefId, ShouldEqual, "ref1")
+				So(res.Namespace, ShouldEqual, "ec2")
+				So(res.MetricName, ShouldEqual, "CPUUtilization")
+				So(res.Id, ShouldEqual, "")
+				So(res.Expression, ShouldEqual, "")
+				So(res.Period, ShouldEqual, 600)
+				So(res.ReturnData, ShouldEqual, true)
+				So(res.HighResolution, ShouldEqual, false)
+				So(len(res.Dimensions), ShouldEqual, 2)
+				So(len(res.Dimensions["InstanceId"]), ShouldEqual, 1)
+				So(len(res.Dimensions["InstanceType"]), ShouldEqual, 1)
+				So(res.Dimensions["InstanceType"][0], ShouldEqual, "test2")
+				So(*res.Statistics[0], ShouldEqual, "Average")
+			})
+		})
+	})
+}

pkg/tsdb/cloudwatch/response_parser.go

@@ -0,0 +1,155 @@
+package cloudwatch
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/aws/aws-sdk-go/service/cloudwatch"
+	"github.com/grafana/grafana/pkg/components/null"
+	"github.com/grafana/grafana/pkg/tsdb"
+)
+
+func (e *CloudWatchExecutor) parseResponse(metricDataOutputs []*cloudwatch.GetMetricDataOutput, queries map[string]*cloudWatchQuery) ([]*cloudwatchResponse, error) {
+	mdr := make(map[string]map[string]*cloudwatch.MetricDataResult)
+
+	for _, mdo := range metricDataOutputs {
+		requestExceededMaxLimit := false
+		for _, message := range mdo.Messages {
+			if *message.Code == "MaxMetricsExceeded" {
+				requestExceededMaxLimit = true
+			}
+		}
+
+		for _, r := range mdo.MetricDataResults {
+			if _, exists := mdr[*r.Id]; !exists {
+				mdr[*r.Id] = make(map[string]*cloudwatch.MetricDataResult)
+				mdr[*r.Id][*r.Label] = r
+			} else if _, exists := mdr[*r.Id][*r.Label]; !exists {
+				mdr[*r.Id][*r.Label] = r
+			} else {
+				mdr[*r.Id][*r.Label].Timestamps = append(mdr[*r.Id][*r.Label].Timestamps, r.Timestamps...)
+				mdr[*r.Id][*r.Label].Values = append(mdr[*r.Id][*r.Label].Values, r.Values...)
+			}
+			queries[*r.Id].RequestExceededMaxLimit = requestExceededMaxLimit
+		}
+	}
+
+	cloudWatchResponses := make([]*cloudwatchResponse, 0)
+	for id, lr := range mdr {
+		response := &cloudwatchResponse{}
+		series, err := parseGetMetricDataTimeSeries(lr, queries[id])
+		if err != nil {
+			return cloudWatchResponses, err
+		}
+
+		response.series = series
+		response.Expression = queries[id].UsedExpression
+		response.RefId = queries[id].RefId
+		response.Id = queries[id].Id
+		response.RequestExceededMaxLimit = queries[id].RequestExceededMaxLimit
+
+		cloudWatchResponses = append(cloudWatchResponses, response)
+	}
+
+	return cloudWatchResponses, nil
+}
+
+func parseGetMetricDataTimeSeries(metricDataResults map[string]*cloudwatch.MetricDataResult, query *cloudWatchQuery) (*tsdb.TimeSeriesSlice, error) {
+	result := tsdb.TimeSeriesSlice{}
+	for label, metricDataResult := range metricDataResults {
+		if *metricDataResult.StatusCode != "Complete" {
+			return nil, fmt.Errorf("too many datapoint requested in query %s. Please try to reduce the time range", query.RefId)
+		}
+
+		for _, message := range metricDataResult.Messages {
+			if *message.Code == "ArithmeticError" {
+				return nil, fmt.Errorf("ArithmeticError in query %s: %s", query.RefId, *message.Value)
+			}
+		}
+
+		series := tsdb.TimeSeries{
+			Tags:   make(map[string]string),
+			Points: make([]tsdb.TimePoint, 0),
+		}
+
+		for key, values := range query.Dimensions {
+			if len(values) == 1 && values[0] != "*" {
+				series.Tags[key] = values[0]
+			} else {
+				for _, value := range values {
+					if value == label || value == "*" {
+						series.Tags[key] = label
+					}
+				}
+			}
+		}
+
+		series.Name = formatAlias(query, query.Stats, series.Tags, label)
+
+		for j, t := range metricDataResult.Timestamps {
+			if j > 0 {
+				expectedTimestamp := metricDataResult.Timestamps[j-1].Add(time.Duration(query.Period) * time.Second)
+				if expectedTimestamp.Before(*t) {
+					series.Points = append(series.Points, tsdb.NewTimePoint(null.FloatFromPtr(nil), float64(expectedTimestamp.Unix()*1000)))
+				}
+			}
+			series.Points = append(series.Points, tsdb.NewTimePoint(null.FloatFrom(*metricDataResult.Values[j]), float64((*t).Unix())*1000))
+		}
+		result = append(result, &series)
+	}
+	return &result, nil
+}
+
+func formatAlias(query *cloudWatchQuery, stat string, dimensions map[string]string, label string) string {
+	region := query.Region
+	namespace := query.Namespace
+	metricName := query.MetricName
+	period := strconv.Itoa(query.Period)
+
+	if query.isUserDefinedSearchExpression() {
+		pIndex := strings.LastIndex(query.Expression, ",")
+		period = strings.Trim(query.Expression[pIndex+1:], " )")
+		sIndex := strings.LastIndex(query.Expression[:pIndex], ",")
+		stat = strings.Trim(query.Expression[sIndex+1:pIndex], " '")
+	}
+
+	if len(query.Alias) == 0 && query.isMathExpression() {
+		return query.Id
+	}
+
+	if len(query.Alias) == 0 && query.isInferredSearchExpression() {
+		return label
+	}
+
+	data := map[string]string{}
+	data["region"] = region
+	data["namespace"] = namespace
+	data["metric"] = metricName
+	data["stat"] = stat
+	data["period"] = period
+	if len(label) != 0 {
+		data["label"] = label
+	}
+	for k, v := range dimensions {
+		data[k] = v
+	}
+
+	result := aliasFormat.ReplaceAllFunc([]byte(query.Alias), func(in []byte) []byte {
+		labelName := strings.Replace(string(in), "{{", "", 1)
+		labelName = strings.Replace(labelName, "}}", "", 1)
+		labelName = strings.TrimSpace(labelName)
+		if val, exists := data[labelName]; exists {
+			return []byte(val)
+		}
+
+		return in
+	})
+
+	if string(result) == "" {
+		return metricName + "_" + stat
+	}
+
+	return string(result)
+}

pkg/tsdb/cloudwatch/response_parser_test.go

@@ -0,0 +1,61 @@
+package cloudwatch
+
+import (
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/cloudwatch"
+	"github.com/grafana/grafana/pkg/components/null"
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestCloudWatchResponseParser(t *testing.T) {
+	Convey("TestCloudWatchResponseParser", t, func() {
+
+		Convey("can parse cloudwatch response", func() {
+			timestamp := time.Unix(0, 0)
+			resp := map[string]*cloudwatch.MetricDataResult{
+				"lb": {
+					Id:    aws.String("id1"),
+					Label: aws.String("lb"),
+					Timestamps: []*time.Time{
+						aws.Time(timestamp),
+						aws.Time(timestamp.Add(60 * time.Second)),
+						aws.Time(timestamp.Add(180 * time.Second)),
+					},
+					Values: []*float64{
+						aws.Float64(10),
+						aws.Float64(20),
+						aws.Float64(30),
+					},
+					StatusCode: aws.String("Complete"),
+				},
+			}
+
+			query := &cloudWatchQuery{
+				RefId:      "refId1",
+				Region:     "us-east-1",
+				Namespace:  "AWS/ApplicationELB",
+				MetricName: "TargetResponseTime",
+				Dimensions: map[string][]string{
+					"LoadBalancer": {"lb"},
+					"TargetGroup":  {"tg"},
+				},
+				Stats:  "Average",
+				Period: 60,
+				Alias:  "{{namespace}}_{{metric}}_{{stat}}",
+			}
+			series, err := parseGetMetricDataTimeSeries(resp, query)
+			timeSeries := (*series)[0]
+
+			So(err, ShouldBeNil)
+			So(timeSeries.Name, ShouldEqual, "AWS/ApplicationELB_TargetResponseTime_Average")
+			So(timeSeries.Tags["LoadBalancer"], ShouldEqual, "lb")
+			So(timeSeries.Points[0][0].String(), ShouldEqual, null.FloatFrom(10.0).String())
+			So(timeSeries.Points[1][0].String(), ShouldEqual, null.FloatFrom(20.0).String())
+			So(timeSeries.Points[2][0].String(), ShouldEqual, null.FloatFromPtr(nil).String())
+			So(timeSeries.Points[3][0].String(), ShouldEqual, null.FloatFrom(30.0).String())
+		})
+	})
+}

pkg/tsdb/cloudwatch/time_series_query.go

@@ -0,0 +1,101 @@
+package cloudwatch
+
+import (
+	"context"
+
+	"github.com/grafana/grafana/pkg/infra/log"
+	"github.com/grafana/grafana/pkg/tsdb"
+	"golang.org/x/sync/errgroup"
+)
+
+func (e *CloudWatchExecutor) executeTimeSeriesQuery(ctx context.Context, queryContext *tsdb.TsdbQuery) (*tsdb.Response, error) {
+	results := &tsdb.Response{
+		Results: make(map[string]*tsdb.QueryResult),
+	}
+
+	requestQueriesByRegion, err := e.parseQueries(queryContext)
+	if err != nil {
+		return results, err
+	}
+	resultChan := make(chan *tsdb.QueryResult, len(queryContext.Queries))
+	eg, ectx := errgroup.WithContext(ctx)
+
+	if len(requestQueriesByRegion) > 0 {
+		for r, q := range requestQueriesByRegion {
+			requestQueries := q
+			region := r
+			eg.Go(func() error {
+				defer func() {
+					if err := recover(); err != nil {
+						plog.Error("Execute Get Metric Data Query Panic", "error", err, "stack", log.Stack(1))
+						if theErr, ok := err.(error); ok {
+							resultChan <- &tsdb.QueryResult{
+								Error: theErr,
+							}
+						}
+					}
+				}()
+
+				client, err := e.getClient(region)
+				if err != nil {
+					return err
+				}
+
+				queries, err := e.transformRequestQueriesToCloudWatchQueries(requestQueries)
+				if err != nil {
+					for _, query := range requestQueries {
+						resultChan <- &tsdb.QueryResult{
+							RefId: query.RefId,
+							Error: err,
+						}
+					}
+					return nil
+				}
+
+				metricDataInput, err := e.buildMetricDataInput(queryContext, queries)
+				if err != nil {
+					return err
+				}
+
+				cloudwatchResponses := make([]*cloudwatchResponse, 0)
+				mdo, err := e.executeRequest(ectx, client, metricDataInput)
+				if err != nil {
+					for _, query := range requestQueries {
+						resultChan <- &tsdb.QueryResult{
+							RefId: query.RefId,
+							Error: err,
+						}
+					}
+					return nil
+				}
+
+				responses, err := e.parseResponse(mdo, queries)
+				if err != nil {
+					for _, query := range requestQueries {
+						resultChan <- &tsdb.QueryResult{
+							RefId: query.RefId,
+							Error: err,
+						}
+					}
+					return nil
+				}
+				cloudwatchResponses = append(cloudwatchResponses, responses...)
+				res := e.transformQueryResponseToQueryResult(cloudwatchResponses)
+				for _, queryRes := range res {
+					resultChan <- queryRes
+				}
+				return nil
+			})
+		}
+	}
+
+	if err := eg.Wait(); err != nil {
+		return nil, err
+	}
+	close(resultChan)
+	for result := range resultChan {
+		results.Results[result.RefId] = result
+	}
+
+	return results, nil
+}

pkg/tsdb/cloudwatch/types.go

@@ -1,21 +1,49 @@
 package cloudwatch
 
 import (
+	"fmt"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/service/cloudwatch"
+	"github.com/grafana/grafana/pkg/tsdb"
 )
 
-type CloudWatchQuery struct {
+type cloudWatchClient interface {
+	GetMetricDataWithContext(ctx aws.Context, input *cloudwatch.GetMetricDataInput, opts ...request.Option) (*cloudwatch.GetMetricDataOutput, error)
+}
+
+type requestQuery struct {
 	RefId              string
 	Region             string
+	Id                 string
 	Namespace          string
 	MetricName         string
-	Dimensions         []*cloudwatch.Dimension
 	Statistics         []*string
+	QueryType          string
+	Expression         string
+	ReturnData         bool
+	Dimensions         map[string][]string
 	ExtendedStatistics []*string
 	Period             int
 	Alias              string
-	Id                 string
-	Expression         string
-	ReturnData         bool
 	HighResolution     bool
+	MatchExact         bool
+}
+
+type cloudwatchResponse struct {
+	series                  *tsdb.TimeSeriesSlice
+	Id                      string
+	RefId                   string
+	Expression              string
+	RequestExceededMaxLimit bool
+}
+
+type queryError struct {
+	err   error
+	RefID string
+}
+
+func (e *queryError) Error() string {
+	return fmt.Sprintf("Error parsing query %s, %s", e.RefID, e.err)
 }