diff --git a/pkg/query-service/app/http_handler.go b/pkg/query-service/app/http_handler.go
index d347bf576e..681a472b3a 100644
--- a/pkg/query-service/app/http_handler.go
+++ b/pkg/query-service/app/http_handler.go
@@ -2521,7 +2521,7 @@ func (aH *APIHandler) getNetworkData(
 	var result []*v3.Result
 	var errQueriesByName map[string]error
 
-	result, errQueriesByName, err = aH.querierV2.QueryRange(r.Context(), queryRangeParams, nil)
+	result, errQueriesByName, err = aH.querierV2.QueryRange(r.Context(), queryRangeParams)
 	if err != nil {
 		apiErrObj := &model.ApiError{Typ: model.ErrorBadData, Err: err}
 		RespondError(w, apiErrObj, errQueriesByName)
@@ -2556,7 +2556,7 @@ func (aH *APIHandler) getNetworkData(
 		return
 	}
 
-	resultFetchLatency, errQueriesByNameFetchLatency, err := aH.querierV2.QueryRange(r.Context(), queryRangeParams, nil)
+	resultFetchLatency, errQueriesByNameFetchLatency, err := aH.querierV2.QueryRange(r.Context(), queryRangeParams)
 	if err != nil {
 		apiErrObj := &model.ApiError{Typ: model.ErrorBadData, Err: err}
 		RespondError(w, apiErrObj, errQueriesByNameFetchLatency)
@@ -2617,7 +2617,7 @@ func (aH *APIHandler) getProducerData(
 	var result []*v3.Result
 	var errQuriesByName map[string]error
 
-	result, errQuriesByName, err = aH.querierV2.QueryRange(r.Context(), queryRangeParams, nil)
+	result, errQuriesByName, err = aH.querierV2.QueryRange(r.Context(), queryRangeParams)
 	if err != nil {
 		apiErrObj := &model.ApiError{Typ: model.ErrorBadData, Err: err}
 		RespondError(w, apiErrObj, errQuriesByName)
@@ -2658,7 +2658,7 @@ func (aH *APIHandler) getConsumerData(
 	var result []*v3.Result
 	var errQuriesByName map[string]error
 
-	result, errQuriesByName, err = aH.querierV2.QueryRange(r.Context(), queryRangeParams, nil)
+	result, errQuriesByName, err = aH.querierV2.QueryRange(r.Context(), queryRangeParams)
 	if err != nil {
 		apiErrObj := &model.ApiError{Typ: model.ErrorBadData, Err: err}
 		RespondError(w, apiErrObj, errQuriesByName)
@@ -3020,7 +3020,7 @@ func (aH *APIHandler) calculateLogsConnectionStatus(
 		},
 	}
 	queryRes, _, err := aH.querier.QueryRange(
-		ctx, qrParams, map[string]v3.AttributeKey{},
+		ctx, qrParams,
 	)
 	if err != nil {
 		return nil, model.InternalError(fmt.Errorf(
@@ -3670,13 +3670,14 @@ func (aH *APIHandler) queryRangeV3(ctx context.Context, queryRangeParams *v3.Que
 			RespondError(w, apiErrObj, errQuriesByName)
 			return
 		}
+		tracesV3.Enrich(queryRangeParams, spanKeys)
 	}
 
 	// WARN: Only works for AND operator in traces query
 	if queryRangeParams.CompositeQuery.QueryType == v3.QueryTypeBuilder {
 		// check if traceID is used as filter (with equal/similar operator) in traces query if yes add timestamp filter to queryRange params
 		isUsed, traceIDs := tracesV3.TraceIdFilterUsedWithEqual(queryRangeParams)
-		if isUsed == true && len(traceIDs) > 0 {
+		if isUsed && len(traceIDs) > 0 {
 			zap.L().Debug("traceID used as filter in traces query")
 			// query signoz_spans table with traceID to get min and max timestamp
 			min, max, err := aH.reader.GetMinAndMaxTimestampForTraceID(ctx, traceIDs)
@@ -3706,7 +3707,7 @@ func (aH *APIHandler) queryRangeV3(ctx context.Context, queryRangeParams *v3.Que
 		}
 	}
 
-	result, errQuriesByName, err = aH.querier.QueryRange(ctx, queryRangeParams, spanKeys)
+	result, errQuriesByName, err = aH.querier.QueryRange(ctx, queryRangeParams)
 
 	if err != nil {
 		apiErrObj := &model.ApiError{Typ: model.ErrorBadData, Err: err}
@@ -4044,13 +4045,14 @@ func (aH *APIHandler) queryRangeV4(ctx context.Context, queryRangeParams *v3.Que
 			RespondError(w, apiErrObj, errQuriesByName)
 			return
 		}
+		tracesV3.Enrich(queryRangeParams, spanKeys)
 	}
 
 	// WARN: Only works for AND operator in traces query
 	if queryRangeParams.CompositeQuery.QueryType == v3.QueryTypeBuilder {
 		// check if traceID is used as filter (with equal/similar operator) in traces query if yes add timestamp filter to queryRange params
 		isUsed, traceIDs := tracesV3.TraceIdFilterUsedWithEqual(queryRangeParams)
-		if isUsed == true && len(traceIDs) > 0 {
+		if isUsed && len(traceIDs) > 0 {
 			zap.L().Debug("traceID used as filter in traces query")
 			// query signoz_spans table with traceID to get min and max timestamp
 			min, max, err := aH.reader.GetMinAndMaxTimestampForTraceID(ctx, traceIDs)
@@ -4062,7 +4064,7 @@ func (aH *APIHandler) queryRangeV4(ctx context.Context, queryRangeParams *v3.Que
 		}
 	}
 
-	result, errQuriesByName, err = aH.querierV2.QueryRange(ctx, queryRangeParams, spanKeys)
+	result, errQuriesByName, err = aH.querierV2.QueryRange(ctx, queryRangeParams)
 
 	if err != nil {
 		apiErrObj := &model.ApiError{Typ: model.ErrorBadData, Err: err}
diff --git a/pkg/query-service/app/querier/helper.go b/pkg/query-service/app/querier/helper.go
index 7c45cc8781..cf42828d05 100644
--- a/pkg/query-service/app/querier/helper.go
+++ b/pkg/query-service/app/querier/helper.go
@@ -77,7 +77,6 @@ func (q *querier) runBuilderQuery(
 	ctx context.Context,
 	builderQuery *v3.BuilderQuery,
 	params *v3.QueryRangeParamsV3,
-	keys map[string]v3.AttributeKey,
 	cacheKeys map[string]string,
 	ch chan channelResult,
 	wg *sync.WaitGroup,
@@ -196,7 +195,6 @@ func (q *querier) runBuilderQuery(
 				end,
 				params.CompositeQuery.PanelType,
 				builderQuery,
-				keys,
 				tracesV3.Options{GraphLimitQtype: constants.FirstQueryGraphLimit, PreferRPM: preferRPM},
 			)
 			if err != nil {
@@ -208,7 +206,6 @@ func (q *querier) runBuilderQuery(
 				end,
 				params.CompositeQuery.PanelType,
 				builderQuery,
-				keys,
 				tracesV3.Options{GraphLimitQtype: constants.SecondQueryGraphLimit, PreferRPM: preferRPM},
 			)
 			if err != nil {
@@ -222,7 +219,6 @@ func (q *querier) runBuilderQuery(
 				end,
 				params.CompositeQuery.PanelType,
 				builderQuery,
-				keys,
 				tracesV3.Options{PreferRPM: preferRPM},
 			)
 			if err != nil {
@@ -333,7 +329,6 @@ func (q *querier) runBuilderExpression(
 	ctx context.Context,
 	builderQuery *v3.BuilderQuery,
 	params *v3.QueryRangeParamsV3,
-	keys map[string]v3.AttributeKey,
 	cacheKeys map[string]string,
 	ch chan channelResult,
 	wg *sync.WaitGroup,
@@ -342,7 +337,7 @@ func (q *querier) runBuilderExpression(
 
 	queryName := builderQuery.QueryName
 
-	queries, err := q.builder.PrepareQueries(params, keys)
+	queries, err := q.builder.PrepareQueries(params)
 	if err != nil {
 		ch <- channelResult{Err: err, Name: queryName, Query: "", Series: nil}
 		return
@@ -377,7 +372,7 @@ func (q *querier) runBuilderExpression(
 			NoCache:        params.NoCache,
 			CompositeQuery: params.CompositeQuery,
 			Variables:      params.Variables,
-		}, keys)
+		})
 		query := missQueries[queryName]
 		series, err := q.execClickHouseQuery(ctx, query)
 		if err != nil {
diff --git a/pkg/query-service/app/querier/querier.go b/pkg/query-service/app/querier/querier.go
index 2113b3f8fc..15b587c8f5 100644
--- a/pkg/query-service/app/querier/querier.go
+++ b/pkg/query-service/app/querier/querier.go
@@ -297,7 +297,7 @@ func mergeSerieses(cachedSeries, missedSeries []*v3.Series) []*v3.Series {
 	return mergedSeries
 }
 
-func (q *querier) runBuilderQueries(ctx context.Context, params *v3.QueryRangeParamsV3, keys map[string]v3.AttributeKey) ([]*v3.Result, map[string]error, error) {
+func (q *querier) runBuilderQueries(ctx context.Context, params *v3.QueryRangeParamsV3) ([]*v3.Result, map[string]error, error) {
 
 	cacheKeys := q.keyGenerator.GenerateKeys(params)
 
@@ -310,9 +310,9 @@ func (q *querier) runBuilderQueries(ctx context.Context, params *v3.QueryRangePa
 		}
 		wg.Add(1)
 		if queryName == builderQuery.Expression {
-			go q.runBuilderQuery(ctx, builderQuery, params, keys, cacheKeys, ch, &wg)
+			go q.runBuilderQuery(ctx, builderQuery, params, cacheKeys, ch, &wg)
 		} else {
-			go q.runBuilderExpression(ctx, builderQuery, params, keys, cacheKeys, ch, &wg)
+			go q.runBuilderExpression(ctx, builderQuery, params, cacheKeys, ch, &wg)
 		}
 	}
 
@@ -470,7 +470,7 @@ func (q *querier) runClickHouseQueries(ctx context.Context, params *v3.QueryRang
 	return results, errQueriesByName, err
 }
 
-func (q *querier) runLogsListQuery(ctx context.Context, params *v3.QueryRangeParamsV3, keys map[string]v3.AttributeKey, tsRanges []utils.LogsListTsRange) ([]*v3.Result, map[string]error, error) {
+func (q *querier) runLogsListQuery(ctx context.Context, params *v3.QueryRangeParamsV3, tsRanges []utils.LogsListTsRange) ([]*v3.Result, map[string]error, error) {
 	res := make([]*v3.Result, 0)
 	qName := ""
 	pageSize := uint64(0)
@@ -487,7 +487,7 @@ func (q *querier) runLogsListQuery(ctx context.Context, params *v3.QueryRangePar
 		params.End = v.End
 
 		params.CompositeQuery.BuilderQueries[qName].PageSize = pageSize - uint64(len(data))
-		queries, err := q.builder.PrepareQueries(params, keys)
+		queries, err := q.builder.PrepareQueries(params)
 		if err != nil {
 			return nil, nil, err
 		}
@@ -529,7 +529,7 @@ func (q *querier) runLogsListQuery(ctx context.Context, params *v3.QueryRangePar
 	return res, nil, nil
 }
 
-func (q *querier) runBuilderListQueries(ctx context.Context, params *v3.QueryRangeParamsV3, keys map[string]v3.AttributeKey) ([]*v3.Result, map[string]error, error) {
+func (q *querier) runBuilderListQueries(ctx context.Context, params *v3.QueryRangeParamsV3) ([]*v3.Result, map[string]error, error) {
 	// List query has support for only one query.
 	if q.UseLogsNewSchema && params.CompositeQuery != nil && len(params.CompositeQuery.BuilderQueries) == 1 {
 		for _, v := range params.CompositeQuery.BuilderQueries {
@@ -537,13 +537,13 @@ func (q *querier) runBuilderListQueries(ctx context.Context, params *v3.QueryRan
 			if v.DataSource == v3.DataSourceLogs && len(v.OrderBy) == 1 && v.OrderBy[0].ColumnName == "timestamp" && v.OrderBy[0].Order == "desc" {
 				startEndArr := utils.GetLogsListTsRanges(params.Start, params.End)
 				if len(startEndArr) > 0 {
-					return q.runLogsListQuery(ctx, params, keys, startEndArr)
+					return q.runLogsListQuery(ctx, params, startEndArr)
 				}
 			}
 		}
 	}
 
-	queries, err := q.builder.PrepareQueries(params, keys)
+	queries, err := q.builder.PrepareQueries(params)
 
 	if err != nil {
 		return nil, nil, err
@@ -590,7 +590,7 @@ func (q *querier) runBuilderListQueries(ctx context.Context, params *v3.QueryRan
 	return res, nil, nil
 }
 
-func (q *querier) QueryRange(ctx context.Context, params *v3.QueryRangeParamsV3, keys map[string]v3.AttributeKey) ([]*v3.Result, map[string]error, error) {
+func (q *querier) QueryRange(ctx context.Context, params *v3.QueryRangeParamsV3) ([]*v3.Result, map[string]error, error) {
 	var results []*v3.Result
 	var err error
 	var errQueriesByName map[string]error
@@ -598,9 +598,9 @@ func (q *querier) QueryRange(ctx context.Context, params *v3.QueryRangeParamsV3,
 		switch params.CompositeQuery.QueryType {
 		case v3.QueryTypeBuilder:
 			if params.CompositeQuery.PanelType == v3.PanelTypeList || params.CompositeQuery.PanelType == v3.PanelTypeTrace {
-				results, errQueriesByName, err = q.runBuilderListQueries(ctx, params, keys)
+				results, errQueriesByName, err = q.runBuilderListQueries(ctx, params)
 			} else {
-				results, errQueriesByName, err = q.runBuilderQueries(ctx, params, keys)
+				results, errQueriesByName, err = q.runBuilderQueries(ctx, params)
 			}
 			// in builder query, the only errors we expose are the ones that exceed the resource limits
 			// everything else is internal error as they are not actionable by the user
diff --git a/pkg/query-service/app/querier/querier_test.go b/pkg/query-service/app/querier/querier_test.go
index aecb7b27ba..a4814d0c0a 100644
--- a/pkg/query-service/app/querier/querier_test.go
+++ b/pkg/query-service/app/querier/querier_test.go
@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"go.signoz.io/signoz/pkg/query-service/app/queryBuilder"
+	tracesV3 "go.signoz.io/signoz/pkg/query-service/app/traces/v3"
 	"go.signoz.io/signoz/pkg/query-service/cache/inmemory"
 	v3 "go.signoz.io/signoz/pkg/query-service/model/v3"
 )
@@ -584,7 +585,8 @@ func TestQueryRange(t *testing.T) {
 	}
 
 	for i, param := range params {
-		_, errByName, err := q.QueryRange(context.Background(), param, nil)
+		tracesV3.Enrich(param, map[string]v3.AttributeKey{})
+		_, errByName, err := q.QueryRange(context.Background(), param)
 		if err != nil {
 			t.Errorf("expected no error, got %s", err)
 		}
@@ -693,7 +695,8 @@ func TestQueryRangeValueType(t *testing.T) {
 	}
 
 	for i, param := range params {
-		_, errByName, err := q.QueryRange(context.Background(), param, nil)
+		tracesV3.Enrich(param, map[string]v3.AttributeKey{})
+		_, errByName, err := q.QueryRange(context.Background(), param)
 		if err != nil {
 			t.Errorf("expected no error, got %s", err)
 		}
@@ -746,7 +749,8 @@ func TestQueryRangeTimeShift(t *testing.T) {
 	expectedTimeRangeInQueryString := fmt.Sprintf("timestamp >= %d AND timestamp <= %d", (1675115596722-86400*1000)*1000000, ((1675115596722+120*60*1000)-86400*1000)*1000000)
 
 	for i, param := range params {
-		_, errByName, err := q.QueryRange(context.Background(), param, nil)
+		tracesV3.Enrich(param, map[string]v3.AttributeKey{})
+		_, errByName, err := q.QueryRange(context.Background(), param)
 		if err != nil {
 			t.Errorf("expected no error, got %s", err)
 		}
@@ -844,7 +848,8 @@ func TestQueryRangeTimeShiftWithCache(t *testing.T) {
 	}
 
 	for i, param := range params {
-		_, errByName, err := q.QueryRange(context.Background(), param, nil)
+		tracesV3.Enrich(param, map[string]v3.AttributeKey{})
+		_, errByName, err := q.QueryRange(context.Background(), param)
 		if err != nil {
 			t.Errorf("expected no error, got %s", err)
 		}
@@ -944,7 +949,8 @@ func TestQueryRangeTimeShiftWithLimitAndCache(t *testing.T) {
 	}
 
 	for i, param := range params {
-		_, errByName, err := q.QueryRange(context.Background(), param, nil)
+		tracesV3.Enrich(param, map[string]v3.AttributeKey{})
+		_, errByName, err := q.QueryRange(context.Background(), param)
 		if err != nil {
 			t.Errorf("expected no error, got %s", err)
 		}
@@ -1033,7 +1039,8 @@ func TestQueryRangeValueTypePromQL(t *testing.T) {
 	}
 
 	for i, param := range params {
-		_, errByName, err := q.QueryRange(context.Background(), param, nil)
+		tracesV3.Enrich(param, map[string]v3.AttributeKey{})
+		_, errByName, err := q.QueryRange(context.Background(), param)
 		if err != nil {
 			t.Errorf("expected no error, got %s", err)
 		}
diff --git a/pkg/query-service/app/querier/v2/helper.go b/pkg/query-service/app/querier/v2/helper.go
index de9d591f7f..126b532af6 100644
--- a/pkg/query-service/app/querier/v2/helper.go
+++ b/pkg/query-service/app/querier/v2/helper.go
@@ -77,7 +77,6 @@ func (q *querier) runBuilderQuery(
 	ctx context.Context,
 	builderQuery *v3.BuilderQuery,
 	params *v3.QueryRangeParamsV3,
-	keys map[string]v3.AttributeKey,
 	cacheKeys map[string]string,
 	ch chan channelResult,
 	wg *sync.WaitGroup,
@@ -195,7 +194,6 @@ func (q *querier) runBuilderQuery(
 				end,
 				params.CompositeQuery.PanelType,
 				builderQuery,
-				keys,
 				tracesV3.Options{GraphLimitQtype: constants.FirstQueryGraphLimit, PreferRPM: preferRPM},
 			)
 			if err != nil {
@@ -207,7 +205,6 @@ func (q *querier) runBuilderQuery(
 				end,
 				params.CompositeQuery.PanelType,
 				builderQuery,
-				keys,
 				tracesV3.Options{GraphLimitQtype: constants.SecondQueryGraphLimit, PreferRPM: preferRPM},
 			)
 			if err != nil {
@@ -221,7 +218,6 @@ func (q *querier) runBuilderQuery(
 				end,
 				params.CompositeQuery.PanelType,
 				builderQuery,
-				keys,
 				tracesV3.Options{PreferRPM: preferRPM},
 			)
 			if err != nil {
diff --git a/pkg/query-service/app/querier/v2/querier.go b/pkg/query-service/app/querier/v2/querier.go
index b6d92faa44..7dae7f659f 100644
--- a/pkg/query-service/app/querier/v2/querier.go
+++ b/pkg/query-service/app/querier/v2/querier.go
@@ -312,7 +312,7 @@ func mergeSerieses(cachedSeries, missedSeries []*v3.Series) []*v3.Series {
 	return mergedSeries
 }
 
-func (q *querier) runBuilderQueries(ctx context.Context, params *v3.QueryRangeParamsV3, keys map[string]v3.AttributeKey) ([]*v3.Result, map[string]error, error) {
+func (q *querier) runBuilderQueries(ctx context.Context, params *v3.QueryRangeParamsV3) ([]*v3.Result, map[string]error, error) {
 
 	cacheKeys := q.keyGenerator.GenerateKeys(params)
 
@@ -322,7 +322,7 @@ func (q *querier) runBuilderQueries(ctx context.Context, params *v3.QueryRangePa
 	for queryName, builderQuery := range params.CompositeQuery.BuilderQueries {
 		if queryName == builderQuery.Expression {
 			wg.Add(1)
-			go q.runBuilderQuery(ctx, builderQuery, params, keys, cacheKeys, ch, &wg)
+			go q.runBuilderQuery(ctx, builderQuery, params, cacheKeys, ch, &wg)
 		}
 	}
 
@@ -479,7 +479,7 @@ func (q *querier) runClickHouseQueries(ctx context.Context, params *v3.QueryRang
 	return results, errQueriesByName, err
 }
 
-func (q *querier) runLogsListQuery(ctx context.Context, params *v3.QueryRangeParamsV3, keys map[string]v3.AttributeKey, tsRanges []utils.LogsListTsRange) ([]*v3.Result, map[string]error, error) {
+func (q *querier) runLogsListQuery(ctx context.Context, params *v3.QueryRangeParamsV3, tsRanges []utils.LogsListTsRange) ([]*v3.Result, map[string]error, error) {
 	res := make([]*v3.Result, 0)
 	qName := ""
 	pageSize := uint64(0)
@@ -496,7 +496,7 @@ func (q *querier) runLogsListQuery(ctx context.Context, params *v3.QueryRangePar
 		params.End = v.End
 
 		params.CompositeQuery.BuilderQueries[qName].PageSize = pageSize - uint64(len(data))
-		queries, err := q.builder.PrepareQueries(params, keys)
+		queries, err := q.builder.PrepareQueries(params)
 		if err != nil {
 			return nil, nil, err
 		}
@@ -538,7 +538,7 @@ func (q *querier) runLogsListQuery(ctx context.Context, params *v3.QueryRangePar
 	return res, nil, nil
 }
 
-func (q *querier) runBuilderListQueries(ctx context.Context, params *v3.QueryRangeParamsV3, keys map[string]v3.AttributeKey) ([]*v3.Result, map[string]error, error) {
+func (q *querier) runBuilderListQueries(ctx context.Context, params *v3.QueryRangeParamsV3) ([]*v3.Result, map[string]error, error) {
 	// List query has support for only one query.
 	if q.UseLogsNewSchema && params.CompositeQuery != nil && len(params.CompositeQuery.BuilderQueries) == 1 {
 		for _, v := range params.CompositeQuery.BuilderQueries {
@@ -546,13 +546,13 @@ func (q *querier) runBuilderListQueries(ctx context.Context, params *v3.QueryRan
 			if v.DataSource == v3.DataSourceLogs && len(v.OrderBy) == 1 && v.OrderBy[0].ColumnName == "timestamp" && v.OrderBy[0].Order == "desc" {
 				startEndArr := utils.GetLogsListTsRanges(params.Start, params.End)
 				if len(startEndArr) > 0 {
-					return q.runLogsListQuery(ctx, params, keys, startEndArr)
+					return q.runLogsListQuery(ctx, params, startEndArr)
 				}
 			}
 		}
 	}
 
-	queries, err := q.builder.PrepareQueries(params, keys)
+	queries, err := q.builder.PrepareQueries(params)
 
 	if err != nil {
 		return nil, nil, err
@@ -601,7 +601,7 @@ func (q *querier) runBuilderListQueries(ctx context.Context, params *v3.QueryRan
 
 // QueryRange is the main function that runs the queries
 // and returns the results
-func (q *querier) QueryRange(ctx context.Context, params *v3.QueryRangeParamsV3, keys map[string]v3.AttributeKey) ([]*v3.Result, map[string]error, error) {
+func (q *querier) QueryRange(ctx context.Context, params *v3.QueryRangeParamsV3) ([]*v3.Result, map[string]error, error) {
 	var results []*v3.Result
 	var err error
 	var errQueriesByName map[string]error
@@ -609,9 +609,9 @@ func (q *querier) QueryRange(ctx context.Context, params *v3.QueryRangeParamsV3,
 		switch params.CompositeQuery.QueryType {
 		case v3.QueryTypeBuilder:
 			if params.CompositeQuery.PanelType == v3.PanelTypeList || params.CompositeQuery.PanelType == v3.PanelTypeTrace {
-				results, errQueriesByName, err = q.runBuilderListQueries(ctx, params, keys)
+				results, errQueriesByName, err = q.runBuilderListQueries(ctx, params)
 			} else {
-				results, errQueriesByName, err = q.runBuilderQueries(ctx, params, keys)
+				results, errQueriesByName, err = q.runBuilderQueries(ctx, params)
 			}
 			// in builder query, the only errors we expose are the ones that exceed the resource limits
 			// everything else is internal error as they are not actionable by the user
diff --git a/pkg/query-service/app/querier/v2/querier_test.go b/pkg/query-service/app/querier/v2/querier_test.go
index 5707e9f70d..c65b6ff54a 100644
--- a/pkg/query-service/app/querier/v2/querier_test.go
+++ b/pkg/query-service/app/querier/v2/querier_test.go
@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"go.signoz.io/signoz/pkg/query-service/app/queryBuilder"
+	tracesV3 "go.signoz.io/signoz/pkg/query-service/app/traces/v3"
 	"go.signoz.io/signoz/pkg/query-service/cache/inmemory"
 	v3 "go.signoz.io/signoz/pkg/query-service/model/v3"
 )
@@ -593,7 +594,8 @@ func TestV2QueryRangePanelGraph(t *testing.T) {
 	}
 
 	for i, param := range params {
-		_, errByName, err := q.QueryRange(context.Background(), param, nil)
+		tracesV3.Enrich(param, map[string]v3.AttributeKey{})
+		_, errByName, err := q.QueryRange(context.Background(), param)
 		if err != nil {
 			t.Errorf("expected no error, got %s", err)
 		}
@@ -738,7 +740,8 @@ func TestV2QueryRangeValueType(t *testing.T) {
 	}
 
 	for i, param := range params {
-		_, errByName, err := q.QueryRange(context.Background(), param, nil)
+		tracesV3.Enrich(param, map[string]v3.AttributeKey{})
+		_, errByName, err := q.QueryRange(context.Background(), param)
 		if err != nil {
 			t.Errorf("expected no error, got %s", err)
 		}
@@ -792,7 +795,8 @@ func TestV2QueryRangeTimeShift(t *testing.T) {
 	expectedTimeRangeInQueryString := fmt.Sprintf("timestamp >= %d AND timestamp <= %d", (1675115596722-86400*1000)*1000000, ((1675115596722+120*60*1000)-86400*1000)*1000000)
 
 	for i, param := range params {
-		_, errByName, err := q.QueryRange(context.Background(), param, nil)
+		tracesV3.Enrich(param, map[string]v3.AttributeKey{})
+		_, errByName, err := q.QueryRange(context.Background(), param)
 		if err != nil {
 			t.Errorf("expected no error, got %s", err)
 		}
@@ -892,7 +896,8 @@ func TestV2QueryRangeTimeShiftWithCache(t *testing.T) {
 	}
 
 	for i, param := range params {
-		_, errByName, err := q.QueryRange(context.Background(), param, nil)
+		tracesV3.Enrich(param, map[string]v3.AttributeKey{})
+		_, errByName, err := q.QueryRange(context.Background(), param)
 		if err != nil {
 			t.Errorf("expected no error, got %s", err)
 		}
@@ -994,7 +999,8 @@ func TestV2QueryRangeTimeShiftWithLimitAndCache(t *testing.T) {
 	}
 
 	for i, param := range params {
-		_, errByName, err := q.QueryRange(context.Background(), param, nil)
+		tracesV3.Enrich(param, map[string]v3.AttributeKey{})
+		_, errByName, err := q.QueryRange(context.Background(), param)
 		if err != nil {
 			t.Errorf("expected no error, got %s", err)
 		}
@@ -1085,7 +1091,8 @@ func TestV2QueryRangeValueTypePromQL(t *testing.T) {
 	}
 
 	for i, param := range params {
-		_, errByName, err := q.QueryRange(context.Background(), param, nil)
+		tracesV3.Enrich(param, map[string]v3.AttributeKey{})
+		_, errByName, err := q.QueryRange(context.Background(), param)
 		if err != nil {
 			t.Errorf("expected no error, got %s", err)
 		}
diff --git a/pkg/query-service/app/queryBuilder/query_builder.go b/pkg/query-service/app/queryBuilder/query_builder.go
index 7ddd3c114d..8e8b79572f 100644
--- a/pkg/query-service/app/queryBuilder/query_builder.go
+++ b/pkg/query-service/app/queryBuilder/query_builder.go
@@ -43,7 +43,7 @@ var SupportedFunctions = []string{
 
 var EvalFuncs = map[string]govaluate.ExpressionFunction{}
 
-type prepareTracesQueryFunc func(start, end int64, panelType v3.PanelType, bq *v3.BuilderQuery, keys map[string]v3.AttributeKey, options tracesV3.Options) (string, error)
+type prepareTracesQueryFunc func(start, end int64, panelType v3.PanelType, bq *v3.BuilderQuery, options tracesV3.Options) (string, error)
 type prepareLogsQueryFunc func(start, end int64, queryType v3.QueryType, panelType v3.PanelType, bq *v3.BuilderQuery, options logsV3.Options) (string, error)
 type prepareMetricQueryFunc func(start, end int64, queryType v3.QueryType, panelType v3.PanelType, bq *v3.BuilderQuery, options metricsV3.Options) (string, error)
 
@@ -173,7 +173,7 @@ func (qb *QueryBuilder) PrepareLiveTailQuery(params *v3.QueryRangeParamsV3) (str
 	return queryStr, nil
 }
 
-func (qb *QueryBuilder) PrepareQueries(params *v3.QueryRangeParamsV3, args ...interface{}) (map[string]string, error) {
+func (qb *QueryBuilder) PrepareQueries(params *v3.QueryRangeParamsV3) (map[string]string, error) {
 	queries := make(map[string]string)
 
 	compositeQuery := params.CompositeQuery
@@ -193,19 +193,15 @@ func (qb *QueryBuilder) PrepareQueries(params *v3.QueryRangeParamsV3, args ...in
 			if query.Expression == queryName {
 				switch query.DataSource {
 				case v3.DataSourceTraces:
-					keys := map[string]v3.AttributeKey{}
-					if len(args) > 0 {
-						keys = args[0].(map[string]v3.AttributeKey)
-					}
 					// for ts query with group by and limit form two queries
 					if compositeQuery.PanelType == v3.PanelTypeGraph && query.Limit > 0 && len(query.GroupBy) > 0 {
 						limitQuery, err := qb.options.BuildTraceQuery(start, end, compositeQuery.PanelType, query,
-							keys, tracesV3.Options{GraphLimitQtype: constants.FirstQueryGraphLimit, PreferRPM: PreferRPMFeatureEnabled})
+							tracesV3.Options{GraphLimitQtype: constants.FirstQueryGraphLimit, PreferRPM: PreferRPMFeatureEnabled})
 						if err != nil {
 							return nil, err
 						}
 						placeholderQuery, err := qb.options.BuildTraceQuery(start, end, compositeQuery.PanelType,
-							query, keys, tracesV3.Options{GraphLimitQtype: constants.SecondQueryGraphLimit, PreferRPM: PreferRPMFeatureEnabled})
+							query, tracesV3.Options{GraphLimitQtype: constants.SecondQueryGraphLimit, PreferRPM: PreferRPMFeatureEnabled})
 						if err != nil {
 							return nil, err
 						}
@@ -213,7 +209,7 @@ func (qb *QueryBuilder) PrepareQueries(params *v3.QueryRangeParamsV3, args ...in
 						queries[queryName] = query
 					} else {
 						queryString, err := qb.options.BuildTraceQuery(start, end, compositeQuery.PanelType,
-							query, keys, tracesV3.Options{PreferRPM: PreferRPMFeatureEnabled, GraphLimitQtype: ""})
+							query, tracesV3.Options{PreferRPM: PreferRPMFeatureEnabled, GraphLimitQtype: ""})
 						if err != nil {
 							return nil, err
 						}
diff --git a/pkg/query-service/app/server.go b/pkg/query-service/app/server.go
index a1fc0dd329..22d52b9884 100644
--- a/pkg/query-service/app/server.go
+++ b/pkg/query-service/app/server.go
@@ -710,7 +710,7 @@ func (s *Server) Stop() error {
 }
 
 func makeRulesManager(
-	promConfigPath,
+	_,
 	alertManagerURL string,
 	ruleRepoURL string,
 	db *sqlx.DB,
diff --git a/pkg/query-service/app/traces/v3/query_builder.go b/pkg/query-service/app/traces/v3/query_builder.go
index 41f64548ad..4f1ad86f23 100644
--- a/pkg/query-service/app/traces/v3/query_builder.go
+++ b/pkg/query-service/app/traces/v3/query_builder.go
@@ -58,8 +58,7 @@ var tracesOperatorMappingV3 = map[v3.FilterOperator]string{
 	v3.FilterOperatorNotExists:       "NOT has(%s%s, '%s')",
 }
 
-func getColumnName(key v3.AttributeKey, keys map[string]v3.AttributeKey) string {
-	key = enrichKeyWithMetadata(key, keys)
+func getColumnName(key v3.AttributeKey) string {
 	if key.IsColumn {
 		return key.Key
 	}
@@ -102,13 +101,13 @@ func enrichKeyWithMetadata(key v3.AttributeKey, keys map[string]v3.AttributeKey)
 }
 
 // getSelectLabels returns the select labels for the query based on groupBy and aggregateOperator
-func getSelectLabels(aggregatorOperator v3.AggregateOperator, groupBy []v3.AttributeKey, keys map[string]v3.AttributeKey) string {
+func getSelectLabels(aggregatorOperator v3.AggregateOperator, groupBy []v3.AttributeKey) string {
 	var selectLabels string
 	if aggregatorOperator == v3.AggregateOperatorNoOp {
 		selectLabels = ""
 	} else {
 		for _, tag := range groupBy {
-			filterName := getColumnName(tag, keys)
+			filterName := getColumnName(tag)
 			selectLabels += fmt.Sprintf(" %s as `%s`,", filterName, tag.Key)
 		}
 	}
@@ -127,10 +126,10 @@ func getSelectKeys(aggregatorOperator v3.AggregateOperator, groupBy []v3.Attribu
 	return strings.Join(selectLabels, ",")
 }
 
-func getSelectColumns(sc []v3.AttributeKey, keys map[string]v3.AttributeKey) string {
+func getSelectColumns(sc []v3.AttributeKey) string {
 	var columns []string
 	for _, tag := range sc {
-		columnName := getColumnName(tag, keys)
+		columnName := getColumnName(tag)
 		columns = append(columns, fmt.Sprintf("%s as `%s` ", columnName, tag.Key))
 	}
 	return strings.Join(columns, ",")
@@ -150,20 +149,19 @@ func getZerosForEpochNano(epoch int64) int64 {
 	return int64(math.Pow(10, float64(19-count)))
 }
 
-func buildTracesFilterQuery(fs *v3.FilterSet, keys map[string]v3.AttributeKey) (string, error) {
+func buildTracesFilterQuery(fs *v3.FilterSet) (string, error) {
 	var conditions []string
 
 	if fs != nil && len(fs.Items) != 0 {
 		for _, item := range fs.Items {
 			val := item.Value
 			// generate the key
-			columnName := getColumnName(item.Key, keys)
+			columnName := getColumnName(item.Key)
 			var fmtVal string
-			key := enrichKeyWithMetadata(item.Key, keys)
 			item.Operator = v3.FilterOperator(strings.ToLower(strings.TrimSpace(string(item.Operator))))
 			if item.Operator != v3.FilterOperatorExists && item.Operator != v3.FilterOperatorNotExists {
 				var err error
-				val, err = utils.ValidateAndCastValue(val, key.DataType)
+				val, err = utils.ValidateAndCastValue(val, item.Key.DataType)
 				if err != nil {
 					return "", fmt.Errorf("invalid value for key %s: %v", item.Key.Key, err)
 				}
@@ -179,15 +177,15 @@ func buildTracesFilterQuery(fs *v3.FilterSet, keys map[string]v3.AttributeKey) (
 				case v3.FilterOperatorRegex, v3.FilterOperatorNotRegex:
 					conditions = append(conditions, fmt.Sprintf(operator, columnName, fmtVal))
 				case v3.FilterOperatorExists, v3.FilterOperatorNotExists:
-					if key.IsColumn {
-						subQuery, err := existsSubQueryForFixedColumn(key, item.Operator)
+					if item.Key.IsColumn {
+						subQuery, err := existsSubQueryForFixedColumn(item.Key, item.Operator)
 						if err != nil {
 							return "", err
 						}
 						conditions = append(conditions, subQuery)
 					} else {
-						columnType, columnDataType := getClickhouseTracesColumnDataTypeAndType(key)
-						conditions = append(conditions, fmt.Sprintf(operator, columnDataType, columnType, key.Key))
+						columnType, columnDataType := getClickhouseTracesColumnDataTypeAndType(item.Key)
+						conditions = append(conditions, fmt.Sprintf(operator, columnDataType, columnType, item.Key.Key))
 					}
 
 				default:
@@ -218,12 +216,11 @@ func existsSubQueryForFixedColumn(key v3.AttributeKey, op v3.FilterOperator) (st
 	}
 }
 
-func handleEmptyValuesInGroupBy(keys map[string]v3.AttributeKey, groupBy []v3.AttributeKey) (string, error) {
+func handleEmptyValuesInGroupBy(groupBy []v3.AttributeKey) (string, error) {
 	filterItems := []v3.FilterItem{}
 	if len(groupBy) != 0 {
 		for _, item := range groupBy {
-			key := enrichKeyWithMetadata(item, keys)
-			if !key.IsColumn {
+			if !item.IsColumn {
 				filterItems = append(filterItems, v3.FilterItem{
 					Key:      item,
 					Operator: v3.FilterOperatorExists,
@@ -236,21 +233,21 @@ func handleEmptyValuesInGroupBy(keys map[string]v3.AttributeKey, groupBy []v3.At
 			Operator: "AND",
 			Items:    filterItems,
 		}
-		return buildTracesFilterQuery(&filterSet, keys)
+		return buildTracesFilterQuery(&filterSet)
 	}
 	return "", nil
 }
 
-func buildTracesQuery(start, end, step int64, mq *v3.BuilderQuery, tableName string, keys map[string]v3.AttributeKey, panelType v3.PanelType, options Options) (string, error) {
+func buildTracesQuery(start, end, step int64, mq *v3.BuilderQuery, _ string, panelType v3.PanelType, options Options) (string, error) {
 
-	filterSubQuery, err := buildTracesFilterQuery(mq.Filters, keys)
+	filterSubQuery, err := buildTracesFilterQuery(mq.Filters)
 	if err != nil {
 		return "", err
 	}
 	// timerange will be sent in epoch millisecond
 	spanIndexTableTimeFilter := fmt.Sprintf("(timestamp >= '%d' AND timestamp <= '%d')", start*getZerosForEpochNano(start), end*getZerosForEpochNano(end))
 
-	selectLabels := getSelectLabels(mq.AggregateOperator, mq.GroupBy, keys)
+	selectLabels := getSelectLabels(mq.AggregateOperator, mq.GroupBy)
 
 	having := having(mq.Having)
 	if having != "" {
@@ -283,7 +280,7 @@ func buildTracesQuery(start, end, step int64, mq *v3.BuilderQuery, tableName str
 		queryTmpl = "SELECT " + getSelectKeys(mq.AggregateOperator, mq.GroupBy) + " from (" + queryTmpl + ")"
 	}
 
-	emptyValuesInGroupByFilter, err := handleEmptyValuesInGroupBy(keys, mq.GroupBy)
+	emptyValuesInGroupByFilter, err := handleEmptyValuesInGroupBy(mq.GroupBy)
 	if err != nil {
 		return "", err
 	}
@@ -293,8 +290,7 @@ func buildTracesQuery(start, end, step int64, mq *v3.BuilderQuery, tableName str
 	if groupBy != "" {
 		groupBy = " group by " + groupBy
 	}
-	enrichedOrderBy := enrichOrderBy(mq.OrderBy, keys)
-	orderBy := orderByAttributeKeyTags(panelType, enrichedOrderBy, mq.GroupBy, keys)
+	orderBy := orderByAttributeKeyTags(panelType, mq.OrderBy, mq.GroupBy)
 	if orderBy != "" {
 		orderBy = " order by " + orderBy
 	}
@@ -305,7 +301,7 @@ func buildTracesQuery(start, end, step int64, mq *v3.BuilderQuery, tableName str
 
 	aggregationKey := ""
 	if mq.AggregateAttribute.Key != "" {
-		aggregationKey = getColumnName(mq.AggregateAttribute, keys)
+		aggregationKey = getColumnName(mq.AggregateAttribute)
 	}
 
 	switch mq.AggregateOperator {
@@ -342,14 +338,13 @@ func buildTracesQuery(start, end, step int64, mq *v3.BuilderQuery, tableName str
 		return query, nil
 	case v3.AggregateOperatorCount:
 		if mq.AggregateAttribute.Key != "" {
-			key := enrichKeyWithMetadata(mq.AggregateAttribute, keys)
-			if key.IsColumn {
-				subQuery, err := existsSubQueryForFixedColumn(key, v3.FilterOperatorExists)
+			if mq.AggregateAttribute.IsColumn {
+				subQuery, err := existsSubQueryForFixedColumn(mq.AggregateAttribute, v3.FilterOperatorExists)
 				if err == nil {
 					filterSubQuery = fmt.Sprintf("%s AND %s", filterSubQuery, subQuery)
 				}
 			} else {
-				columnType, columnDataType := getClickhouseTracesColumnDataTypeAndType(key)
+				columnType, columnDataType := getClickhouseTracesColumnDataTypeAndType(mq.AggregateAttribute)
 				filterSubQuery = fmt.Sprintf("%s AND has(%s%s, '%s')", filterSubQuery, columnDataType, columnType, mq.AggregateAttribute.Key)
 			}
 		}
@@ -373,7 +368,7 @@ func buildTracesQuery(start, end, step int64, mq *v3.BuilderQuery, tableName str
 			if len(mq.SelectColumns) == 0 {
 				return "", fmt.Errorf("select columns cannot be empty for panelType %s", panelType)
 			}
-			selectColumns := getSelectColumns(mq.SelectColumns, keys)
+			selectColumns := getSelectColumns(mq.SelectColumns)
 			queryNoOpTmpl := fmt.Sprintf("SELECT timestamp as timestamp_datetime, spanID, traceID, "+"%s ", selectColumns) + "from " + constants.SIGNOZ_TRACE_DBNAME + "." + constants.SIGNOZ_SPAN_INDEX_TABLENAME + " where %s %s" + "%s"
 			query = fmt.Sprintf(queryNoOpTmpl, spanIndexTableTimeFilter, filterSubQuery, orderBy)
 		} else {
@@ -423,7 +418,7 @@ func groupByAttributeKeyTags(panelType v3.PanelType, graphLimitQtype string, tag
 // orderBy returns a string of comma separated tags for order by clause
 // if there are remaining items which are not present in tags they are also added
 // if the order is not specified, it defaults to ASC
-func orderBy(panelType v3.PanelType, items []v3.OrderBy, tagLookup map[string]struct{}, keys map[string]v3.AttributeKey) []string {
+func orderBy(panelType v3.PanelType, items []v3.OrderBy, tagLookup map[string]struct{}) []string {
 	var orderBy []string
 
 	for _, item := range items {
@@ -433,7 +428,7 @@ func orderBy(panelType v3.PanelType, items []v3.OrderBy, tagLookup map[string]st
 			orderBy = append(orderBy, fmt.Sprintf("`%s` %s", item.ColumnName, item.Order))
 		} else if panelType == v3.PanelTypeList {
 			attr := v3.AttributeKey{Key: item.ColumnName, DataType: item.DataType, Type: item.Type, IsColumn: item.IsColumn}
-			name := getColumnName(attr, keys)
+			name := getColumnName(attr)
 			if item.IsColumn {
 				orderBy = append(orderBy, fmt.Sprintf("`%s` %s", name, item.Order))
 			} else {
@@ -445,13 +440,13 @@ func orderBy(panelType v3.PanelType, items []v3.OrderBy, tagLookup map[string]st
 	return orderBy
 }
 
-func orderByAttributeKeyTags(panelType v3.PanelType, items []v3.OrderBy, tags []v3.AttributeKey, keys map[string]v3.AttributeKey) string {
+func orderByAttributeKeyTags(panelType v3.PanelType, items []v3.OrderBy, tags []v3.AttributeKey) string {
 	tagLookup := map[string]struct{}{}
 	for _, v := range tags {
 		tagLookup[v.Key] = struct{}{}
 	}
 
-	orderByArray := orderBy(panelType, items, tagLookup, keys)
+	orderByArray := orderBy(panelType, items, tagLookup)
 
 	if len(orderByArray) == 0 {
 		if panelType == v3.PanelTypeList {
@@ -474,7 +469,7 @@ func having(items []v3.Having) string {
 	return strings.Join(having, " AND ")
 }
 
-func reduceToQuery(query string, reduceTo v3.ReduceToOperator, aggregateOperator v3.AggregateOperator) (string, error) {
+func reduceToQuery(query string, reduceTo v3.ReduceToOperator, _ v3.AggregateOperator) (string, error) {
 
 	var groupBy string
 	switch reduceTo {
@@ -508,13 +503,13 @@ func addOffsetToQuery(query string, offset uint64) string {
 // PrepareTracesQuery returns the query string for traces
 // start and end are in epoch millisecond
 // step is in seconds
-func PrepareTracesQuery(start, end int64, panelType v3.PanelType, mq *v3.BuilderQuery, keys map[string]v3.AttributeKey, options Options) (string, error) {
+func PrepareTracesQuery(start, end int64, panelType v3.PanelType, mq *v3.BuilderQuery, options Options) (string, error) {
 	// adjust the start and end time to the step interval
 	start = start - (start % (mq.StepInterval * 1000))
 	end = end - (end % (mq.StepInterval * 1000))
 	if options.GraphLimitQtype == constants.FirstQueryGraphLimit {
 		// give me just the group by names
-		query, err := buildTracesQuery(start, end, mq.StepInterval, mq, constants.SIGNOZ_SPAN_INDEX_TABLENAME, keys, panelType, options)
+		query, err := buildTracesQuery(start, end, mq.StepInterval, mq, constants.SIGNOZ_SPAN_INDEX_TABLENAME, panelType, options)
 		if err != nil {
 			return "", err
 		}
@@ -522,14 +517,14 @@ func PrepareTracesQuery(start, end int64, panelType v3.PanelType, mq *v3.Builder
 
 		return query, nil
 	} else if options.GraphLimitQtype == constants.SecondQueryGraphLimit {
-		query, err := buildTracesQuery(start, end, mq.StepInterval, mq, constants.SIGNOZ_SPAN_INDEX_TABLENAME, keys, panelType, options)
+		query, err := buildTracesQuery(start, end, mq.StepInterval, mq, constants.SIGNOZ_SPAN_INDEX_TABLENAME, panelType, options)
 		if err != nil {
 			return "", err
 		}
 		return query, nil
 	}
 
-	query, err := buildTracesQuery(start, end, mq.StepInterval, mq, constants.SIGNOZ_SPAN_INDEX_TABLENAME, keys, panelType, options)
+	query, err := buildTracesQuery(start, end, mq.StepInterval, mq, constants.SIGNOZ_SPAN_INDEX_TABLENAME, panelType, options)
 	if err != nil {
 		return "", err
 	}
@@ -545,3 +540,30 @@ func PrepareTracesQuery(start, end int64, panelType v3.PanelType, mq *v3.Builder
 	}
 	return query, err
 }
+
+func Enrich(params *v3.QueryRangeParamsV3, keys map[string]v3.AttributeKey) {
+	if params.CompositeQuery.QueryType == v3.QueryTypeBuilder {
+		for _, query := range params.CompositeQuery.BuilderQueries {
+			if query.DataSource == v3.DataSourceTraces {
+				// enrich aggregate attribute
+				query.AggregateAttribute = enrichKeyWithMetadata(query.AggregateAttribute, keys)
+				// enrich filter items
+				if query.Filters != nil && len(query.Filters.Items) > 0 {
+					for idx, filter := range query.Filters.Items {
+						query.Filters.Items[idx].Key = enrichKeyWithMetadata(filter.Key, keys)
+					}
+				}
+				// enrich group by
+				for idx, groupBy := range query.GroupBy {
+					query.GroupBy[idx] = enrichKeyWithMetadata(groupBy, keys)
+				}
+				// enrich order by
+				query.OrderBy = enrichOrderBy(query.OrderBy, keys)
+				// enrich select columns
+				for idx, selectColumn := range query.SelectColumns {
+					query.SelectColumns[idx] = enrichKeyWithMetadata(selectColumn, keys)
+				}
+			}
+		}
+	}
+}
diff --git a/pkg/query-service/app/traces/v3/query_builder_test.go b/pkg/query-service/app/traces/v3/query_builder_test.go
index cf4eb21cfe..a1e7635a77 100644
--- a/pkg/query-service/app/traces/v3/query_builder_test.go
+++ b/pkg/query-service/app/traces/v3/query_builder_test.go
@@ -133,7 +133,7 @@ var buildFilterQueryData = []struct {
 func TestBuildTracesFilterQuery(t *testing.T) {
 	for _, tt := range buildFilterQueryData {
 		Convey("TestBuildTracesFilterQuery", t, func() {
-			query, err := buildTracesFilterQuery(tt.FilterSet, map[string]v3.AttributeKey{})
+			query, err := buildTracesFilterQuery(tt.FilterSet)
 			So(err, ShouldBeNil)
 			So(query, ShouldEqual, tt.ExpectedFilter)
 		})
@@ -169,7 +169,7 @@ var handleEmptyValuesInGroupByData = []struct {
 func TestBuildTracesHandleEmptyValuesInGroupBy(t *testing.T) {
 	for _, tt := range handleEmptyValuesInGroupByData {
 		Convey("TestBuildTracesHandleEmptyValuesInGroupBy", t, func() {
-			query, err := handleEmptyValuesInGroupBy(map[string]v3.AttributeKey{}, tt.GroupBy)
+			query, err := handleEmptyValuesInGroupBy(tt.GroupBy)
 			So(err, ShouldBeNil)
 			So(query, ShouldEqual, tt.ExpectedFilter)
 		})
@@ -220,8 +220,9 @@ var testColumnName = []struct {
 
 func TestColumnName(t *testing.T) {
 	for _, tt := range testColumnName {
+		tt.AttributeKey = enrichKeyWithMetadata(tt.AttributeKey, map[string]v3.AttributeKey{})
 		Convey("testColumnName", t, func() {
-			Column := getColumnName(tt.AttributeKey, map[string]v3.AttributeKey{})
+			Column := getColumnName(tt.AttributeKey)
 			So(Column, ShouldEqual, tt.ExpectedColumn)
 		})
 	}
@@ -265,7 +266,7 @@ var testGetSelectLabelsData = []struct {
 func TestGetSelectLabels(t *testing.T) {
 	for _, tt := range testGetSelectLabelsData {
 		Convey("testGetSelectLabelsData", t, func() {
-			selectLabels := getSelectLabels(tt.AggregateOperator, tt.GroupByTags, map[string]v3.AttributeKey{})
+			selectLabels := getSelectLabels(tt.AggregateOperator, tt.GroupByTags)
 			So(selectLabels, ShouldEqual, tt.SelectLabels)
 		})
 	}
@@ -304,7 +305,7 @@ var testGetSelectColumnsData = []struct {
 func TestGetSelectColumns(t *testing.T) {
 	for _, tt := range testGetSelectColumnsData {
 		Convey("testGetSelectColumnsData", t, func() {
-			selectColumns := getSelectColumns(tt.sc, map[string]v3.AttributeKey{})
+			selectColumns := getSelectColumns(tt.sc)
 			So(selectColumns, ShouldEqual, tt.SelectColumns)
 		})
 	}
@@ -464,13 +465,15 @@ var testOrderBy = []struct {
 }
 
 func TestOrderBy(t *testing.T) {
+	keys := map[string]v3.AttributeKey{
+		"name":          {Key: "name", DataType: v3.AttributeKeyDataTypeString, Type: v3.AttributeKeyTypeTag, IsColumn: true},
+		"bytes":         {Key: "bytes", DataType: v3.AttributeKeyDataTypeString, Type: v3.AttributeKeyTypeTag, IsColumn: true},
+		"response_time": {Key: "response_time", DataType: v3.AttributeKeyDataTypeString, Type: v3.AttributeKeyTypeTag, IsColumn: false},
+	}
 	for _, tt := range testOrderBy {
 		Convey("testOrderBy", t, func() {
-			res := orderByAttributeKeyTags(tt.PanelType, tt.Items, tt.Tags, map[string]v3.AttributeKey{
-				"name":          {Key: "name", DataType: v3.AttributeKeyDataTypeString, Type: v3.AttributeKeyTypeTag, IsColumn: true},
-				"bytes":         {Key: "bytes", DataType: v3.AttributeKeyDataTypeString, Type: v3.AttributeKeyTypeTag, IsColumn: true},
-				"response_time": {Key: "response_time", DataType: v3.AttributeKeyDataTypeString, Type: v3.AttributeKeyTypeTag, IsColumn: false},
-			})
+			tt.Items = enrichOrderBy(tt.Items, keys)
+			res := orderByAttributeKeyTags(tt.PanelType, tt.Items, tt.Tags)
 			So(res, ShouldResemble, tt.Result)
 		})
 	}
@@ -1171,11 +1174,24 @@ var testBuildTracesQueryData = []struct {
 }
 
 func TestBuildTracesQuery(t *testing.T) {
+	keys := map[string]v3.AttributeKey{
+		"name": {Key: "name", DataType: v3.AttributeKeyDataTypeString, Type: v3.AttributeKeyTypeTag, IsColumn: true},
+	}
+
 	for _, tt := range testBuildTracesQueryData {
+		tt.BuilderQuery.DataSource = v3.DataSourceTraces
+		params := &v3.QueryRangeParamsV3{
+			Version: "v4",
+			CompositeQuery: &v3.CompositeQuery{
+				QueryType: v3.QueryTypeBuilder,
+				BuilderQueries: map[string]*v3.BuilderQuery{
+					"A": tt.BuilderQuery,
+				},
+			},
+		}
+		Enrich(params, keys)
 		Convey("TestBuildTracesQuery", t, func() {
-			query, err := buildTracesQuery(tt.Start, tt.End, tt.BuilderQuery.StepInterval, tt.BuilderQuery, tt.TableName, map[string]v3.AttributeKey{
-				"name": {Key: "name", DataType: v3.AttributeKeyDataTypeString, Type: v3.AttributeKeyTypeTag, IsColumn: true},
-			}, tt.PanelType, tt.Options)
+			query, err := buildTracesQuery(tt.Start, tt.End, tt.BuilderQuery.StepInterval, tt.BuilderQuery, tt.TableName, tt.PanelType, tt.Options)
 			So(err, ShouldBeNil)
 			So(query, ShouldEqual, tt.ExpectedQuery)
 		})
@@ -1400,7 +1416,7 @@ var testPrepTracesQueryData = []struct {
 func TestPrepareTracesQuery(t *testing.T) {
 	for _, tt := range testPrepTracesQueryData {
 		Convey("TestPrepareTracesQuery", t, func() {
-			query, err := PrepareTracesQuery(tt.Start, tt.End, tt.PanelType, tt.BuilderQuery, tt.Keys, tt.Options)
+			query, err := PrepareTracesQuery(tt.Start, tt.End, tt.PanelType, tt.BuilderQuery, tt.Options)
 			So(err, ShouldBeNil)
 			So(query, ShouldEqual, tt.ExpectedQuery)
 		})
diff --git a/pkg/query-service/interfaces/interface.go b/pkg/query-service/interfaces/interface.go
index cfb4f9159e..e9e46254d2 100644
--- a/pkg/query-service/interfaces/interface.go
+++ b/pkg/query-service/interfaces/interface.go
@@ -126,7 +126,7 @@ type Reader interface {
 }
 
 type Querier interface {
-	QueryRange(context.Context, *v3.QueryRangeParamsV3, map[string]v3.AttributeKey) ([]*v3.Result, map[string]error, error)
+	QueryRange(context.Context, *v3.QueryRangeParamsV3) ([]*v3.Result, map[string]error, error)
 
 	// test helpers
 	QueriesExecuted() []string
diff --git a/pkg/query-service/rules/threshold_rule.go b/pkg/query-service/rules/threshold_rule.go
index 964774500e..01b6b1d2fd 100644
--- a/pkg/query-service/rules/threshold_rule.go
+++ b/pkg/query-service/rules/threshold_rule.go
@@ -504,9 +504,9 @@ func (r *ThresholdRule) buildAndRunQuery(ctx context.Context, ts time.Time) (Vec
 	var queryErrors map[string]error
 
 	if r.version == "v4" {
-		results, queryErrors, err = r.querierV2.QueryRange(ctx, params, map[string]v3.AttributeKey{})
+		results, queryErrors, err = r.querierV2.QueryRange(ctx, params)
 	} else {
-		results, queryErrors, err = r.querier.QueryRange(ctx, params, map[string]v3.AttributeKey{})
+		results, queryErrors, err = r.querier.QueryRange(ctx, params)
 	}
 
 	if err != nil {