apitech
/
grafana
mirror of https://github.com/grafana/grafana
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

re-implement get regions

Browse Source
pull/8050/head
Mitsuhiro Tanda 8 years ago
parent 0c95148486
commit feed90c0e2
4 changed files with 308 additions and 236 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 4
      pkg/api/cloudwatch/cloudwatch.go
  2. 14
      pkg/tsdb/cloudwatch/cloudwatch.go
  3. 498
      pkg/tsdb/cloudwatch/metric_find_query.go
  4. 28
      public/app/plugins/datasource/cloudwatch/datasource.js

4
pkg/api/cloudwatch/cloudwatch.go
Unescape View File

@ -80,10 +80,6 @@ func init() {
"DescribeAlarmsForMetric": handleDescribeAlarmsForMetric,
"DescribeAlarmHistory": handleDescribeAlarmHistory,
"DescribeInstances": handleDescribeInstances,
"__GetRegions": handleGetRegions,
"__GetNamespaces": handleGetNamespaces,
"__GetMetrics": handleGetMetrics,
"__GetDimensions": handleGetDimensions,
}
}

14
pkg/tsdb/cloudwatch/cloudwatch.go
Unescape View File

@ -53,6 +53,20 @@ func init() {
}
func (e *CloudWatchExecutor) Execute(ctx context.Context, queries tsdb.QuerySlice, queryContext *tsdb.QueryContext) *tsdb.BatchResult {
var result *tsdb.BatchResult
queryType := queries[0].Model.Get("type").MustString()
switch queryType {
case "timeSeriesQuery":
result = e.executeTimeSeriesQuery(ctx, queries, queryContext)
break
case "metricFindQuery":
result = e.executeMetricFindQuery(ctx, queries, queryContext)
break
}
return result
}
func (e *CloudWatchExecutor) executeTimeSeriesQuery(ctx context.Context, queries tsdb.QuerySlice, queryContext *tsdb.QueryContext) *tsdb.BatchResult {
result := &tsdb.BatchResult{
QueryResults: make(map[string]*tsdb.QueryResult),
}

498
pkg/tsdb/cloudwatch/metric_find_query.go
Unescape View File

@ -1,24 +1,21 @@
package cloudwatch
import (
"encoding/json"
"sort"
"strings"
"sync"
"context"
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/awsutil"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/cloudwatch"
"github.com/grafana/grafana/pkg/metrics"
"github.com/grafana/grafana/pkg/middleware"
"github.com/grafana/grafana/pkg/util"
"github.com/grafana/grafana/pkg/components/simplejson"
"github.com/grafana/grafana/pkg/tsdb"
)
var metricsMap map[string][]string
var dimensionsMap map[string][]string
type suggestData struct {
Text string
Value string
}
type CustomMetricsCache struct {
Expire time.Time
Cache []string
@ -144,236 +141,279 @@ func init() {
customMetricsDimensionsMap = make(map[string]map[string]map[string]*CustomMetricsCache)
}
// Whenever this list is updated, frontend list should also be updated.
// Please update the region list in public/app/plugins/datasource/cloudwatch/partials/config.html
func handleGetRegions(req *cwRequest, c *middleware.Context) {
regions := []string{
"ap-northeast-1", "ap-northeast-2", "ap-southeast-1", "ap-southeast-2", "ap-south-1", "ca-central-1", "cn-north-1",
"eu-central-1", "eu-west-1", "eu-west-2", "sa-east-1", "us-east-1", "us-east-2", "us-gov-west-1", "us-west-1", "us-west-2",
}
result := []interface{}{}
for _, region := range regions {
result = append(result, util.DynMap{"text": region, "value": region})
}
c.JSON(200, result)
}
func handleGetNamespaces(req *cwRequest, c *middleware.Context) {
keys := []string{}
for key := range metricsMap {
keys = append(keys, key)
}
customNamespaces := req.DataSource.JsonData.Get("customMetricsNamespaces").MustString()
if customNamespaces != "" {
keys = append(keys, strings.Split(customNamespaces, ",")...)
func (e *CloudWatchExecutor) executeMetricFindQuery(ctx context.Context, queries tsdb.QuerySlice, queryContext *tsdb.QueryContext) *tsdb.BatchResult {
result := &tsdb.BatchResult{
QueryResults: make(map[string]*tsdb.QueryResult),
}
sort.Sort(sort.StringSlice(keys))
result := []interface{}{}
for _, key := range keys {
result = append(result, util.DynMap{"text": key, "value": key})
}
c.JSON(200, result)
}
func handleGetMetrics(req *cwRequest, c *middleware.Context) {
reqParam := &struct {
Parameters struct {
Namespace string `json:"namespace"`
} `json:"parameters"`
}{}
json.Unmarshal(req.Body, reqParam)
var namespaceMetrics []string
if !isCustomMetrics(reqParam.Parameters.Namespace) {
var exists bool
if namespaceMetrics, exists = metricsMap[reqParam.Parameters.Namespace]; !exists {
c.JsonApiErr(404, "Unable to find namespace "+reqParam.Parameters.Namespace, nil)
return
}
} else {
var err error
cwData := req.GetDatasourceInfo()
cwData.Namespace = reqParam.Parameters.Namespace
if namespaceMetrics, err = getMetricsForCustomMetrics(cwData, getAllMetrics); err != nil {
c.JsonApiErr(500, "Unable to call AWS API", err)
return
queryResult := &tsdb.QueryResult{Meta: simplejson.New(), RefId: queries[0].RefId}
parameters := queries[0].Model.Get("parameters")
subType := queries[0].Model.Get("subtype").MustString()
var data []suggestData
var err error
switch subType {
case "regions":
data, err = e.handleGetRegions(ctx, parameters, queryContext)
if err != nil {
queryResult.Error = err
}
break
}
sort.Sort(sort.StringSlice(namespaceMetrics))
result := []interface{}{}
for _, name := range namespaceMetrics {
result = append(result, util.DynMap{"text": name, "value": name})
}
c.JSON(200, result)
transformToTable(data, queryResult)
result.QueryResults[queries[0].RefId] = queryResult
return result
}
func handleGetDimensions(req *cwRequest, c *middleware.Context) {
reqParam := &struct {
Parameters struct {
Namespace string `json:"namespace"`
} `json:"parameters"`
}{}
json.Unmarshal(req.Body, reqParam)
var dimensionValues []string
if !isCustomMetrics(reqParam.Parameters.Namespace) {
var exists bool
if dimensionValues, exists = dimensionsMap[reqParam.Parameters.Namespace]; !exists {
c.JsonApiErr(404, "Unable to find dimension "+reqParam.Parameters.Namespace, nil)
return
}
} else {
var err error
dsInfo := req.GetDatasourceInfo()
dsInfo.Namespace = reqParam.Parameters.Namespace
if dimensionValues, err = getDimensionsForCustomMetrics(dsInfo, getAllMetrics); err != nil {
c.JsonApiErr(500, "Unable to call AWS API", err)
return
}
func transformToTable(data []suggestData, result *tsdb.QueryResult) {
table := &tsdb.Table{
Columns: make([]tsdb.TableColumn, 2),
Rows: make([]tsdb.RowValues, 0),
}
sort.Sort(sort.StringSlice(dimensionValues))
result := []interface{}{}
for _, name := range dimensionValues {
result = append(result, util.DynMap{"text": name, "value": name})
table.Columns[0].Text = "text"
table.Columns[1].Text = "value"
for _, r := range data {
values := make([]interface{}, 2)
values[0] = r.Text
values[1] = r.Value
table.Rows = append(table.Rows, values)
}
c.JSON(200, result)
result.Tables = append(result.Tables, table)
result.Meta.Set("rowCount", len(data))
}
func getAllMetrics(cwData *DatasourceInfo) (cloudwatch.ListMetricsOutput, error) {
creds, err := GetCredentials(cwData)
if err != nil {
return cloudwatch.ListMetricsOutput{}, err
}
cfg := &aws.Config{
Region: aws.String(cwData.Region),
Credentials: creds,
}
sess, err := session.NewSession(cfg)
if err != nil {
return cloudwatch.ListMetricsOutput{}, err
}
svc := cloudwatch.New(sess, cfg)
params := &cloudwatch.ListMetricsInput{
Namespace: aws.String(cwData.Namespace),
}
var resp cloudwatch.ListMetricsOutput
err = svc.ListMetricsPages(params,
func(page *cloudwatch.ListMetricsOutput, lastPage bool) bool {
metrics.M_Aws_CloudWatch_ListMetrics.Inc()
metrics, _ := awsutil.ValuesAtPath(page, "Metrics")
for _, metric := range metrics {
resp.Metrics = append(resp.Metrics, metric.(*cloudwatch.Metric))
}
return !lastPage
})
if err != nil {
return resp, err
}
return resp, nil
}
var metricsCacheLock sync.Mutex
func getMetricsForCustomMetrics(dsInfo *DatasourceInfo, getAllMetrics func(*DatasourceInfo) (cloudwatch.ListMetricsOutput, error)) ([]string, error) {
metricsCacheLock.Lock()
defer metricsCacheLock.Unlock()
if _, ok := customMetricsMetricsMap[dsInfo.Profile]; !ok {
customMetricsMetricsMap[dsInfo.Profile] = make(map[string]map[string]*CustomMetricsCache)
}
if _, ok := customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region]; !ok {
customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region] = make(map[string]*CustomMetricsCache)
}
if _, ok := customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace]; !ok {
customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace] = &CustomMetricsCache{}
customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache = make([]string, 0)
}
if customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Expire.After(time.Now()) {
return customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache, nil
}
result, err := getAllMetrics(dsInfo)
if err != nil {
return []string{}, err
}
customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache = make([]string, 0)
customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Expire = time.Now().Add(5 * time.Minute)
for _, metric := range result.Metrics {
if isDuplicate(customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache, *metric.MetricName) {
continue
}
customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache = append(customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache, *metric.MetricName)
}
return customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache, nil
}
var dimensionsCacheLock sync.Mutex
func getDimensionsForCustomMetrics(dsInfo *DatasourceInfo, getAllMetrics func(*DatasourceInfo) (cloudwatch.ListMetricsOutput, error)) ([]string, error) {
dimensionsCacheLock.Lock()
defer dimensionsCacheLock.Unlock()
if _, ok := customMetricsDimensionsMap[dsInfo.Profile]; !ok {
customMetricsDimensionsMap[dsInfo.Profile] = make(map[string]map[string]*CustomMetricsCache)
}
if _, ok := customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region]; !ok {
customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region] = make(map[string]*CustomMetricsCache)
}
if _, ok := customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace]; !ok {
customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace] = &CustomMetricsCache{}
customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache = make([]string, 0)
}
if customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Expire.After(time.Now()) {
return customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache, nil
}
result, err := getAllMetrics(dsInfo)
if err != nil {
return []string{}, err
// Whenever this list is updated, frontend list should also be updated.
// Please update the region list in public/app/plugins/datasource/cloudwatch/partials/config.html
func (e *CloudWatchExecutor) handleGetRegions(ctx context.Context, parameters *simplejson.Json, queryContext *tsdb.QueryContext) ([]suggestData, error) {
regions := []string{
"ap-northeast-1", "ap-northeast-2", "ap-southeast-1", "ap-southeast-2", "ap-south-1", "ca-central-1", "cn-north-1",
"eu-central-1", "eu-west-1", "eu-west-2", "sa-east-1", "us-east-1", "us-east-2", "us-gov-west-1", "us-west-1", "us-west-2",
}
customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache = make([]string, 0)
customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Expire = time.Now().Add(5 * time.Minute)
for _, metric := range result.Metrics {
for _, dimension := range metric.Dimensions {
if isDuplicate(customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache, *dimension.Name) {
continue
}
customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache = append(customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache, *dimension.Name)
}
result := make([]suggestData, 0)
for _, region := range regions {
result = append(result, suggestData{Text: region, Value: region})
}
return customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache, nil
return result, nil
}
func isDuplicate(nameList []string, target string) bool {
for _, name := range nameList {
if name == target {
return true
}
}
return false
}
func isCustomMetrics(namespace string) bool {
return strings.Index(namespace, "AWS/") != 0
}
//func handleGetNamespaces(req *cwRequest, c *middleware.Context) {
// keys := []string{}
// for key := range metricsMap {
// keys = append(keys, key)
// }
//
// customNamespaces := req.DataSource.JsonData.Get("customMetricsNamespaces").MustString()
// if customNamespaces != "" {
// for _, key := range strings.Split(customNamespaces, ",") {
// keys = append(keys, key)
// }
// }
//
// sort.Sort(sort.StringSlice(keys))
//
// result := []interface{}{}
// for _, key := range keys {
// result = append(result, util.DynMap{"text": key, "value": key})
// }
//
// c.JSON(200, result)
//}
//
//func handleGetMetrics(req *cwRequest, c *middleware.Context) {
// reqParam := &struct {
// Parameters struct {
// Namespace string `json:"namespace"`
// } `json:"parameters"`
// }{}
//
// json.Unmarshal(req.Body, reqParam)
//
// var namespaceMetrics []string
// if !isCustomMetrics(reqParam.Parameters.Namespace) {
// var exists bool
// if namespaceMetrics, exists = metricsMap[reqParam.Parameters.Namespace]; !exists {
// c.JsonApiErr(404, "Unable to find namespace "+reqParam.Parameters.Namespace, nil)
// return
// }
// } else {
// var err error
// cwData := req.GetDatasourceInfo()
// cwData.Namespace = reqParam.Parameters.Namespace
//
// if namespaceMetrics, err = getMetricsForCustomMetrics(cwData, getAllMetrics); err != nil {
// c.JsonApiErr(500, "Unable to call AWS API", err)
// return
// }
// }
// sort.Sort(sort.StringSlice(namespaceMetrics))
//
// result := []interface{}{}
// for _, name := range namespaceMetrics {
// result = append(result, util.DynMap{"text": name, "value": name})
// }
//
// c.JSON(200, result)
//}
//
//func handleGetDimensions(req *cwRequest, c *middleware.Context) {
// reqParam := &struct {
// Parameters struct {
// Namespace string `json:"namespace"`
// } `json:"parameters"`
// }{}
//
// json.Unmarshal(req.Body, reqParam)
//
// var dimensionValues []string
// if !isCustomMetrics(reqParam.Parameters.Namespace) {
// var exists bool
// if dimensionValues, exists = dimensionsMap[reqParam.Parameters.Namespace]; !exists {
// c.JsonApiErr(404, "Unable to find dimension "+reqParam.Parameters.Namespace, nil)
// return
// }
// } else {
// var err error
// dsInfo := req.GetDatasourceInfo()
// dsInfo.Namespace = reqParam.Parameters.Namespace
//
// if dimensionValues, err = getDimensionsForCustomMetrics(dsInfo, getAllMetrics); err != nil {
// c.JsonApiErr(500, "Unable to call AWS API", err)
// return
// }
// }
// sort.Sort(sort.StringSlice(dimensionValues))
//
// result := []interface{}{}
// for _, name := range dimensionValues {
// result = append(result, util.DynMap{"text": name, "value": name})
// }
//
// c.JSON(200, result)
//}
//
//func getAllMetrics(cwData *DatasourceInfo) (cloudwatch.ListMetricsOutput, error) {
// creds, err := GetCredentials(cwData)
// if err != nil {
// return cloudwatch.ListMetricsOutput{}, err
// }
// cfg := &aws.Config{
// Region: aws.String(cwData.Region),
// Credentials: creds,
// }
// sess, err := session.NewSession(cfg)
// if err != nil {
// return cloudwatch.ListMetricsOutput{}, err
// }
// svc := cloudwatch.New(sess, cfg)
//
// params := &cloudwatch.ListMetricsInput{
// Namespace: aws.String(cwData.Namespace),
// }
//
// var resp cloudwatch.ListMetricsOutput
// err = svc.ListMetricsPages(params,
// func(page *cloudwatch.ListMetricsOutput, lastPage bool) bool {
// metrics.M_Aws_CloudWatch_ListMetrics.Inc(1)
// metrics, _ := awsutil.ValuesAtPath(page, "Metrics")
// for _, metric := range metrics {
// resp.Metrics = append(resp.Metrics, metric.(*cloudwatch.Metric))
// }
// return !lastPage
// })
// if err != nil {
// return resp, err
// }
//
// return resp, nil
//}
//
//var metricsCacheLock sync.Mutex
//
//func getMetricsForCustomMetrics(dsInfo *DatasourceInfo, getAllMetrics func(*DatasourceInfo) (cloudwatch.ListMetricsOutput, error)) ([]string, error) {
// metricsCacheLock.Lock()
// defer metricsCacheLock.Unlock()
//
// if _, ok := customMetricsMetricsMap[dsInfo.Profile]; !ok {
// customMetricsMetricsMap[dsInfo.Profile] = make(map[string]map[string]*CustomMetricsCache)
// }
// if _, ok := customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region]; !ok {
// customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region] = make(map[string]*CustomMetricsCache)
// }
// if _, ok := customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace]; !ok {
// customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace] = &CustomMetricsCache{}
// customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache = make([]string, 0)
// }
//
// if customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Expire.After(time.Now()) {
// return customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache, nil
// }
// result, err := getAllMetrics(dsInfo)
// if err != nil {
// return []string{}, err
// }
// customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache = make([]string, 0)
// customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Expire = time.Now().Add(5 * time.Minute)
//
// for _, metric := range result.Metrics {
// if isDuplicate(customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache, *metric.MetricName) {
// continue
// }
// customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache = append(customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache, *metric.MetricName)
// }
//
// return customMetricsMetricsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache, nil
//}
//
//var dimensionsCacheLock sync.Mutex
//
//func getDimensionsForCustomMetrics(dsInfo *DatasourceInfo, getAllMetrics func(*DatasourceInfo) (cloudwatch.ListMetricsOutput, error)) ([]string, error) {
// dimensionsCacheLock.Lock()
// defer dimensionsCacheLock.Unlock()
//
// if _, ok := customMetricsDimensionsMap[dsInfo.Profile]; !ok {
// customMetricsDimensionsMap[dsInfo.Profile] = make(map[string]map[string]*CustomMetricsCache)
// }
// if _, ok := customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region]; !ok {
// customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region] = make(map[string]*CustomMetricsCache)
// }
// if _, ok := customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace]; !ok {
// customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace] = &CustomMetricsCache{}
// customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache = make([]string, 0)
// }
//
// if customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Expire.After(time.Now()) {
// return customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache, nil
// }
// result, err := getAllMetrics(dsInfo)
// if err != nil {
// return []string{}, err
// }
// customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache = make([]string, 0)
// customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Expire = time.Now().Add(5 * time.Minute)
//
// for _, metric := range result.Metrics {
// for _, dimension := range metric.Dimensions {
// if isDuplicate(customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache, *dimension.Name) {
// continue
// }
// customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache = append(customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache, *dimension.Name)
// }
// }
//
// return customMetricsDimensionsMap[dsInfo.Profile][dsInfo.Region][dsInfo.Namespace].Cache, nil
//}
//
//func isDuplicate(nameList []string, target string) bool {
// for _, name := range nameList {
// if name == target {
// return true
// }
// }
// return false
//}
//
//func isCustomMetrics(namespace string) bool {
// return strings.Index(namespace, "AWS/") != 0
//}

28
public/app/plugins/datasource/cloudwatch/datasource.js
Unescape View File

@ -11,7 +11,7 @@ function (angular, _, moment, dateMath, kbn, templatingVariable, CloudWatchAnnot
'use strict';
/** @ngInject */
function CloudWatchDatasource(instanceSettings, $q, backendSrv, templateSrv) {
function CloudWatchDatasource(instanceSettings, $q, backendSrv, templateSrv, timeSrv) {
this.type = 'cloudwatch';
this.name = instanceSettings.name;
this.supportMetrics = true;
@ -133,7 +133,21 @@ function (angular, _, moment, dateMath, kbn, templatingVariable, CloudWatchAnnot
};
this.getRegions = function() {
return this.awsRequest({action: '__GetRegions'});
var range = timeSrv.timeRange();
return backendSrv.post('/api/tsdb/query', {
from: range.from,
to: range.to,
queries: [
{
refId: 'metricFindQuery',
intervalMs: 1, // dummy
maxDataPoints: 1, // dummy
datasourceId: this.instanceSettings.id,
type: 'metricFindQuery',
subtype: 'regions'
}
]
});
};
this.getNamespaces = function() {
@ -200,6 +214,14 @@ function (angular, _, moment, dateMath, kbn, templatingVariable, CloudWatchAnnot
var namespace;
var metricName;
var transformSuggestDataFromTable = function(suggestData) {
return _.map(suggestData.results['metricFindQuery'].tables[0].rows, function (v) {
return {
text: v[0],
value: v[1]
};
});
};
var transformSuggestData = function(suggestData) {
return _.map(suggestData, function(v) {
return { text: v };
@ -208,7 +230,7 @@ function (angular, _, moment, dateMath, kbn, templatingVariable, CloudWatchAnnot
var regionQuery = query.match(/^regions\(\)/);
if (regionQuery) {
return this.getRegions();
return this.getRegions().then(function (r) { return transformSuggestDataFromTable(r); });
}
var namespaceQuery = query.match(/^namespaces\(\)/);

Write Preview
Loading…
Cancel
Save