public/grafana
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cloudwatch: Refactor dimension values resource request (#57346)

Browse Source 
* refactor dimension values backend

* fix test file name
This commit is contained in:
Erik Sundell
2022-10-24 15:04:25 +02:00
committed by GitHub
parent 9ebed91eed
commit 017da781cf
23 changed files with 587 additions and 277 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/tsdb/cloudwatch/models/dimension_keys_request.go
-88
View File
@@ -1,88 +0,0 @@
package models
import (
"encoding/json"
"fmt"
"net/url"
"github.com/grafana/grafana/pkg/tsdb/cloudwatch/constants"
)
type DimensionKeysRequestType uint32
const (
StandardDimensionKeysRequest DimensionKeysRequestType = iota
FilterDimensionKeysRequest
CustomMetricDimensionKeysRequest
)
type Dimension struct {
Name string
Value string
}
type DimensionKeysRequest struct {
Region string `json:"region"`
Namespace string `json:"namespace"`
MetricName string `json:"metricName"`
DimensionFilter []*Dimension
}
func (q *DimensionKeysRequest) Type() DimensionKeysRequestType {
if _, exist := constants.NamespaceMetricsMap[q.Namespace]; !exist {
return CustomMetricDimensionKeysRequest
}
if len(q.DimensionFilter) > 0 {
return FilterDimensionKeysRequest
}
return StandardDimensionKeysRequest
}
func GetDimensionKeysRequest(parameters url.Values) (*DimensionKeysRequest, error) {
req := &DimensionKeysRequest{
Region: parameters.Get("region"),
Namespace: parameters.Get("namespace"),
MetricName: parameters.Get("metricName"),
DimensionFilter: []*Dimension{},
}
if req.Region == "" {
return nil, fmt.Errorf("region is required")
}
dimensionFilters := map[string]interface{}{}
dimensionFilterJson := []byte(parameters.Get("dimensionFilters"))
if len(dimensionFilterJson) > 0 {
err := json.Unmarshal(dimensionFilterJson, &dimensionFilters)
if err != nil {
return nil, fmt.Errorf("error unmarshaling dimensionFilters: %v", err)
}
}
addDimension := func(key string, value string) {
d := &Dimension{
Name: key,
}
// if value is not specified or a wildcard is used, simply don't use the value field
if value != "" && value != "*" {
d.Value = value
}
req.DimensionFilter = append(req.DimensionFilter, d)
}
for k, v := range dimensionFilters {
// due to legacy, value can be a string, a string slice or nil
if vv, ok := v.(string); ok {
addDimension(k, vv)
} else if vv, ok := v.([]interface{}); ok {
for _, v := range vv {
addDimension(k, v.(string))
}
} else if v == nil {
addDimension(k, "")
}
}
return req, nil
}
pkg/tsdb/cloudwatch/models/dimension_keys_request_test.go
-72
View File
@@ -1,72 +0,0 @@
package models
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestDimensionKeyQuery(t *testing.T) {
t.Run("Should parse parameters without dimension filter", func(t *testing.T) {
req, err := GetDimensionKeysRequest(map[string][]string{
"region": {"us-east-1"},
"namespace": {"AWS/EC2"},
"metricName": {"CPUUtilization"}},
)
require.NoError(t, err)
assert.Equal(t, "us-east-1", req.Region)
assert.Equal(t, "AWS/EC2", req.Namespace)
assert.Equal(t, "CPUUtilization", req.MetricName)
})
t.Run("Should parse parameters with single valued dimension filter", func(t *testing.T) {
req, err := GetDimensionKeysRequest(map[string][]string{
"region": {"us-east-1"},
"namespace": {"AWS/EC2"},
"metricName": {"CPUUtilization"},
"dimensionFilters": {"{\"InstanceId\": \"i-1234567890abcdef0\"}"},
})
require.NoError(t, err)
assert.Equal(t, "us-east-1", req.Region)
assert.Equal(t, "AWS/EC2", req.Namespace)
assert.Equal(t, "CPUUtilization", req.MetricName)
assert.Equal(t, 1, len(req.DimensionFilter))
assert.Equal(t, "InstanceId", req.DimensionFilter[0].Name)
assert.Equal(t, "i-1234567890abcdef0", req.DimensionFilter[0].Value)
})
t.Run("Should parse parameters with multi-valued dimension filter", func(t *testing.T) {
req, err := GetDimensionKeysRequest(map[string][]string{
"region": {"us-east-1"},
"namespace": {"AWS/EC2"},
"metricName": {"CPUUtilization"},
"dimensionFilters": {"{\"InstanceId\": [\"i-1234567890abcdef0\", \"i-1234567890abcdef1\"]}"},
})
require.NoError(t, err)
assert.Equal(t, "us-east-1", req.Region)
assert.Equal(t, "AWS/EC2", req.Namespace)
assert.Equal(t, "CPUUtilization", req.MetricName)
assert.Equal(t, 2, len(req.DimensionFilter))
assert.Equal(t, "InstanceId", req.DimensionFilter[0].Name)
assert.Equal(t, "i-1234567890abcdef0", req.DimensionFilter[0].Value)
assert.Equal(t, "InstanceId", req.DimensionFilter[1].Name)
assert.Equal(t, "i-1234567890abcdef1", req.DimensionFilter[1].Value)
})
t.Run("Should parse parameters with wildcard dimension filter", func(t *testing.T) {
req, err := GetDimensionKeysRequest(map[string][]string{
"region": {"us-east-1"},
"namespace": {"AWS/EC2"},
"metricName": {"CPUUtilization"},
"dimensionFilters": {"{\"InstanceId\": [\"*\"]}"},
})
require.NoError(t, err)
assert.Equal(t, "us-east-1", req.Region)
assert.Equal(t, "AWS/EC2", req.Namespace)
assert.Equal(t, "CPUUtilization", req.MetricName)
assert.Equal(t, 1, len(req.DimensionFilter))
assert.Equal(t, "InstanceId", req.DimensionFilter[0].Name)
assert.Equal(t, "", req.DimensionFilter[0].Value)
})
}
pkg/tsdb/cloudwatch/models/metric_types.go
+3 -1
View File
@@ -2,12 +2,14 @@ package models
import (
"github.com/aws/aws-sdk-go/service/cloudwatch"
"github.com/grafana/grafana/pkg/tsdb/cloudwatch/models/request"
)
type ListMetricsProvider interface {
GetDimensionKeysByDimensionFilter(*DimensionKeysRequest) ([]string, error)
GetDimensionKeysByDimensionFilter(*request.DimensionKeysRequest) ([]string, error)
GetHardCodedDimensionKeysByNamespace(string) ([]string, error)
GetDimensionKeysByNamespace(string) ([]string, error)
GetDimensionValuesByDimensionFilter(*request.DimensionValuesRequest) ([]string, error)
}
type MetricsClientProvider interface {
pkg/tsdb/cloudwatch/models/request/dimension_keys_request.go
+57
View File
@@ -0,0 +1,57 @@
package request
import (
"net/url"
"github.com/grafana/grafana/pkg/tsdb/cloudwatch/constants"
)
type DimensionKeysRequestType uint32
const (
StandardDimensionKeysRequest DimensionKeysRequestType = iota
FilterDimensionKeysRequest
CustomMetricDimensionKeysRequest
)
type DimensionKeysRequest struct {
*ResourceRequest
Namespace string
MetricName string
DimensionFilter []*Dimension
}
func (q *DimensionKeysRequest) Type() DimensionKeysRequestType {
if _, exist := constants.NamespaceMetricsMap[q.Namespace]; !exist {
return CustomMetricDimensionKeysRequest
}
if len(q.DimensionFilter) > 0 {
return FilterDimensionKeysRequest
}
return StandardDimensionKeysRequest
}
func GetDimensionKeysRequest(parameters url.Values) (*DimensionKeysRequest, error) {
resourceRequest, err := getResourceRequest(parameters)
if err != nil {
return nil, err
}
request := &DimensionKeysRequest{
ResourceRequest: resourceRequest,
Namespace: parameters.Get("namespace"),
MetricName: parameters.Get("metricName"),
DimensionFilter: []*Dimension{},
}
dimensions, err := parseDimensionFilter(parameters.Get("dimensionFilters"))
if err != nil {
return nil, err
}
request.DimensionFilter = dimensions
return request, nil
}
pkg/tsdb/cloudwatch/models/request/dimension_keys_request_test.go
+72
View File
@@ -0,0 +1,72 @@
package request
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestDimensionKeyRequest(t *testing.T) {
t.Run("Should parse parameters without dimension filter", func(t *testing.T) {
request, err := GetDimensionKeysRequest(map[string][]string{
"region": {"us-east-1"},
"namespace": {"AWS/EC2"},
"metricName": {"CPUUtilization"}},
)
require.NoError(t, err)
assert.Equal(t, "us-east-1", request.Region)
assert.Equal(t, "AWS/EC2", request.Namespace)
assert.Equal(t, "CPUUtilization", request.MetricName)
})
t.Run("Should parse parameters with single valued dimension filter", func(t *testing.T) {
request, err := GetDimensionKeysRequest(map[string][]string{
"region": {"us-east-1"},
"namespace": {"AWS/EC2"},
"metricName": {"CPUUtilization"},
"dimensionFilters": {"{\"InstanceId\": \"i-1234567890abcdef0\"}"},
})
require.NoError(t, err)
assert.Equal(t, "us-east-1", request.Region)
assert.Equal(t, "AWS/EC2", request.Namespace)
assert.Equal(t, "CPUUtilization", request.MetricName)
assert.Equal(t, 1, len(request.DimensionFilter))
assert.Equal(t, "InstanceId", request.DimensionFilter[0].Name)
assert.Equal(t, "i-1234567890abcdef0", request.DimensionFilter[0].Value)
})
t.Run("Should parse parameters with multi-valued dimension filter", func(t *testing.T) {
request, err := GetDimensionKeysRequest(map[string][]string{
"region": {"us-east-1"},
"namespace": {"AWS/EC2"},
"metricName": {"CPUUtilization"},
"dimensionFilters": {"{\"InstanceId\": [\"i-1234567890abcdef0\", \"i-1234567890abcdef1\"]}"},
})
require.NoError(t, err)
assert.Equal(t, "us-east-1", request.Region)
assert.Equal(t, "AWS/EC2", request.Namespace)
assert.Equal(t, "CPUUtilization", request.MetricName)
assert.Equal(t, 2, len(request.DimensionFilter))
assert.Equal(t, "InstanceId", request.DimensionFilter[0].Name)
assert.Equal(t, "i-1234567890abcdef0", request.DimensionFilter[0].Value)
assert.Equal(t, "InstanceId", request.DimensionFilter[1].Name)
assert.Equal(t, "i-1234567890abcdef1", request.DimensionFilter[1].Value)
})
t.Run("Should parse parameters with wildcard dimension filter", func(t *testing.T) {
request, err := GetDimensionKeysRequest(map[string][]string{
"region": {"us-east-1"},
"namespace": {"AWS/EC2"},
"metricName": {"CPUUtilization"},
"dimensionFilters": {"{\"InstanceId\": [\"*\"]}"},
})
require.NoError(t, err)
assert.Equal(t, "us-east-1", request.Region)
assert.Equal(t, "AWS/EC2", request.Namespace)
assert.Equal(t, "CPUUtilization", request.MetricName)
assert.Equal(t, 1, len(request.DimensionFilter))
assert.Equal(t, "InstanceId", request.DimensionFilter[0].Name)
assert.Equal(t, "", request.DimensionFilter[0].Value)
})
}
pkg/tsdb/cloudwatch/models/request/dimension_values_request.go
+37
View File
@@ -0,0 +1,37 @@
package request
import (
"net/url"
)
type DimensionValuesRequest struct {
*ResourceRequest
Namespace string
MetricName string
DimensionKey string
DimensionFilter []*Dimension
}
func GetDimensionValuesRequest(parameters url.Values) (*DimensionValuesRequest, error) {
resourceRequest, err := getResourceRequest(parameters)
if err != nil {
return nil, err
}
request := &DimensionValuesRequest{
ResourceRequest: resourceRequest,
Namespace: parameters.Get("namespace"),
MetricName: parameters.Get("metricName"),
DimensionKey: parameters.Get("dimensionKey"),
DimensionFilter: []*Dimension{},
}
dimensions, err := parseDimensionFilter(parameters.Get("dimensionFilters"))
if err != nil {
return nil, err
}
request.DimensionFilter = dimensions
return request, nil
}
pkg/tsdb/cloudwatch/models/request/dimension_values_rquest_test.go
+78
View File
@@ -0,0 +1,78 @@
package request
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestDimensionValuesRequest(t *testing.T) {
t.Run("Should parse parameters without dimension filter", func(t *testing.T) {
request, err := GetDimensionValuesRequest(map[string][]string{
"region": {"us-east-1"},
"namespace": {"AWS/EC2"},
"metricName": {"CPUUtilization"},
"dimensionKey": {"InstanceId"}},
)
require.NoError(t, err)
assert.Equal(t, "us-east-1", request.Region)
assert.Equal(t, "AWS/EC2", request.Namespace)
assert.Equal(t, "CPUUtilization", request.MetricName)
assert.Equal(t, "InstanceId", request.DimensionKey)
})
t.Run("Should parse parameters with single valued dimension filter", func(t *testing.T) {
request, err := GetDimensionValuesRequest(map[string][]string{
"region": {"us-east-1"},
"namespace": {"AWS/EC2"},
"metricName": {"CPUUtilization"},
"dimensionKey": {"InstanceId"},
"dimensionFilters": {"{\"InstanceId\": \"i-1234567890abcdef0\"}"},
})
require.NoError(t, err)
assert.Equal(t, "us-east-1", request.Region)
assert.Equal(t, "AWS/EC2", request.Namespace)
assert.Equal(t, "CPUUtilization", request.MetricName)
assert.Equal(t, 1, len(request.DimensionFilter))
assert.Equal(t, "InstanceId", request.DimensionKey)
assert.Equal(t, "InstanceId", request.DimensionFilter[0].Name)
assert.Equal(t, "i-1234567890abcdef0", request.DimensionFilter[0].Value)
})
t.Run("Should parse parameters with multi-valued dimension filter", func(t *testing.T) {
request, err := GetDimensionValuesRequest(map[string][]string{
"region": {"us-east-1"},
"namespace": {"AWS/EC2"},
"metricName": {"CPUUtilization"},
"dimensionKey": {"InstanceId"},
"dimensionFilters": {"{\"InstanceId\": [\"i-1234567890abcdef0\", \"i-1234567890abcdef1\"]}"},
})
require.NoError(t, err)
assert.Equal(t, "us-east-1", request.Region)
assert.Equal(t, "AWS/EC2", request.Namespace)
assert.Equal(t, "CPUUtilization", request.MetricName)
assert.Equal(t, 2, len(request.DimensionFilter))
assert.Equal(t, "InstanceId", request.DimensionKey)
assert.Equal(t, "InstanceId", request.DimensionFilter[0].Name)
assert.Equal(t, "i-1234567890abcdef0", request.DimensionFilter[0].Value)
assert.Equal(t, "InstanceId", request.DimensionFilter[1].Name)
assert.Equal(t, "i-1234567890abcdef1", request.DimensionFilter[1].Value)
})
t.Run("Should parse parameters with wildcard dimension filter", func(t *testing.T) {
request, err := GetDimensionValuesRequest(map[string][]string{
"region": {"us-east-1"},
"namespace": {"AWS/EC2"},
"metricName": {"CPUUtilization"},
"dimensionFilters": {"{\"InstanceId\": [\"*\"]}"},
})
require.NoError(t, err)
assert.Equal(t, "us-east-1", request.Region)
assert.Equal(t, "AWS/EC2", request.Namespace)
assert.Equal(t, "CPUUtilization", request.MetricName)
assert.Equal(t, 1, len(request.DimensionFilter))
assert.Equal(t, "InstanceId", request.DimensionFilter[0].Name)
assert.Equal(t, "", request.DimensionFilter[0].Value)
})
}
pkg/tsdb/cloudwatch/models/request/resource_request.go
+22
View File
@@ -0,0 +1,22 @@
package request
import (
"fmt"
"net/url"
)
type ResourceRequest struct {
Region string
}
func getResourceRequest(parameters url.Values) (*ResourceRequest, error) {
request := &ResourceRequest{
Region: parameters.Get("region"),
}
if request.Region == "" {
return nil, fmt.Errorf("region is required")
}
return request, nil
}
pkg/tsdb/cloudwatch/models/request/resource_request_test.go
+16
View File
@@ -0,0 +1,16 @@
package request
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestResourceRequest(t *testing.T) {
t.Run("Should return an error if region is not provided", func(t *testing.T) {
request, err := GetDimensionValuesRequest(map[string][]string{})
require.Nil(t, request)
assert.Equal(t, "region is required", err.Error())
})
}
pkg/tsdb/cloudwatch/models/request/types.go
+6
View File
@@ -0,0 +1,6 @@
package request
type Dimension struct {
Name string
Value string
}
pkg/tsdb/cloudwatch/models/request/utils.go
+44
View File
@@ -0,0 +1,44 @@
package request
import (
"encoding/json"
"fmt"
)
func parseDimensionFilter(dimensionFilter string) ([]*Dimension, error) {
dimensionFilters := map[string]interface{}{}
dimensionFilterJson := []byte(dimensionFilter)
if len(dimensionFilterJson) > 0 {
err := json.Unmarshal(dimensionFilterJson, &dimensionFilters)
if err != nil {
return nil, fmt.Errorf("error unmarshaling dimensionFilters: %v", err)
}
}
dimensions := []*Dimension{}
addDimension := func(key string, value string) {
d := &Dimension{
Name: key,
}
// if value is not specified or a wildcard is used, simply don't use the value field
if value != "" && value != "*" {
d.Value = value
}
dimensions = append(dimensions, d)
}
for k, v := range dimensionFilters {
// due to legacy, value can be a string, a string slice or nil
if vv, ok := v.(string); ok {
addDimension(k, vv)
} else if vv, ok := v.([]interface{}); ok {
for _, v := range vv {
addDimension(k, v.(string))
}
} else if v == nil {
addDimension(k, "")
}
}
return dimensions, nil
}