MQE: Remove projections logic from ingesters, store-gateways (#15109)

Projections don't make sense as a way to reduce TCO. Remove the
projections fields from ingester and store-gateway request objects and
metrics for measuring their effect.

Part of #13863

Author: 56quarters

pkg/distributor/distributor_test.go

@@ -1143,7 +1143,7 @@ func TestDistributor_PushQuery(t *testing.T) {
 			assert.Nil(t, err)
 
 			queryMetrics := stats.NewQueryMetrics(reg[0])
-			resp, err := ds[0].QueryStream(ctx, queryMetrics, 0, 10, false, nil, tc.matchers...)
+			resp, err := ds[0].QueryStream(ctx, queryMetrics, 0, 10, tc.matchers...)
 
 			if tc.expectedError == nil {
 				require.NoError(t, err)
@@ -2589,7 +2589,7 @@ func TestSlowQueries(t *testing.T) {
 			})
 
 			queryMetrics := stats.NewQueryMetrics(reg[0])
-			_, err := ds[0].QueryStream(ctx, queryMetrics, 0, 10, false, nil, nameMatcher)
+			_, err := ds[0].QueryStream(ctx, queryMetrics, 0, 10, nameMatcher)
 			assert.Equal(t, expectedErr, err)
 		})
 	}

pkg/distributor/query.go

@@ -82,10 +82,10 @@ func (d *Distributor) QueryExemplars(ctx context.Context, from, to model.Time, m
 }
 
 // QueryStream queries multiple ingesters via the streaming interface and returns a big ol' set of chunks.
