[v9.3.x] CloudWatch: fix custom namespace for listing dimension keys, refactor to non-pointer types, add test assertions, rename packages (#59130)

CloudWatch: fix custom namespace for listing dimension keys, refactor to non-pointer types, add test assertions, rename packages (#59106)

Co-authored-by: Erik Sundell <erik.sundell87@gmail.com>
(cherry picked from commit c43e1a721f)

Co-authored-by: Shirley <4163034+fridgepoet@users.noreply.github.com>

pkg/tsdb/cloudwatch/models/resources/dimension_keys_request.go

@@ -0,0 +1,50 @@
+package resources
+
+import (
+	"net/url"
+)
+
+type DimensionKeysRequestType uint32
+
+const (
+	StandardDimensionKeysRequest DimensionKeysRequestType = iota
+	FilterDimensionKeysRequest
+)
+
+type DimensionKeysRequest struct {
+	*ResourceRequest
+	Namespace       string
+	MetricName      string
+	DimensionFilter []*Dimension
+}
+
+func (q *DimensionKeysRequest) Type() DimensionKeysRequestType {
+	if isCustomNamespace(q.Namespace) || len(q.DimensionFilter) > 0 {
+		return FilterDimensionKeysRequest
+	}
+
+	return StandardDimensionKeysRequest
+}
+
+func GetDimensionKeysRequest(parameters url.Values) (DimensionKeysRequest, error) {
+	resourceRequest, err := getResourceRequest(parameters)
+	if err != nil {
+		return DimensionKeysRequest{}, 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 DimensionKeysRequest{}, err
+	}
+
+	request.DimensionFilter = dimensions
+
+	return request, nil
+}

pkg/tsdb/cloudwatch/models/resources/dimension_keys_request_test.go

@@ -0,0 +1,108 @@
+package resources
+
+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)
+	})
+
+	type testCase struct {
+		name                 string
+		dimensionKeysRequest DimensionKeysRequest
+		expectedType         DimensionKeysRequestType
+	}
+	testCases := []testCase{
+		{
+			name: "With custom namespace it should resolve to FilterDimensionKeysRequest",
+			dimensionKeysRequest: DimensionKeysRequest{
+				Namespace: "custom",
+			},
+			expectedType: FilterDimensionKeysRequest,
+		},
+		{
+			name: "With dimension filter it should resolve to FilterDimensionKeysRequest",
+			dimensionKeysRequest: DimensionKeysRequest{
+				Namespace:       "AWS/EC2",
+				DimensionFilter: []*Dimension{{Name: "InstanceId", Value: "i-1234567890abcdef0"}},
+			},
+			expectedType: FilterDimensionKeysRequest,
+		},
+		{
+			name: "With dimension filter and without custom namespace it should resolve to StandardDimensionKeysRequest",
+			dimensionKeysRequest: DimensionKeysRequest{
+				Namespace: "AWS/EC2",
+			},
+			expectedType: StandardDimensionKeysRequest,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			assert.Equal(t, tc.expectedType, tc.dimensionKeysRequest.Type())
+		})
+	}
+}

pkg/tsdb/cloudwatch/models/resources/dimension_values_request.go

@@ -0,0 +1,37 @@
+package resources
+
+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 DimensionValuesRequest{}, 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 DimensionValuesRequest{}, err
+	}
+
+	request.DimensionFilter = dimensions
+
+	return request, nil
+}

pkg/tsdb/cloudwatch/models/resources/dimension_values_rquest_test.go

@@ -0,0 +1,78 @@
+package resources
+
+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/resources/metrics_resource_request.go

@@ -0,0 +1,42 @@
+package resources
+
+import (
+	"net/url"
+)
+
+type MetricsRequestType uint32
+
+const (
+	MetricsByNamespaceRequestType MetricsRequestType = iota
+	AllMetricsRequestType
+	CustomNamespaceRequestType
+)
+
+type MetricsRequest struct {
+	*ResourceRequest
+	Namespace string
+}
+
+func GetMetricsRequest(parameters url.Values) (*MetricsRequest, error) {
+	resourceRequest, err := getResourceRequest(parameters)
+	if err != nil {
+		return nil, err
+	}
+
+	return &MetricsRequest{
+		ResourceRequest: resourceRequest,
+		Namespace:       parameters.Get("namespace"),
+	}, nil
+}
+
+func (r *MetricsRequest) Type() MetricsRequestType {
+	if r.Namespace == "" {
+		return AllMetricsRequestType
+	}
+
+	if isCustomNamespace(r.Namespace) {
+		return CustomNamespaceRequestType
+	}
+
+	return MetricsByNamespaceRequestType
+}

pkg/tsdb/cloudwatch/models/resources/metrics_resource_request_test.go

@@ -0,0 +1,48 @@
+package resources
+
+import (
+	"net/url"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestMetricsRequest(t *testing.T) {
+	t.Run("Should parse parameters", func(t *testing.T) {
+		request, err := GetMetricsRequest(map[string][]string{"region": {"us-east-1"}, "namespace": {"AWS/EC2"}})
+		require.NoError(t, err)
+		assert.Equal(t, "us-east-1", request.Region)
+		assert.Equal(t, "AWS/EC2", request.Namespace)
+	})
+
+	tests := []struct {
+		reqType MetricsRequestType
+		params  url.Values
+	}{
+		{
+			params:  map[string][]string{"region": {"us-east-1"}, "namespace": {"AWS/EC2"}},
+			reqType: MetricsByNamespaceRequestType,
+		},
+		{
+			params:  map[string][]string{"region": {"us-east-1"}},
+			reqType: AllMetricsRequestType,
+		},
+		{
+			params:  map[string][]string{"region": {"us-east-1"}, "namespace": {""}},
+			reqType: AllMetricsRequestType,
+		},
+		{
+			params:  map[string][]string{"region": {"us-east-1"}, "namespace": {"custom-namespace"}},
+			reqType: CustomNamespaceRequestType,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run("Should resolve the correct type", func(t *testing.T) {
+			request, err := GetMetricsRequest(tc.params)
+			require.NoError(t, err)
+			assert.Equal(t, tc.reqType, request.Type())
+		})
+	}
+}

pkg/tsdb/cloudwatch/models/resources/resource_request.go

@@ -0,0 +1,22 @@
+package resources
+
+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/resources/resource_request_test.go

@@ -0,0 +1,16 @@
+package resources
+
+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.Empty(t, request)
+		assert.Equal(t, "region is required", err.Error())
+	})
+}

pkg/tsdb/cloudwatch/models/resources/types.go

@@ -0,0 +1,11 @@
+package resources
+
+type Dimension struct {
+	Name  string
+	Value string
+}
+
+type Metric struct {
+	Name      string `json:"name"`
+	Namespace string `json:"namespace"`
+}

pkg/tsdb/cloudwatch/models/resources/utils.go

@@ -0,0 +1,53 @@
+package resources
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/grafana/grafana/pkg/tsdb/cloudwatch/constants"
+)
+
+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
+}
+
+func isCustomNamespace(namespace string) bool {
+	if _, ok := constants.NamespaceMetricsMap[namespace]; ok {
+		return false
+	}
+	return true
+}