CloudWatch: Improve metric label parsing (#84835)

pkg/tsdb/cloudwatch/metric_data_query_builder_test.go

@@ -1,23 +1,25 @@
 package cloudwatch
 
 import (
+	"context"
 	"testing"
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/grafana/grafana-plugin-sdk-go/backend/log"
+	"github.com/grafana/grafana/pkg/tsdb/cloudwatch/features"
 	"github.com/grafana/grafana/pkg/tsdb/cloudwatch/models"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func TestMetricDataQueryBuilder(t *testing.T) {
+	executor := newExecutor(nil, log.NewNullLogger())
 	t.Run("buildMetricDataQuery", func(t *testing.T) {
 		t.Run("should use metric stat", func(t *testing.T) {
-			executor := newExecutor(nil, log.NewNullLogger())
 			query := getBaseQuery()
 			query.MetricEditorMode = models.MetricEditorModeBuilder
 			query.MetricQueryType = models.MetricQueryTypeSearch
-			mdq, err := executor.buildMetricDataQuery(query)
+			mdq, err := executor.buildMetricDataQuery(context.Background(), query)
 			require.NoError(t, err)
 			require.Empty(t, mdq.Expression)
 			assert.Equal(t, query.MetricName, *mdq.MetricStat.Metric.MetricName)
@@ -25,57 +27,52 @@ func TestMetricDataQueryBuilder(t *testing.T) {
 		})
 
 		t.Run("should pass AccountId in metric stat query", func(t *testing.T) {
-			executor := newExecutor(nil, log.NewNullLogger())
 			query := getBaseQuery()
 			query.MetricEditorMode = models.MetricEditorModeBuilder
 			query.MetricQueryType = models.MetricQueryTypeSearch
 			query.AccountId = aws.String("some account id")
-			mdq, err := executor.buildMetricDataQuery(query)
+			mdq, err := executor.buildMetricDataQuery(context.Background(), query)
 			require.NoError(t, err)
 			assert.Equal(t, "some account id", *mdq.AccountId)
 		})
 
 		t.Run("should leave AccountId in metric stat query", func(t *testing.T) {
-			executor := newExecutor(nil, log.NewNullLogger())
 			query := getBaseQuery()
 			query.MetricEditorMode = models.MetricEditorModeBuilder
 			query.MetricQueryType = models.MetricQueryTypeSearch
-			mdq, err := executor.buildMetricDataQuery(query)
+			mdq, err := executor.buildMetricDataQuery(context.Background(), query)
 			require.NoError(t, err)
 			assert.Nil(t, mdq.AccountId)
 		})
 
 		t.Run("should use custom built expression", func(t *testing.T) {
-			executor := newExecutor(nil, log.NewNullLogger())
 			query := getBaseQuery()
 			query.MetricEditorMode = models.MetricEditorModeBuilder
 			query.MetricQueryType = models.MetricQueryTypeSearch
 			query.MatchExact = false
-			mdq, err := executor.buildMetricDataQuery(query)
+			mdq, err := executor.buildMetricDataQuery(context.Background(), query)
 			require.NoError(t, err)
 			require.Nil(t, mdq.MetricStat)
 			assert.Equal(t, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"="lb1"', '', 300))`, *mdq.Expression)
 		})
 
 		t.Run("should use sql expression", func(t *testing.T) {
-			executor := newExecutor(nil, log.NewNullLogger())
 			query := getBaseQuery()
 			query.MetricEditorMode = models.MetricEditorModeRaw
 			query.MetricQueryType = models.MetricQueryTypeQuery
 			query.SqlExpression = `SELECT SUM(CPUUTilization) FROM "AWS/EC2"`
-			mdq, err := executor.buildMetricDataQuery(query)
+			mdq, err := executor.buildMetricDataQuery(context.Background(), query)
 			require.NoError(t, err)
 			require.Nil(t, mdq.MetricStat)
 			assert.Equal(t, query.SqlExpression, *mdq.Expression)
 		})
 
 		t.Run("should use user defined math expression", func(t *testing.T) {
-			executor := newExecutor(nil, log.NewNullLogger())
 			query := getBaseQuery()
 			query.MetricEditorMode = models.MetricEditorModeRaw
 			query.MetricQueryType = models.MetricQueryTypeSearch
 			query.Expression = `SUM(x+y)`
-			mdq, err := executor.buildMetricDataQuery(query)
+			mdq, err := executor.buildMetricDataQuery(context.Background(), query)
 			require.NoError(t, err)
 			require.Nil(t, mdq.MetricStat)
 			assert.Equal(t, query.Expression, *mdq.Expression)
@@ -88,7 +85,7 @@ func TestMetricDataQueryBuilder(t *testing.T) {
 			query.MetricQueryType = models.MetricQueryTypeSearch
 			query.MatchExact = false
 			query.Expression = `SUM([a,b])`
-			mdq, err := executor.buildMetricDataQuery(query)
+			mdq, err := executor.buildMetricDataQuery(context.Background(), query)
 			require.NoError(t, err)
 			require.Nil(t, mdq.MetricStat)
 			assert.Equal(t, int64(300), *mdq.Period)
@@ -100,7 +97,7 @@ func TestMetricDataQueryBuilder(t *testing.T) {
 			query := getBaseQuery()
 			query.Label = "some label"
 
-			mdq, err := executor.buildMetricDataQuery(query)
+			mdq, err := executor.buildMetricDataQuery(context.Background(), query)
 
 			assert.NoError(t, err)
 			require.NotNil(t, mdq.Label)
@@ -112,7 +109,7 @@ func TestMetricDataQueryBuilder(t *testing.T) {
 			query := getBaseQuery()
 			query.Label = ""
 
-			mdq, err := executor.buildMetricDataQuery(query)
+			mdq, err := executor.buildMetricDataQuery(context.Background(), query)
 
 			assert.NoError(t, err)
 			assert.Nil(t, mdq.Label)
@@ -129,7 +126,7 @@ func TestMetricDataQueryBuilder(t *testing.T) {
 				AccountId:  aws.String("all"),
 			}
 
-			mdq, err := executor.buildMetricDataQuery(query)
+			mdq, err := executor.buildMetricDataQuery(context.Background(), query)
 
 			assert.NoError(t, err)
 			require.Nil(t, mdq.MetricStat)
@@ -147,7 +144,7 @@ func TestMetricDataQueryBuilder(t *testing.T) {
 				AccountId:  aws.String("12345"),
 			}
 
-			mdq, err := executor.buildMetricDataQuery(query)
+			mdq, err := executor.buildMetricDataQuery(context.Background(), query)
 
 			assert.NoError(t, err)
 			require.Nil(t, mdq.MetricStat)
@@ -165,13 +162,18 @@ func TestMetricDataQueryBuilder(t *testing.T) {
 				Dimensions: map[string][]string{
 					"LoadBalancer": {"lb1", "lb2", "lb3"},
 				},
-				Period:     300,
-				Expression: "",
-				MatchExact: matchExact,
+				Period:           300,
+				Expression:       "",
+				MatchExact:       matchExact,
+				Statistic:        "Average",
+				MetricQueryType:  models.MetricQueryTypeSearch,
+				MetricEditorMode: models.MetricEditorModeBuilder,
 			}
 
-			res := buildSearchExpression(query, "Average")
-			assert.Equal(t, `REMOVE_EMPTY(SEARCH('{"AWS/EC2","LoadBalancer"} MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`, res)
+			mdq, err := executor.buildMetricDataQuery(contextWithFeaturesEnabled(features.FlagCloudWatchNewLabelParsing), query)
+			require.NoError(t, err)
+			assert.Equal(t, `REMOVE_EMPTY(SEARCH('{"AWS/EC2","LoadBalancer"} MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`, *mdq.Expression)
+			assert.Equal(t, "${LABEL}|&|${PROP('Dim.LoadBalancer')}", *mdq.Label)
 		})
 
 		t.Run("Query has three dimension values for two given dimension keys", func(t *testing.T) {
@@ -182,29 +184,18 @@ func TestMetricDataQueryBuilder(t *testing.T) {
 					"LoadBalancer": {"lb1", "lb2", "lb3"},
 					"InstanceId":   {"i-123", "i-456", "i-789"},
 				},
-				Period:     300,
-				Expression: "",
-				MatchExact: matchExact,
+				Period:           300,
+				Expression:       "",
+				MatchExact:       matchExact,
+				Statistic:        "Average",
+				MetricQueryType:  models.MetricQueryTypeSearch,
+				MetricEditorMode: models.MetricEditorModeBuilder,
 			}
 
-			res := buildSearchExpression(query, "Average")
-			assert.Equal(t, `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))`, res)
-		})
-
-		t.Run("No OR operator was added if a star was used for dimension value", func(t *testing.T) {
-			query := &models.CloudWatchQuery{
-				Namespace:  "AWS/EC2",
-				MetricName: "CPUUtilization",
-				Dimensions: map[string][]string{
-					"LoadBalancer": {"*"},
-				},
-				Period:     300,
-				Expression: "",
-				MatchExact: matchExact,
-			}
-
-			res := buildSearchExpression(query, "Average")
-			assert.NotContains(t, res, "OR")
+			mdq, err := executor.buildMetricDataQuery(contextWithFeaturesEnabled(features.FlagCloudWatchNewLabelParsing), query)
+			require.NoError(t, err)
+			assert.Equal(t, `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))`, *mdq.Expression)
+			assert.Equal(t, "${LABEL}|&|${PROP('Dim.InstanceId')}|&|${PROP('Dim.LoadBalancer')}", *mdq.Label)
 		})
 
 		t.Run("Query has one dimension key with a * value", func(t *testing.T) {
@@ -214,13 +205,18 @@ func TestMetricDataQueryBuilder(t *testing.T) {
 				Dimensions: map[string][]string{
 					"LoadBalancer": {"*"},
 				},
-				Period:     300,
-				Expression: "",
-				MatchExact: matchExact,
+				Period:           300,
+				Expression:       "",
+				MatchExact:       matchExact,
+				Statistic:        "Average",
+				MetricQueryType:  models.MetricQueryTypeSearch,
+				MetricEditorMode: models.MetricEditorModeBuilder,
 			}
 
-			res := buildSearchExpression(query, "Average")
-			assert.Equal(t, `REMOVE_EMPTY(SEARCH('{"AWS/EC2","LoadBalancer"} MetricName="CPUUtilization"', 'Average', 300))`, res)
+			mdq, err := executor.buildMetricDataQuery(contextWithFeaturesEnabled(features.FlagCloudWatchNewLabelParsing), query)
+			require.NoError(t, err)
+			assert.Equal(t, `REMOVE_EMPTY(SEARCH('{"AWS/EC2","LoadBalancer"} MetricName="CPUUtilization"', 'Average', 300))`, *mdq.Expression)
+			assert.Equal(t, "${LABEL}|&|${PROP('Dim.LoadBalancer')}", *mdq.Label)
 		})
 
 		t.Run("Query has three dimension values for two given dimension keys, and one value is a star", func(t *testing.T) {
@@ -231,13 +227,18 @@ func TestMetricDataQueryBuilder(t *testing.T) {
 					"LoadBalancer": {"lb1", "lb2", "lb3"},
 					"InstanceId":   {"i-123", "*", "i-789"},
 				},
-				Period:     300,
-				Expression: "",
-				MatchExact: matchExact,
+				Period:           300,
+				Expression:       "",
+				MatchExact:       matchExact,
+				Statistic:        "Average",
+				MetricQueryType:  models.MetricQueryTypeSearch,
+				MetricEditorMode: models.MetricEditorModeBuilder,
 			}
 
-			res := buildSearchExpression(query, "Average")
-			assert.Equal(t, `REMOVE_EMPTY(SEARCH('{"AWS/EC2","InstanceId","LoadBalancer"} MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`, res)
+			mdq, err := executor.buildMetricDataQuery(contextWithFeaturesEnabled(features.FlagCloudWatchNewLabelParsing), query)
+			require.NoError(t, err)
+			assert.Equal(t, `REMOVE_EMPTY(SEARCH('{"AWS/EC2","InstanceId","LoadBalancer"} MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`, *mdq.Expression)
+			assert.Equal(t, "${LABEL}|&|${PROP('Dim.InstanceId')}|&|${PROP('Dim.LoadBalancer')}", *mdq.Label)
 		})
 
 		t.Run("Query has multiple dimensions and an account Id", func(t *testing.T) {
@@ -248,14 +249,19 @@ func TestMetricDataQueryBuilder(t *testing.T) {
 					"LoadBalancer": {"lb1", "lb2", "lb3"},
 					"InstanceId":   {"i-123", "*", "i-789"},
 				},
-				Period:     300,
-				Expression: "",
-				MatchExact: matchExact,
-				AccountId:  aws.String("some account id"),
+				Period:           300,
+				Expression:       "",
+				MatchExact:       matchExact,
+				AccountId:        aws.String("some account id"),
+				Statistic:        "Average",
+				MetricQueryType:  models.MetricQueryTypeSearch,
+				MetricEditorMode: models.MetricEditorModeBuilder,
 			}
 
-			res := buildSearchExpression(query, "Average")
-			assert.Equal(t, `REMOVE_EMPTY(SEARCH('{"AWS/EC2","InstanceId","LoadBalancer"} MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3") :aws.AccountId="some account id"', 'Average', 300))`, res)
+			mdq, err := executor.buildMetricDataQuery(contextWithFeaturesEnabled(features.FlagCloudWatchNewLabelParsing), query)
+			require.NoError(t, err)
+			assert.Equal(t, `REMOVE_EMPTY(SEARCH('{"AWS/EC2","InstanceId","LoadBalancer"} MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3") :aws.AccountId="some account id"', 'Average', 300))`, *mdq.Expression)
+			assert.Equal(t, "${LABEL}|&|${PROP('Dim.InstanceId')}|&|${PROP('Dim.LoadBalancer')}", *mdq.Label)
 		})
 
 		t.Run("Query has a dimension key with a space", func(t *testing.T) {
@@ -263,15 +269,20 @@ func TestMetricDataQueryBuilder(t *testing.T) {
 				Namespace:  "AWS/Kafka",
 				MetricName: "CpuUser",
 				Dimensions: map[string][]string{
-					"Cluster Name": {"dev-cluster"},
+					"Cluster Name": {"dev-cluster", "prod-cluster"},
 				},
-				Period:     300,
-				Expression: "",
-				MatchExact: matchExact,
+				Period:           300,
+				Expression:       "",
+				MatchExact:       matchExact,
+				Statistic:        "Average",
+				MetricQueryType:  models.MetricQueryTypeSearch,
+				MetricEditorMode: models.MetricEditorModeBuilder,
 			}
 
-			res := buildSearchExpression(query, "Average")
-			assert.Equal(t, `REMOVE_EMPTY(SEARCH('{"AWS/Kafka","Cluster Name"} MetricName="CpuUser" "Cluster Name"="dev-cluster"', 'Average', 300))`, res)
+			mdq, err := executor.buildMetricDataQuery(contextWithFeaturesEnabled(features.FlagCloudWatchNewLabelParsing), query)
+			require.NoError(t, err)
+			assert.Equal(t, `REMOVE_EMPTY(SEARCH('{"AWS/Kafka","Cluster Name"} MetricName="CpuUser" "Cluster Name"=("dev-cluster" OR "prod-cluster")', 'Average', 300))`, *mdq.Expression)
+			assert.Equal(t, "${LABEL}|&|${PROP('Dim.Cluster Name')}", *mdq.Label)
 		})
 
 		t.Run("Query has a custom namespace contains spaces", func(t *testing.T) {
@@ -282,13 +293,41 @@ func TestMetricDataQueryBuilder(t *testing.T) {
 					"LoadBalancer": {"lb1", "lb2", "lb3"},
 					"InstanceId":   {"i-123", "*", "i-789"},
 				},
-				Period:     300,
-				Expression: "",
-				MatchExact: matchExact,
+				Period:           300,
+				Expression:       "",
+				MatchExact:       matchExact,
+				Statistic:        "Average",
+				MetricQueryType:  models.MetricQueryTypeSearch,
+				MetricEditorMode: models.MetricEditorModeBuilder,
 			}
 
-			res := buildSearchExpression(query, "Average")
-			assert.Equal(t, `REMOVE_EMPTY(SEARCH('{"Test-API Cache by Minute","InstanceId","LoadBalancer"} MetricName="CpuUser" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`, res)
+			mdq, err := executor.buildMetricDataQuery(contextWithFeaturesEnabled(features.FlagCloudWatchNewLabelParsing), query)
+			require.NoError(t, err)
+			assert.Equal(t, `REMOVE_EMPTY(SEARCH('{"Test-API Cache by Minute","InstanceId","LoadBalancer"} MetricName="CpuUser" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`, *mdq.Expression)
+			assert.Equal(t, "${LABEL}|&|${PROP('Dim.InstanceId')}|&|${PROP('Dim.LoadBalancer')}", *mdq.Label)
+		})
+
+		t.Run("Query has a custom label", func(t *testing.T) {
+			query := &models.CloudWatchQuery{
+				Namespace:  "CPUUtilization",
+				MetricName: "CpuUser",
+				Dimensions: map[string][]string{
+					"LoadBalancer": {"lb1"},
+					"InstanceId":   {"i-123", "*", "i-789"},
+				},
+				Period:           300,
+				Expression:       "",
+				MatchExact:       matchExact,
+				Statistic:        "Average",
+				Label:            "LB: ${PROP('Dim.LoadBalancer')",
+				MetricQueryType:  models.MetricQueryTypeSearch,
+				MetricEditorMode: models.MetricEditorModeBuilder,
+			}
+
+			mdq, err := executor.buildMetricDataQuery(contextWithFeaturesEnabled(features.FlagCloudWatchNewLabelParsing), query)
+			require.NoError(t, err)
+			assert.Equal(t, `REMOVE_EMPTY(SEARCH('{"CPUUtilization","InstanceId","LoadBalancer"} MetricName="CpuUser" "LoadBalancer"="lb1"', 'Average', 300))`, *mdq.Expression)
+			assert.Equal(t, "LB: ${PROP('Dim.LoadBalancer')|&|${PROP('Dim.InstanceId')}", *mdq.Label)
 		})
 	})
 
@@ -302,13 +341,18 @@ func TestMetricDataQueryBuilder(t *testing.T) {
 				Dimensions: map[string][]string{
 					"LoadBalancer": {"lb1", "lb2", "lb3"},
 				},
-				Period:     300,
-				Expression: "",
-				MatchExact: matchExact,
+				Period:           300,
+				Expression:       "",
+				MatchExact:       matchExact,
+				Statistic:        "Average",
+				MetricQueryType:  models.MetricQueryTypeSearch,
+				MetricEditorMode: models.MetricEditorModeBuilder,
 			}
 
-			res := buildSearchExpression(query, "Average")
-			assert.Equal(t, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`, res)
+			mdq, err := executor.buildMetricDataQuery(contextWithFeaturesEnabled(features.FlagCloudWatchNewLabelParsing), query)
+			require.NoError(t, err)
+			assert.Equal(t, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`, *mdq.Expression)
+			assert.Equal(t, "${LABEL}|&|${PROP('Dim.LoadBalancer')}", *mdq.Label)
 		})
 
 		t.Run("Query has three dimension values for two given dimension keys", func(t *testing.T) {
@@ -319,13 +363,18 @@ func TestMetricDataQueryBuilder(t *testing.T) {
 					"LoadBalancer": {"lb1", "lb2", "lb3"},
 					"InstanceId":   {"i-123", "i-456", "i-789"},
 				},
-				Period:     300,
-				Expression: "",
-				MatchExact: matchExact,
+				Period:           300,
+				Expression:       "",
+				MatchExact:       matchExact,
+				Statistic:        "Average",
+				MetricQueryType:  models.MetricQueryTypeSearch,
+				MetricEditorMode: models.MetricEditorModeBuilder,
 			}
 
-			res := buildSearchExpression(query, "Average")
-			assert.Equal(t, `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))`, res)
+			mdq, err := executor.buildMetricDataQuery(contextWithFeaturesEnabled(features.FlagCloudWatchNewLabelParsing), query)
+			require.NoError(t, err)
+			assert.Equal(t, `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))`, *mdq.Expression)
+			assert.Equal(t, "${LABEL}|&|${PROP('Dim.InstanceId')}|&|${PROP('Dim.LoadBalancer')}", *mdq.Label)
 		})
 
 		t.Run("Query has one dimension key with a * value", func(t *testing.T) {
@@ -335,13 +384,18 @@ func TestMetricDataQueryBuilder(t *testing.T) {
 				Dimensions: map[string][]string{
 					"LoadBalancer": {"*"},
 				},
-				Period:     300,
-				Expression: "",
-				MatchExact: matchExact,
+				Period:           300,
+				Expression:       "",
+				MatchExact:       matchExact,
+				Statistic:        "Average",
+				MetricQueryType:  models.MetricQueryTypeSearch,
+				MetricEditorMode: models.MetricEditorModeBuilder,
 			}
 
-			res := buildSearchExpression(query, "Average")
-			assert.Equal(t, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"', 'Average', 300))`, res)
+			mdq, err := executor.buildMetricDataQuery(contextWithFeaturesEnabled(features.FlagCloudWatchNewLabelParsing), query)
+			require.NoError(t, err)
+			assert.Equal(t, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"', 'Average', 300))`, *mdq.Expression)
+			assert.Equal(t, "${LABEL}|&|${PROP('Dim.LoadBalancer')}", *mdq.Label)
 		})
 
 		t.Run("query has three dimension values for two given dimension keys, and one value is a star", func(t *testing.T) {
@@ -352,13 +406,18 @@ func TestMetricDataQueryBuilder(t *testing.T) {
 					"LoadBalancer": {"lb1", "lb2", "lb3"},
 					"InstanceId":   {"i-123", "*", "i-789"},
 				},
-				Period:     300,
-				Expression: "",
-				MatchExact: matchExact,
+				Period:           300,
+				Expression:       "",
+				MatchExact:       matchExact,
+				Statistic:        "Average",
+				MetricQueryType:  models.MetricQueryTypeSearch,
+				MetricEditorMode: models.MetricEditorModeBuilder,
 			}
 
-			res := buildSearchExpression(query, "Average")
-			assert.Equal(t, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3") "InstanceId"', 'Average', 300))`, res)
+			mdq, err := executor.buildMetricDataQuery(contextWithFeaturesEnabled(features.FlagCloudWatchNewLabelParsing), query)
+			require.NoError(t, err)
+			assert.Equal(t, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3") "InstanceId"', 'Average', 300))`, *mdq.Expression)
+			assert.Equal(t, "${LABEL}|&|${PROP('Dim.InstanceId')}|&|${PROP('Dim.LoadBalancer')}", *mdq.Label)
 		})
 
 		t.Run("query has multiple dimensions and an account Id", func(t *testing.T) {
@@ -369,14 +428,42 @@ func TestMetricDataQueryBuilder(t *testing.T) {
 					"LoadBalancer": {"lb1", "lb2", "lb3"},
 					"InstanceId":   {"i-123", "*", "i-789"},
 				},
-				Period:     300,
-				Expression: "",
-				MatchExact: matchExact,
-				AccountId:  aws.String("some account id"),
+				Period:           300,
+				Expression:       "",
+				MatchExact:       matchExact,
+				AccountId:        aws.String("some account id"),
+				Statistic:        "Average",
+				MetricQueryType:  models.MetricQueryTypeSearch,
+				MetricEditorMode: models.MetricEditorModeBuilder,
 			}
 
-			res := buildSearchExpression(query, "Average")
-			assert.Equal(t, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3") "InstanceId" :aws.AccountId="some account id"', 'Average', 300))`, res)
+			mdq, err := executor.buildMetricDataQuery(contextWithFeaturesEnabled(features.FlagCloudWatchNewLabelParsing), query)
+			require.NoError(t, err)
+			assert.Equal(t, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3") "InstanceId" :aws.AccountId="some account id"', 'Average', 300))`, *mdq.Expression)
+			assert.Equal(t, "${LABEL}|&|${PROP('Dim.InstanceId')}|&|${PROP('Dim.LoadBalancer')}", *mdq.Label)
+		})
+
+		t.Run("Query has a custom label", func(t *testing.T) {
+			query := &models.CloudWatchQuery{
+				Namespace:  "AWS/EC2",
+				MetricName: "CPUUtilization",
+				Dimensions: map[string][]string{
+					"LoadBalancer": {"lb1"},
+					"InstanceId":   {"i-123", "*", "i-789"},
+				},
+				Period:           300,
+				Expression:       "",
+				MatchExact:       matchExact,
+				Statistic:        "Average",
+				Label:            "LB: ${PROP('Dim.LoadBalancer')",
+				MetricQueryType:  models.MetricQueryTypeSearch,
+				MetricEditorMode: models.MetricEditorModeBuilder,
+			}
+
+			mdq, err := executor.buildMetricDataQuery(contextWithFeaturesEnabled(features.FlagCloudWatchNewLabelParsing), query)
+			require.NoError(t, err)
+			assert.Equal(t, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"="lb1" "InstanceId"', 'Average', 300))`, *mdq.Expression)
+			assert.Equal(t, "LB: ${PROP('Dim.LoadBalancer')|&|${PROP('Dim.InstanceId')}", *mdq.Label)
 		})
 	})