-func (d *Distributor) QueryStream(ctx context.Context, queryMetrics *stats.QueryMetrics, from, to model.Time, projectionInclude bool, projectionLabels []string, matchers ...*labels.Matcher) (ingester_client.CombinedQueryStreamResponse, error) {
+func (d *Distributor) QueryStream(ctx context.Context, queryMetrics *stats.QueryMetrics, from, to model.Time, matchers ...*labels.Matcher) (ingester_client.CombinedQueryStreamResponse, error) {
 	var result ingester_client.CombinedQueryStreamResponse
 	err := instrument.CollectedRequest(ctx, "Distributor.QueryStream", d.queryDuration, instrument.ErrorCode, func(ctx context.Context) error {
-		req, err := ingester_client.ToQueryRequest(from, to, projectionInclude, projectionLabels, matchers)
+		req, err := ingester_client.ToQueryRequest(from, to, matchers)
 		if err != nil {
 			return err
 		}

pkg/distributor/query_ingest_storage_test.go

@@ -523,7 +523,7 @@ func TestDistributor_QueryStream_ShouldSupportIngestStorage(t *testing.T) {
 
 			// Query ingesters.
 			queryMetrics := stats.NewQueryMetrics(distributorRegistries[0])
-			resp, err := distributors[0].QueryStream(ctx, queryMetrics, 0, 10, false, nil, testData.matchers...)
+			resp, err := distributors[0].QueryStream(ctx, queryMetrics, 0, 10, testData.matchers...)
 
 			if testData.expectedErr == nil {
 				require.NoError(t, err)
@@ -693,7 +693,7 @@ func TestDistributor_QueryStream_InactivePartitionsLookback(t *testing.T) {
 
 				// Query ingesters.
 				queryMetrics := stats.NewQueryMetrics(distributorRegistries[0])
-				resp, err := d.QueryStream(ctx, queryMetrics, 0, 10, false, nil, selectAllSeriesMatcher)
+				resp, err := d.QueryStream(ctx, queryMetrics, 0, 10, selectAllSeriesMatcher)
 
 				if scenario.expectQueryError {
 					require.Error(t, err)

pkg/distributor/query_test.go

@@ -237,7 +237,7 @@ func TestDistributor_QueryStream_ShouldReturnErrorIfMaxChunksPerQueryLimitIsReac
 
 					// Since the number of series (and thus chunks) is equal to the limit (but doesn't
 					// exceed it), we expect a query running on all series to succeed.
-					queryRes, err := ds[0].QueryStream(queryCtx, queryMetrics, math.MinInt32, math.MaxInt32, false, nil, allSeriesMatchers...)
+					queryRes, err := ds[0].QueryStream(queryCtx, queryMetrics, math.MinInt32, math.MaxInt32, allSeriesMatchers...)
 					require.NoError(t, err)
 
 					require.Len(t, queryRes.StreamingSeries, initialSeries)
@@ -265,7 +265,7 @@ func TestDistributor_QueryStream_ShouldReturnErrorIfMaxChunksPerQueryLimitIsReac
 
 					// Since the number of series (and thus chunks) is exceeding to the limit, we expect
 					// a query running on all series to fail.
-					_, err = ds[0].QueryStream(queryCtx, queryMetrics, math.MinInt32, math.MaxInt32, false, nil, allSeriesMatchers...)
+					_, err = ds[0].QueryStream(queryCtx, queryMetrics, math.MinInt32, math.MaxInt32, allSeriesMatchers...)
 					require.Error(t, err)
 					require.ErrorContains(t, err, testCase.expectedError)
 
@@ -319,7 +319,7 @@ func TestDistributor_QueryStream_ShouldReturnErrorIfMaxSeriesPerQueryLimitIsReac
 			// exceed it), we expect a query running on all series to succeed.
 			queryCtx := limiter.AddQueryLimiterToContext(userCtx, limiter.NewQueryLimiter(maxSeriesLimit, 0, 0, 0, stats.NewQueryMetrics(prometheus.NewPedanticRegistry())))
 			queryCtx = limiter.ContextWithNewUnlimitedMemoryConsumptionTracker(queryCtx)
-			queryRes, err := ds[0].QueryStream(queryCtx, queryMetrics, math.MinInt32, math.MaxInt32, false, nil, allSeriesMatchers...)
+			queryRes, err := ds[0].QueryStream(queryCtx, queryMetrics, math.MinInt32, math.MaxInt32, allSeriesMatchers...)
 			require.NoError(t, err)
 
 			assert.Len(t, queryRes.StreamingSeries, initialSeries)
@@ -342,7 +342,7 @@ func TestDistributor_QueryStream_ShouldReturnErrorIfMaxSeriesPerQueryLimitIsReac
 
 			// Since the number of series is exceeding the limit, we expect
 			// a query running on all series to fail.
-			_, err = ds[0].QueryStream(queryCtx, queryMetrics, math.MinInt32, math.MaxInt32, false, nil, allSeriesMatchers...)
+			_, err = ds[0].QueryStream(queryCtx, queryMetrics, math.MinInt32, math.MaxInt32, allSeriesMatchers...)
 			require.Error(t, err)
 			assert.ErrorContains(t, err, "the query exceeded the maximum number of series")
 
@@ -384,7 +384,7 @@ func TestDistributor_QueryStream_ShouldReturnErrorIfMaxChunkBytesPerQueryLimitIs
 	assert.Nil(t, err)
 
 	queryMetrics := stats.NewQueryMetrics(reg[0])
-	chunkSizeResponse, err := ds[0].QueryStream(ctx, queryMetrics, math.MinInt32, math.MaxInt32, false, nil, allSeriesMatchers...)
+	chunkSizeResponse, err := ds[0].QueryStream(ctx, queryMetrics, math.MinInt32, math.MaxInt32, allSeriesMatchers...)
 	require.NoError(t, err)
 
 	_, responseChunkSize, err := countStreamingChunksAndBytes(chunkSizeResponse)
@@ -404,7 +404,7 @@ func TestDistributor_QueryStream_ShouldReturnErrorIfMaxChunkBytesPerQueryLimitIs
 
 	// Since the number of chunk bytes is equal to the limit (but doesn't
 	// exceed it), we expect a query running on all series to succeed.
-	queryRes, err := ds[0].QueryStream(ctx, queryMetrics, math.MinInt32, math.MaxInt32, false, nil, allSeriesMatchers...)
+	queryRes, err := ds[0].QueryStream(ctx, queryMetrics, math.MinInt32, math.MaxInt32, allSeriesMatchers...)
 	require.NoError(t, err)
 	assert.Len(t, queryRes.StreamingSeries, seriesToAdd)
 
@@ -418,7 +418,7 @@ func TestDistributor_QueryStream_ShouldReturnErrorIfMaxChunkBytesPerQueryLimitIs
 	// Since the aggregated chunk size is exceeding the limit, we expect
 	// a query running on all series to fail but only when the chunks are
 	// actually consumed from the stream.
-	finalResp, err := ds[0].QueryStream(ctx, queryMetrics, math.MinInt32, math.MaxInt32, false, nil, allSeriesMatchers...)
+	finalResp, err := ds[0].QueryStream(ctx, queryMetrics, math.MinInt32, math.MaxInt32, allSeriesMatchers...)
 	require.NoError(t, err)
 
 	_, _, err = countStreamingChunksAndBytes(finalResp)
@@ -491,7 +491,7 @@ func TestDistributor_QueryStream_ShouldSuccessfullyRunOnSlowIngesterWithStreamin
 				t.Run(fmt.Sprintf("Query #%d", i), func(t *testing.T) {
 					t.Parallel()
 
-					res, err := distributors[0].QueryStream(ctx, queryMetrics, math.MinInt32, math.MaxInt32, false, nil, matchers)
+					res, err := distributors[0].QueryStream(ctx, queryMetrics, math.MinInt32, math.MaxInt32, matchers)
 					require.NoError(t, err)
 					require.Equal(t, numSeries, len(res.StreamingSeries))
 

pkg/ingester/client/compat.go

@@ -16,18 +16,16 @@ import (
 )
 
 // ToQueryRequest builds a QueryRequest proto.
-func ToQueryRequest(from, to model.Time, projectionInclude bool, projectionLabels []string, matchers []*labels.Matcher) (*QueryRequest, error) {
+func ToQueryRequest(from, to model.Time, matchers []*labels.Matcher) (*QueryRequest, error) {
 	ms, err := ToLabelMatchers(matchers)
 	if err != nil {
 		return nil, err
 	}
 
 	return &QueryRequest{
-		StartTimestampMs:  int64(from),
-		EndTimestampMs:    int64(to),
-		Matchers:          ms,
-		ProjectionInclude: projectionInclude,
-		ProjectionLabels:  projectionLabels,
+		StartTimestampMs: int64(from),
+		EndTimestampMs:   int64(to),
+		Matchers:         ms,
 	}, nil
 }
 

pkg/ingester/client/compat_test.go

@@ -43,7 +43,7 @@ func TestQueryRequest(t *testing.T) {
 	}
 	matchers = append(matchers, matcher4)
 
-	req, err := ToQueryRequest(from, to, false, nil, matchers)
+	req, err := ToQueryRequest(from, to, matchers)
 	if err != nil {
 		t.Fatal(err)
 	}