pr feedback

Signed-off-by: Owen Diehl <ow.diehl@gmail.com>

pkg/logql/shards.go

@@ -204,13 +204,10 @@ func (s Shard) Ptr() *Shard {
 }
 
 func (s Shard) Bind(chunks *logproto.ChunkRefGroup) *ShardWithChunkRefs {
-	res := &ShardWithChunkRefs{
-		Shard: s,
+	return &ShardWithChunkRefs{
+		Shard:  s,
+		chunks: chunks,
 	}
-	if chunks != nil {
-		res.chunks = chunks
-	}
-	return res
 }
 
 func NewBoundedShard(shard logproto.Shard) Shard {

pkg/querier/multi_tenant_querier.go

@@ -70,7 +70,7 @@ func (q *MultiTenantQuerier) SelectLogs(ctx context.Context, params logql.Select
 	// in case of multiple tenants, we need to filter the store chunks by tenant if they are provided
 	storeOverridesByTenant := make(map[string][]*logproto.ChunkRef)
 	if overrides := params.GetStoreChunks(); overrides != nil {
-		storeOverridesByTenant = partitionChunkRefsByTenant(params.GetStoreChunks().Refs)
+		storeOverridesByTenant = partitionChunkRefsByTenant(overrides.Refs)
 	}
 
 	iters := make([]iter.EntryIterator, len(matchedTenants))

pkg/querier/queryrange/codec.go

@@ -331,14 +331,14 @@ func (Codec) DecodeRequest(_ context.Context, r *http.Request, _ []string) (quer
 
 	switch op := getOperation(r.URL.Path); op {
 	case QueryRangeOp:
-		req, err := parseRangeQueryWithStoreChunksExtension(r)
+		req, err := parseRangeQuery(r)
 		if err != nil {
 			return nil, httpgrpc.Errorf(http.StatusBadRequest, err.Error())
 		}
 
 		return req, nil
 	case InstantQueryOp:
-		req, err := parseInstantQueryWithStoreChunksExtension(r)
+		req, err := parseInstantQuery(r)
 		if err != nil {
 			return nil, httpgrpc.Errorf(http.StatusBadRequest, err.Error())
 		}
@@ -513,14 +513,14 @@ func (Codec) DecodeHTTPGrpcRequest(ctx context.Context, r *httpgrpc.HTTPRequest)
 
 	switch op := getOperation(httpReq.URL.Path); op {
 	case QueryRangeOp:
-		req, err := parseRangeQueryWithStoreChunksExtension(httpReq)
+		req, err := parseRangeQuery(httpReq)
 		if err != nil {
 			return nil, ctx, httpgrpc.Errorf(http.StatusBadRequest, err.Error())
 		}
 
 		return req, ctx, nil
 	case InstantQueryOp:
-		req, err := parseInstantQueryWithStoreChunksExtension(httpReq)
+		req, err := parseInstantQuery(httpReq)
 		if err != nil {
 			return nil, ctx, httpgrpc.Errorf(http.StatusBadRequest, err.Error())
 		}
@@ -2086,7 +2086,7 @@ func mergeLokiResponse(responses ...queryrangebase.Response) *LokiResponse {
 	}
 }
 
-func parseRangeQueryWithStoreChunksExtension(r *http.Request) (*LokiRequest, error) {
+func parseRangeQuery(r *http.Request) (*LokiRequest, error) {
 	rangeQuery, err := loghttp.ParseRangeQuery(r)
 	if err != nil {
 		return nil, err
@@ -2119,7 +2119,7 @@ func parseRangeQueryWithStoreChunksExtension(r *http.Request) (*LokiRequest, err
 	}, nil
 }
 
-func parseInstantQueryWithStoreChunksExtension(r *http.Request) (*LokiInstantRequest, error) {
+func parseInstantQuery(r *http.Request) (*LokiInstantRequest, error) {
 	req, err := loghttp.ParseInstantQuery(r)
 	if err != nil {
 		return nil, err

pkg/querier/queryrange/shard_resolver.go

@@ -3,7 +3,6 @@ package queryrange
 import (
 	"context"
 	"fmt"
-	"net/http"
 	strings "strings"
 	"time"
 
@@ -12,7 +11,6 @@ import (
 	"github.com/go-kit/log"
 	"github.com/go-kit/log/level"
 	"github.com/grafana/dskit/concurrency"
-	"github.com/grafana/dskit/httpgrpc"
 	"github.com/grafana/dskit/tenant"
 	"github.com/opentracing/opentracing-go"
 	"github.com/prometheus/common/model"
@@ -264,24 +262,7 @@ func (r *dynamicShardResolver) ShardingRanges(expr syntax.Expr, targetBytesPerSh
 	})
 
 	if err != nil {
-		// check unimplemented to fallback
-		// TODO(owen-d): fix if this isn't right
-		if resp, ok := httpgrpc.HTTPResponseFromError(err); ok && (resp.Code == http.StatusNotFound) {
-			n, bytesPerShard, err := r.Shards(expr)
-			if err != nil {
-				return nil, nil, errors.Wrap(err, "falling back to building linear shards from stats")
-			}
-			level.Debug(log).Log(
-				"msg", "falling back to building linear shards from stats",
-				"bytes_per_shard", bytesPerShard,
-				"shards", n,
-				"query", exprStr,
-			)
-			return sharding.LinearShards(n, uint64(n)*bytesPerShard), nil, nil
-		}
-
 		return nil, nil, errors.Wrapf(err, "failed to get shards for expression, got %T: %+v", err, err)
-
 	}
 
 	casted, ok := resp.(*ShardsResponse)