TSDB/query-planning-groundwork (#6367)

* begins building queryrange compatible types for index sampling

* adds MatcherGroups() method to SampleExpr

* MatcherGroups test + ShardResolver interface

* index stats codec wiring

* millisecond precision on index stats codec

* lint

* cleanMatchers in tsdb.IndexClient for consistency + adds catchall matcher if nil

pkg/loghttp/query.go

@@ -337,3 +337,9 @@ func ParseRangeQuery(r *http.Request) (*RangeQuery, error) {
 
 	return &result, nil
 }
+
+func ParseIndexStatsQuery(r *http.Request) (*RangeQuery, error) {
+	// TODO(owen-d): use a specific type/validation instead
+	// of using range query parameters (superset)
+	return ParseRangeQuery(r)
+}

pkg/logql/shardmapper.go

@@ -12,8 +12,16 @@ import (
 	util_log "github.com/grafana/loki/pkg/util/log"
 )
 
+type ShardResolver interface {
+	Shards(expr syntax.Expr) (int, error)
+}
+
+type constantShards int
+
+func (s constantShards) Shards(_ syntax.Expr) (int, error) { return int(s), nil }
+
 type ShardMapper struct {
-	shards  int
+	shards  constantShards
 	metrics *MapperMetrics
 }
 
@@ -22,7 +30,7 @@ func NewShardMapper(shards int, metrics *MapperMetrics) (ShardMapper, error) {
 		return ShardMapper{}, fmt.Errorf("cannot create ShardMapper with <2 shards. Received %d", shards)
 	}
 	return ShardMapper{
-		shards:  shards,
+		shards:  constantShards(shards),
 		metrics: metrics,
 	}, nil
 }
@@ -70,13 +78,13 @@ func (m ShardMapper) Map(expr syntax.Expr, r *downstreamRecorder) (syntax.Expr,
 	case *syntax.LiteralExpr:
 		return e, nil
 	case *syntax.MatchersExpr, *syntax.PipelineExpr:
-		return m.mapLogSelectorExpr(e.(syntax.LogSelectorExpr), r), nil
+		return m.mapLogSelectorExpr(e.(syntax.LogSelectorExpr), r)
 	case *syntax.VectorAggregationExpr:
 		return m.mapVectorAggregationExpr(e, r)
 	case *syntax.LabelReplaceExpr:
 		return m.mapLabelReplaceExpr(e, r)
 	case *syntax.RangeAggregationExpr:
-		return m.mapRangeAggregationExpr(e, r), nil
+		return m.mapRangeAggregationExpr(e, r)
 	case *syntax.BinOpExpr:
 		lhsMapped, err := m.Map(e.SampleExpr, r)
 		if err != nil {
@@ -102,42 +110,50 @@ func (m ShardMapper) Map(expr syntax.Expr, r *downstreamRecorder) (syntax.Expr,
 	}
 }
 
-func (m ShardMapper) mapLogSelectorExpr(expr syntax.LogSelectorExpr, r *downstreamRecorder) syntax.LogSelectorExpr {
+func (m ShardMapper) mapLogSelectorExpr(expr syntax.LogSelectorExpr, r *downstreamRecorder) (syntax.LogSelectorExpr, error) {
 	var head *ConcatLogSelectorExpr
-	for i := m.shards - 1; i >= 0; i-- {
+	shards, err := m.shards.Shards(expr)
+	if err != nil {
+		return nil, err
+	}
+	for i := shards - 1; i >= 0; i-- {
 		head = &ConcatLogSelectorExpr{
 			DownstreamLogSelectorExpr: DownstreamLogSelectorExpr{
 				shard: &astmapper.ShardAnnotation{
 					Shard: i,
-					Of:    m.shards,
+					Of:    shards,
 				},
 				LogSelectorExpr: expr,
 			},
 			next: head,
 		}
 	}
-	r.Add(m.shards, StreamsKey)
+	r.Add(shards, StreamsKey)
 
-	return head
+	return head, nil
 }
 
-func (m ShardMapper) mapSampleExpr(expr syntax.SampleExpr, r *downstreamRecorder) syntax.SampleExpr {
+func (m ShardMapper) mapSampleExpr(expr syntax.SampleExpr, r *downstreamRecorder) (syntax.SampleExpr, error) {
 	var head *ConcatSampleExpr
-	for i := m.shards - 1; i >= 0; i-- {
+	shards, err := m.shards.Shards(expr)
+	if err != nil {
+		return nil, err
+	}
+	for i := shards - 1; i >= 0; i-- {
 		head = &ConcatSampleExpr{
 			DownstreamSampleExpr: DownstreamSampleExpr{
 				shard: &astmapper.ShardAnnotation{
 					Shard: i,
-					Of:    m.shards,
+					Of:    shards,
 				},
 				SampleExpr: expr,
 			},
 			next: head,
 		}
 	}
-	r.Add(m.shards, MetricsKey)
+	r.Add(shards, MetricsKey)
 
-	return head
+	return head, nil
 }
 
 // technically, std{dev,var} are also parallelizable if there is no cross-shard merging
@@ -167,8 +183,12 @@ func (m ShardMapper) mapVectorAggregationExpr(expr *syntax.VectorAggregationExpr
 	switch expr.Operation {
 	case syntax.OpTypeSum:
 		// sum(x) -> sum(sum(x, shard=1) ++ sum(x, shard=2)...)
+		sharded, err := m.mapSampleExpr(expr, r)
+		if err != nil {
+			return nil, err
+		}
 		return &syntax.VectorAggregationExpr{
-			Left:      m.mapSampleExpr(expr, r),
+			Left:      sharded,
 			Grouping:  expr.Grouping,
 			Params:    expr.Params,
 			Operation: expr.Operation,
@@ -201,7 +221,10 @@ func (m ShardMapper) mapVectorAggregationExpr(expr *syntax.VectorAggregationExpr
 
 	case syntax.OpTypeCount:
 		// count(x) -> sum(count(x, shard=1) ++ count(x, shard=2)...)
-		sharded := m.mapSampleExpr(expr, r)
+		sharded, err := m.mapSampleExpr(expr, r)
+		if err != nil {
+			return nil, err
+		}
 		return &syntax.VectorAggregationExpr{
 			Left:      sharded,
 			Grouping:  expr.Grouping,
@@ -228,13 +251,13 @@ func (m ShardMapper) mapLabelReplaceExpr(expr *syntax.LabelReplaceExpr, r *downs
 	return &cpy, nil
 }
 
-func (m ShardMapper) mapRangeAggregationExpr(expr *syntax.RangeAggregationExpr, r *downstreamRecorder) syntax.SampleExpr {
+func (m ShardMapper) mapRangeAggregationExpr(expr *syntax.RangeAggregationExpr, r *downstreamRecorder) (syntax.SampleExpr, error) {
 	if hasLabelModifier(expr) {
 		// if an expr can modify labels this means multiple shards can return the same labelset.
 		// When this happens the merge strategy needs to be different from a simple concatenation.
 		// For instance for rates we need to sum data from different shards but same series.
 		// Since we currently support only concatenation as merge strategy, we skip those queries.
-		return expr
+		return expr, nil
 	}
 	switch expr.Operation {
 	case syntax.OpRangeTypeCount, syntax.OpRangeTypeRate, syntax.OpRangeTypeBytesRate, syntax.OpRangeTypeBytes:
@@ -243,7 +266,7 @@ func (m ShardMapper) mapRangeAggregationExpr(expr *syntax.RangeAggregationExpr,
 		// same goes for bytes_rate and bytes_over_time
 		return m.mapSampleExpr(expr, r)
 	default:
-		return expr
+		return expr, nil
 	}
 }
 

pkg/logql/shardmapper_test.go

@@ -106,7 +106,9 @@ func TestMapSampleExpr(t *testing.T) {
 		},
 	} {
 		t.Run(tc.in.String(), func(t *testing.T) {
-			require.Equal(t, tc.out, m.mapSampleExpr(tc.in, nilShardMetrics.downstreamRecorder()))
+			mapped, err := m.mapSampleExpr(tc.in, nilShardMetrics.downstreamRecorder())
+			require.Nil(t, err)
+			require.Equal(t, tc.out, mapped)
 		})
 	}
 }

pkg/logql/syntax/ast.go

@@ -707,6 +707,7 @@ type SampleExpr interface {
 	// Selector is the LogQL selector to apply when retrieving logs.
 	Selector() LogSelectorExpr
 	Extractor() (SampleExtractor, error)
+	MatcherGroups() [][]*labels.Matcher
 	Expr
 }
 
@@ -753,6 +754,14 @@ func (e *RangeAggregationExpr) Selector() LogSelectorExpr {
 	return e.Left.Left
 }
 
+func (e *RangeAggregationExpr) MatcherGroups() [][]*labels.Matcher {
+	xs := e.Left.Left.Matchers()
+	if len(xs) > 0 {
+		return [][]*labels.Matcher{xs}
+	}
+	return nil
+}
+
 func (e RangeAggregationExpr) validate() error {
 	if e.Grouping != nil {
 		switch e.Operation {
@@ -871,6 +880,10 @@ func mustNewVectorAggregationExpr(left SampleExpr, operation string, gr *Groupin
 	}
 }
 
+func (e *VectorAggregationExpr) MatcherGroups() [][]*labels.Matcher {
+	return e.Left.MatcherGroups()
+}
+
 func (e *VectorAggregationExpr) Selector() LogSelectorExpr {
 	return e.Left.Selector()
 }
@@ -992,6 +1005,10 @@ type BinOpExpr struct {
 	Opts *BinOpOptions
 }
 
+func (e *BinOpExpr) MatcherGroups() [][]*labels.Matcher {
+	return append(e.SampleExpr.MatcherGroups(), e.RHS.MatcherGroups()...)
+}
+
 func (e *BinOpExpr) String() string {
 	op := e.Op
 	if e.Opts != nil {
@@ -1374,6 +1391,7 @@ func (e *LiteralExpr) Shardable() bool                         { return true }
 func (e *LiteralExpr) Walk(f WalkFn)                           { f(e) }
 func (e *LiteralExpr) Pipeline() (log.Pipeline, error)         { return log.NewNoopPipeline(), nil }
 func (e *LiteralExpr) Matchers() []*labels.Matcher             { return nil }
+func (e *LiteralExpr) MatcherGroups() [][]*labels.Matcher      { return nil }
 func (e *LiteralExpr) Extractor() (log.SampleExtractor, error) { return nil, nil }
 func (e *LiteralExpr) Value() float64                          { return e.Val }
 
@@ -1428,6 +1446,10 @@ func (e *LabelReplaceExpr) Selector() LogSelectorExpr {
 	return e.Left.Selector()
 }
 
+func (e *LabelReplaceExpr) MatcherGroups() [][]*labels.Matcher {
+	return e.Left.MatcherGroups()
+}
+
 func (e *LabelReplaceExpr) Extractor() (SampleExtractor, error) {
 	return e.Left.Extractor()
 }
@@ -1498,3 +1520,17 @@ var shardableOps = map[string]bool{
 	OpTypeAdd: true,
 	OpTypeMul: true,
 }
+
+func MatcherGroups(expr Expr) [][]*labels.Matcher {
+	switch e := expr.(type) {
+	case SampleExpr:
+		return e.MatcherGroups()
+	case LogSelectorExpr:
+		if xs := e.Matchers(); len(xs) > 0 {
+			return [][]*labels.Matcher{xs}
+		}
+		return nil
+	default:
+		return nil
+	}
+}

pkg/logql/syntax/ast_test.go

@@ -1,6 +1,7 @@
 package syntax
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/prometheus/prometheus/model/labels"
@@ -178,6 +179,34 @@ func Test_SampleExpr_String(t *testing.T) {
 	}
 }
 
+func TestMatcherGroups(t *testing.T) {
+	for i, tc := range []struct {
+		query string
+		exp   [][]*labels.Matcher
+	}{
+		{
+			query: `{job="foo"}`,
+			exp: [][]*labels.Matcher{
+				{labels.MustNewMatcher(labels.MatchEqual, "job", "foo")},
+			},
+		},
+		{
+			query: `count_over_time({job="foo"}[5m]) / count_over_time({job="bar"}[5m])`,
+			exp: [][]*labels.Matcher{
+				{labels.MustNewMatcher(labels.MatchEqual, "job", "foo")},
+				{labels.MustNewMatcher(labels.MatchEqual, "job", "bar")},
+			},
+		},
+	} {
+		t.Run(fmt.Sprint(i), func(t *testing.T) {
+			expr, err := ParseExpr(tc.query)
+			require.Nil(t, err)
+			out := MatcherGroups(expr)
+			require.Equal(t, tc.exp, out)
+		})
+	}
+}
+
 func Test_NilFilterDoesntPanic(t *testing.T) {
 	t.Parallel()
 	for _, tc := range []string{

pkg/logql/syntax/parser.go

@@ -145,6 +145,10 @@ func ParseMatchers(input string) ([]*labels.Matcher, error) {
 	return matcherExpr.Mts, nil
 }
 
+func MatchersString(xs []*labels.Matcher) string {
+	return newMatcherExpr(xs).String()
+}
+
 // ParseSampleExpr parses a string and returns the sampleExpr
 func ParseSampleExpr(input string) (SampleExpr, error) {
 	expr, err := ParseExpr(input)

pkg/querier/http.go

@@ -422,9 +422,8 @@ func (q *QuerierAPI) SeriesHandler(w http.ResponseWriter, r *http.Request) {
 
 // IndexStatsHandler queries the index for the data statistics related to a query
 func (q *QuerierAPI) IndexStatsHandler(w http.ResponseWriter, r *http.Request) {
-	// TODO(owen-d): use a specific type/validation instead
-	// of using range query parameters (superset)
-	req, err := loghttp.ParseRangeQuery(r)
+
+	req, err := loghttp.ParseIndexStatsQuery(r)
 	if err != nil {
 		serverutil.WriteError(httpgrpc.Errorf(http.StatusBadRequest, err.Error()), w)
 		return

pkg/querier/queryrange/codec.go

@@ -26,6 +26,8 @@ import (
 	"github.com/grafana/loki/pkg/logqlmodel"
 	"github.com/grafana/loki/pkg/logqlmodel/stats"
 	"github.com/grafana/loki/pkg/querier/queryrange/queryrangebase"
+	"github.com/grafana/loki/pkg/storage/stores/shipper/indexgateway/indexgatewaypb"
+	"github.com/grafana/loki/pkg/util"
 	"github.com/grafana/loki/pkg/util/httpreq"
 	"github.com/grafana/loki/pkg/util/marshal"
 	marshal_legacy "github.com/grafana/loki/pkg/util/marshal/legacy"
@@ -259,6 +261,17 @@ func (Codec) DecodeRequest(_ context.Context, r *http.Request, forwardHeaders []
 			EndTs:   *req.End,
 			Path:    r.URL.Path,
 		}, nil
+	case IndexStatsOp:
+		req, err := loghttp.ParseIndexStatsQuery(r)
+		if err != nil {
+			return nil, httpgrpc.Errorf(http.StatusBadRequest, err.Error())
+		}
+		from, through := util.RoundToMilliseconds(req.Start, req.End)
+		return &indexgatewaypb.IndexStatsRequest{
+			From:     from,
+			Through:  through,
+			Matchers: req.Query,
+		}, err
 	default:
 		return nil, httpgrpc.Errorf(http.StatusBadRequest, fmt.Sprintf("unknown request path: %s", r.URL.Path))
 	}
@@ -365,6 +378,24 @@ func (Codec) EncodeRequest(ctx context.Context, r queryrangebase.Request) (*http
 			Header:     header,
 		}
 
+		return req.WithContext(ctx), nil
+	case *indexgatewaypb.IndexStatsRequest:
+		params := url.Values{
+			"start": []string{fmt.Sprintf("%d", request.From.Time().UnixNano())},
+			"end":   []string{fmt.Sprintf("%d", request.Through.Time().UnixNano())},
+			"query": []string{request.GetQuery()},
+		}
+		u := &url.URL{
+			Path:     "/loki/api/v1/index/stats",
+			RawQuery: params.Encode(),
+		}
+		req := &http.Request{
+			Method:     "GET",
+			RequestURI: u.String(), // This is what the httpgrpc code looks at.
+			URL:        u,
+			Body:       http.NoBody,
+			Header:     header,
+		}
 		return req.WithContext(ctx), nil
 	default:
 		return nil, httpgrpc.Errorf(http.StatusInternalServerError, "invalid request format")
@@ -424,6 +455,15 @@ func (Codec) DecodeResponse(ctx context.Context, r *http.Response, req queryrang
 			Data:    resp.Data,
 			Headers: httpResponseHeadersToPromResponseHeaders(r.Header),
 		}, nil
+	case *indexgatewaypb.IndexStatsRequest:
+		var resp indexgatewaypb.IndexStatsResponse
+		if err := json.Unmarshal(buf, &resp); err != nil {
+			return nil, httpgrpc.Errorf(http.StatusInternalServerError, "error decoding response: %v", err)
+		}
+		return &IndexStatsResponse{
+			Response: &resp,
+			Headers:  httpResponseHeadersToPromResponseHeaders(r.Header),
+		}, nil
 	default:
 		var resp loghttp.QueryResponse
 		if err := resp.UnmarshalJSON(buf); err != nil {
@@ -536,6 +576,11 @@ func (Codec) EncodeResponse(ctx context.Context, res queryrangebase.Response) (*
 				return nil, err
 			}
 		}
+	case *IndexStatsResponse:
+		if err := marshal.WriteIndexStatsResponseJSON(response.Response, &buf); err != nil {
+			return nil, err
+		}
+
 	default:
 		return nil, httpgrpc.Errorf(http.StatusInternalServerError, "invalid response format")
 	}

pkg/querier/queryrange/codec_test.go

@@ -12,12 +12,15 @@ import (
 	"testing"
 	"time"
 
+	"github.com/prometheus/common/model"
 	"github.com/stretchr/testify/require"
 
 	"github.com/grafana/loki/pkg/loghttp"
 	"github.com/grafana/loki/pkg/logproto"
 	"github.com/grafana/loki/pkg/logqlmodel/stats"
 	"github.com/grafana/loki/pkg/querier/queryrange/queryrangebase"
+	"github.com/grafana/loki/pkg/storage/stores/shipper/indexgateway/indexgatewaypb"
+	"github.com/grafana/loki/pkg/util"
 )
 
 func init() {
@@ -79,6 +82,17 @@ func Test_codec_DecodeRequest(t *testing.T) {
 			StartTs: start,
 			EndTs:   end,
 		}, false},
+		{"index_stats", func() (*http.Request, error) {
+			return LokiCodec.EncodeRequest(context.Background(), &indexgatewaypb.IndexStatsRequest{
+				From:     model.TimeFromUnixNano(start.UnixNano()),
+				Through:  model.TimeFromUnixNano(end.UnixNano()),
+				Matchers: `{job="foo"}`,
+			})
+		}, &indexgatewaypb.IndexStatsRequest{
+			From:     model.TimeFromUnixNano(start.UnixNano()),
+			Through:  model.TimeFromUnixNano(end.UnixNano()),
+			Matchers: `{job="foo"}`,
+		}, false},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -200,6 +214,18 @@ func Test_codec_DecodeResponse(t *testing.T) {
 				Data:    labelsData,
 			}, false,
 		},
+		{
+			"index stats", &http.Response{StatusCode: 200, Body: ioutil.NopCloser(strings.NewReader(indexStatsString))},
+			&indexgatewaypb.IndexStatsRequest{},
+			&IndexStatsResponse{
+				Response: &indexgatewaypb.IndexStatsResponse{
+					Streams: 1,
+					Chunks:  2,
+					Bytes:   3,
+					Entries: 4,
+				},
+			}, false,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -326,6 +352,20 @@ func Test_codec_labels_EncodeRequest(t *testing.T) {
 	require.Equal(t, "/loki/api/v1/labels/__name__/values", req.(*LokiLabelNamesRequest).Path)
 }
 
+func Test_codec_index_stats_EncodeRequest(t *testing.T) {
+	from, through := util.RoundToMilliseconds(start, end)
+	toEncode := &indexgatewaypb.IndexStatsRequest{
+		From:     from,
+		Through:  through,
+		Matchers: `{job="foo"}`,
+	}
+	got, err := LokiCodec.EncodeRequest(context.Background(), toEncode)
+	require.Nil(t, err)
+	require.Equal(t, fmt.Sprintf("%d", from.UnixNano()), got.URL.Query().Get("start"))
+	require.Equal(t, fmt.Sprintf("%d", through.UnixNano()), got.URL.Query().Get("end"))
+	require.Equal(t, `{job="foo"}`, got.URL.Query().Get("query"))
+}
+
 func Test_codec_EncodeResponse(t *testing.T) {
 	tests := []struct {
 		name    string
@@ -396,6 +436,17 @@ func Test_codec_EncodeResponse(t *testing.T) {
 				Data:    labelsData,
 			}, labelsLegacyString, false,
 		},
+		{
+			"index stats",
+			&IndexStatsResponse{
+				Response: &indexgatewaypb.IndexStatsResponse{
+					Streams: 1,
+					Chunks:  2,
+					Bytes:   3,
+					Entries: 4,
+				},
+			}, indexStatsString, false,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -1103,6 +1154,12 @@ var (
 			"bar"
 		]
 	}`
+	indexStatsString = `{
+		"streams": 1,
+		"chunks": 2,
+		"bytes": 3,
+		"entries": 4
+		}`
 	labelsData  = []string{"foo", "bar"}
 	statsResult = stats.Result{
 		Summary: stats.Summary{

pkg/querier/queryrange/extensions.go

@@ -53,3 +53,11 @@ func convertPrometheusResponseHeadersToPointers(h []queryrangebase.PrometheusRes
 
 	return resp
 }
+
+// GetHeaders returns the HTTP headers in the response.
+func (m *IndexStatsResponse) GetHeaders() []*queryrangebase.PrometheusResponseHeader {
+	if m != nil {
+		return convertPrometheusResponseHeadersToPointers(m.Headers)
+	}
+	return nil
+}

pkg/querier/queryrange/queryrange.pb.go

@@ -14,6 +14,8 @@ import (
 	stats "github.com/grafana/loki/pkg/logqlmodel/stats"
 	github_com_grafana_loki_pkg_querier_queryrange_queryrangebase "github.com/grafana/loki/pkg/querier/queryrange/queryrangebase"
 	queryrangebase "github.com/grafana/loki/pkg/querier/queryrange/queryrangebase"
+	_ "github.com/grafana/loki/pkg/storage/stores/shipper/indexgateway/indexgatewaypb"
+	github_com_grafana_loki_pkg_storage_stores_shipper_indexgateway_indexgatewaypb "github.com/grafana/loki/pkg/storage/stores/shipper/indexgateway/indexgatewaypb"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -690,6 +692,43 @@ func (m *LokiPromResponse) GetStatistics() stats.Result {
 	return stats.Result{}
 }
 
+type IndexStatsResponse struct {
+	Response *github_com_grafana_loki_pkg_storage_stores_shipper_indexgateway_indexgatewaypb.IndexStatsResponse `protobuf:"bytes,1,opt,name=response,proto3,customtype=github.com/grafana/loki/pkg/storage/stores/shipper/indexgateway/indexgatewaypb.IndexStatsResponse" json:"response,omitempty"`
+	Headers  []github_com_grafana_loki_pkg_querier_queryrange_queryrangebase.PrometheusResponseHeader           `protobuf:"bytes,2,rep,name=Headers,proto3,customtype=github.com/grafana/loki/pkg/querier/queryrange/queryrangebase.PrometheusResponseHeader" json:"-"`
+}
+
+func (m *IndexStatsResponse) Reset()      { *m = IndexStatsResponse{} }
+func (*IndexStatsResponse) ProtoMessage() {}
+func (*IndexStatsResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_51b9d53b40d11902, []int{9}
+}
+func (m *IndexStatsResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *IndexStatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_IndexStatsResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *IndexStatsResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IndexStatsResponse.Merge(m, src)
+}
+func (m *IndexStatsResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *IndexStatsResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_IndexStatsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IndexStatsResponse proto.InternalMessageInfo
+
 func init() {
 	proto.RegisterType((*LokiRequest)(nil), "queryrange.LokiRequest")
 	proto.RegisterType((*LokiInstantRequest)(nil), "queryrange.LokiInstantRequest")
@@ -700,6 +739,7 @@ func init() {
 	proto.RegisterType((*LokiLabelNamesResponse)(nil), "queryrange.LokiLabelNamesResponse")
 	proto.RegisterType((*LokiData)(nil), "queryrange.LokiData")
 	proto.RegisterType((*LokiPromResponse)(nil), "queryrange.LokiPromResponse")
+	proto.RegisterType((*IndexStatsResponse)(nil), "queryrange.IndexStatsResponse")
 }
 
 func init() {
@@ -707,65 +747,70 @@ func init() {
 }
 
 var fileDescriptor_51b9d53b40d11902 = []byte{
-	// 923 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x55, 0xcf, 0x6f, 0x23, 0x35,
-	0x14, 0x8e, 0x33, 0xf9, 0x35, 0x2e, 0x5b, 0xc0, 0x5d, 0x76, 0x47, 0x45, 0x9a, 0x89, 0x72, 0x80,
-	0x20, 0xd8, 0x89, 0xe8, 0x02, 0x07, 0x04, 0x88, 0x1d, 0x15, 0xc4, 0x4a, 0x2b, 0x84, 0x66, 0x23,
-	0xae, 0xc8, 0x69, 0xdc, 0x64, 0xd4, 0x99, 0xf1, 0xd4, 0x76, 0x56, 0xea, 0x0d, 0x89, 0x33, 0xd2,
-	0xfe, 0x0d, 0x70, 0x00, 0xf1, 0x97, 0xf4, 0xd8, 0xe3, 0x6a, 0x25, 0x06, 0x9a, 0x1e, 0x80, 0x9c,
-	0xf6, 0x4f, 0x40, 0xb6, 0x67, 0x12, 0xa7, 0x34, 0xb4, 0x69, 0x2f, 0x1c, 0xb8, 0x24, 0x7e, 0xcf,
-	0xef, 0x73, 0xfc, 0xbe, 0xf7, 0x7d, 0x0e, 0x7c, 0x33, 0x3b, 0x18, 0xf5, 0x0e, 0x27, 0x84, 0x45,
-	0x84, 0xa9, 0xef, 0x23, 0x86, 0xd3, 0x11, 0x31, 0x96, 0x7e, 0xc6, 0xa8, 0xa0, 0x08, 0x2e, 0x32,
-	0xdb, 0xf7, 0x46, 0x91, 0x18, 0x4f, 0x06, 0xfe, 0x1e, 0x4d, 0x7a, 0x23, 0x3a, 0xa2, 0x3d, 0x55,
-	0x32, 0x98, 0xec, 0xab, 0x48, 0x05, 0x6a, 0xa5, 0xa1, 0xdb, 0xde, 0x88, 0xd2, 0x51, 0x4c, 0x16,
-	0x55, 0x22, 0x4a, 0x08, 0x17, 0x38, 0xc9, 0x8a, 0x82, 0xd7, 0xe5, 0x25, 0x62, 0x3a, 0xd2, 0xc8,
-	0x72, 0x51, 0x6c, 0xb6, 0x8b, 0xcd, 0xc3, 0x38, 0xa1, 0x43, 0x12, 0xf7, 0xb8, 0xc0, 0x82, 0xeb,
-	0xcf, 0xa2, 0xe2, 0x83, 0x4b, 0x7b, 0x18, 0x60, 0xfe, 0xcf, 0x96, 0x3a, 0x27, 0x55, 0xb8, 0xf1,
-	0x88, 0x1e, 0x44, 0x21, 0x39, 0x9c, 0x10, 0x2e, 0xd0, 0x6d, 0x58, 0x57, 0x35, 0x0e, 0x68, 0x83,
-	0xae, 0x1d, 0xea, 0x40, 0x66, 0xe3, 0x28, 0x89, 0x84, 0x53, 0x6d, 0x83, 0xee, 0xad, 0x50, 0x07,
-	0x08, 0xc1, 0x1a, 0x17, 0x24, 0x73, 0xac, 0x36, 0xe8, 0x5a, 0xa1, 0x5a, 0xa3, 0x6d, 0xd8, 0x8a,
-	0x52, 0x41, 0xd8, 0x13, 0x1c, 0x3b, 0xb6, 0xca, 0xcf, 0x63, 0xf4, 0x09, 0x6c, 0x72, 0x81, 0x99,
-	0xe8, 0x73, 0xa7, 0xd6, 0x06, 0xdd, 0x8d, 0x9d, 0x6d, 0x5f, 0xb3, 0xe2, 0x97, 0xac, 0xf8, 0xfd,
-	0x92, 0x95, 0xa0, 0x75, 0x9c, 0x7b, 0x95, 0xa7, 0xbf, 0x79, 0x20, 0x2c, 0x41, 0xe8, 0x43, 0x58,
-	0x27, 0xe9, 0xb0, 0xcf, 0x9d, 0xfa, 0x1a, 0x68, 0x0d, 0x41, 0xef, 0x42, 0x7b, 0x18, 0x31, 0xb2,
-	0x27, 0x22, 0x9a, 0x3a, 0x8d, 0x36, 0xe8, 0x6e, 0xee, 0x6c, 0xf9, 0x73, 0x96, 0x77, 0xcb, 0xad,
-	0x70, 0x51, 0x25, 0xdb, 0xcb, 0xb0, 0x18, 0x3b, 0x4d, 0xc5, 0x84, 0x5a, 0xa3, 0x0e, 0x6c, 0xf0,
-	0x31, 0x66, 0x43, 0xee, 0xb4, 0xda, 0x56, 0xd7, 0x0e, 0xe0, 0x2c, 0xf7, 0x8a, 0x4c, 0x58, 0x7c,
-	0x77, 0xfe, 0x02, 0x10, 0x49, 0x4a, 0x1f, 0xa6, 0x5c, 0xe0, 0x54, 0x5c, 0x87, 0xd9, 0x8f, 0x60,
-	0x43, 0xea, 0xa3, 0xcf, 0x15, 0xb7, 0x57, 0x6d, 0xb5, 0xc0, 0x2c, 0xf7, 0x5a, 0x5b, 0xab, 0xd7,
-	0xfa, 0x85, 0xbd, 0x36, 0x56, 0xf6, 0xfa, 0x43, 0x0d, 0xbe, 0xa4, 0xe5, 0xc3, 0x33, 0x9a, 0x72,
-	0x22, 0x41, 0x8f, 0x05, 0x16, 0x13, 0xae, 0xdb, 0x2c, 0x40, 0x2a, 0x13, 0x16, 0x3b, 0xe8, 0x53,
-	0x58, 0xdb, 0xc5, 0x02, 0xab, 0x96, 0x37, 0x76, 0x6e, 0xfb, 0x86, 0x28, 0xe5, 0x59, 0x72, 0x2f,
-	0xb8, 0x23, 0xbb, 0x9a, 0xe5, 0xde, 0xe6, 0x10, 0x0b, 0xfc, 0x0e, 0x4d, 0x22, 0x41, 0x92, 0x4c,
-	0x1c, 0x85, 0x0a, 0x89, 0xde, 0x87, 0xf6, 0x67, 0x8c, 0x51, 0xd6, 0x3f, 0xca, 0x88, 0xa2, 0xc8,
-	0x0e, 0xee, 0xce, 0x72, 0x6f, 0x8b, 0x94, 0x49, 0x03, 0xb1, 0xa8, 0x44, 0x6f, 0xc1, 0xba, 0x0a,
-	0x14, 0x29, 0x76, 0xb0, 0x35, 0xcb, 0xbd, 0x97, 0x15, 0xc4, 0x28, 0xd7, 0x15, 0xcb, 0x1c, 0xd6,
-	0xaf, 0xc4, 0xe1, 0x7c, 0x94, 0x0d, 0x73, 0x94, 0x0e, 0x6c, 0x3e, 0x21, 0x8c, 0xcb, 0x63, 0x9a,
-	0x2a, 0x5f, 0x86, 0xe8, 0x01, 0x84, 0x92, 0x98, 0x88, 0x8b, 0x68, 0x4f, 0xea, 0x49, 0x92, 0x71,
-	0xcb, 0xd7, 0xa6, 0x0e, 0x09, 0x9f, 0xc4, 0x22, 0x40, 0x05, 0x0b, 0x46, 0x61, 0x68, 0xac, 0xd1,
-	0x8f, 0x00, 0x36, 0xbf, 0x20, 0x78, 0x48, 0x18, 0x77, 0xec, 0xb6, 0xd5, 0xdd, 0xd8, 0xe9, 0xfa,
-	0xcb, 0x8e, 0xf7, 0xbf, 0x62, 0x34, 0x21, 0x62, 0x4c, 0x26, 0xbc, 0x9c, 0x91, 0x06, 0x04, 0xdf,
-	0x3c, 0xcf, 0xbd, 0xaf, 0xcd, 0x47, 0x8c, 0xe1, 0x7d, 0x9c, 0xe2, 0x5e, 0x4c, 0x0f, 0xa2, 0xde,
-	0x95, 0x5e, 0x93, 0x95, 0x67, 0xcf, 0x72, 0x0f, 0xdc, 0x0b, 0xcb, 0x9b, 0x75, 0x7e, 0x05, 0xf0,
-	0x55, 0x39, 0xd8, 0xc7, 0xf2, 0x3c, 0x6e, 0xf8, 0x21, 0xc1, 0x62, 0x6f, 0xec, 0x00, 0xa9, 0xae,
-	0x50, 0x07, 0xe6, 0x1b, 0x51, 0xbd, 0xd1, 0x1b, 0x61, 0xad, 0xff, 0x46, 0x94, 0x26, 0xa8, 0x5d,
-	0x68, 0x82, 0xfa, 0x4a, 0x13, 0x7c, 0x67, 0x69, 0xc3, 0x97, 0xfd, 0xad, 0x61, 0x85, 0xcf, 0xe7,
-	0x56, 0xb0, 0xd4, 0x6d, 0xe7, 0x0a, 0xd3, 0x67, 0x3d, 0x1c, 0x92, 0x54, 0x44, 0xfb, 0x11, 0x61,
-	0x97, 0x18, 0xc2, 0x50, 0x99, 0xb5, 0xac, 0x32, 0x53, 0x22, 0xb5, 0xff, 0xaa, 0x44, 0xce, 0x79,
-	0xa1, 0x7e, 0x0d, 0x2f, 0x74, 0x7e, 0x02, 0xf0, 0x35, 0x39, 0x85, 0x47, 0x78, 0x40, 0xe2, 0x2f,
-	0x71, 0xb2, 0x50, 0x9a, 0xa1, 0x29, 0x70, 0x23, 0x4d, 0x55, 0xaf, 0xaf, 0x29, 0x6b, 0xa1, 0xa9,
-	0xce, 0x1f, 0x55, 0x78, 0xe7, 0xfc, 0x4d, 0xd7, 0xd0, 0xcc, 0x1b, 0x86, 0x66, 0xec, 0x00, 0xfd,
-	0xaf, 0x89, 0xd5, 0x9a, 0xf8, 0x05, 0xc0, 0x56, 0xf9, 0x97, 0x82, 0x7c, 0x08, 0x35, 0x4c, 0xfd,
-	0x6b, 0x68, 0x7e, 0x37, 0x25, 0x98, 0xcd, 0xb3, 0xa1, 0x51, 0x81, 0x52, 0xd8, 0xd0, 0x51, 0xe1,
-	0xce, 0xbb, 0x86, 0x3b, 0x05, 0x23, 0x38, 0x79, 0x30, 0xc4, 0x99, 0x20, 0x2c, 0xf8, 0x58, 0xde,
-	0xe2, 0x79, 0xee, 0xbd, 0xfd, 0x6f, 0xb4, 0x9c, 0xc3, 0xca, 0xb9, 0xea, 0xdf, 0x0d, 0x8b, 0x5f,
-	0xe9, 0x7c, 0x0f, 0xe0, 0x2b, 0xf2, 0xb2, 0x92, 0x9e, 0xb9, 0x20, 0x76, 0x61, 0x8b, 0x15, 0xeb,
-	0x42, 0xbc, 0x9d, 0xcb, 0x47, 0x15, 0xd4, 0x8e, 0x73, 0x0f, 0x84, 0x73, 0x24, 0xba, 0xbf, 0x44,
-	0x65, 0xf5, 0x22, 0x2a, 0x25, 0xa4, 0x62, 0x92, 0x17, 0xbc, 0x77, 0x72, 0xea, 0x56, 0x9e, 0x9d,
-	0xba, 0x95, 0x17, 0xa7, 0x2e, 0xf8, 0x76, 0xea, 0x82, 0x9f, 0xa7, 0x2e, 0x38, 0x9e, 0xba, 0xe0,
-	0x64, 0xea, 0x82, 0xdf, 0xa7, 0x2e, 0xf8, 0x73, 0xea, 0x56, 0x5e, 0x4c, 0x5d, 0xf0, 0xf4, 0xcc,
-	0xad, 0x9c, 0x9c, 0xb9, 0x95, 0x67, 0x67, 0x6e, 0x65, 0xd0, 0x50, 0x5d, 0xde, 0xff, 0x3b, 0x00,
-	0x00, 0xff, 0xff, 0x13, 0x18, 0x8f, 0x0c, 0x55, 0x0b, 0x00, 0x00,
+	// 1003 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x56, 0x4f, 0x6f, 0x1b, 0x45,
+	0x14, 0xf7, 0xf8, 0x5f, 0xec, 0x09, 0x0d, 0x30, 0x29, 0xed, 0xca, 0x48, 0xbb, 0x96, 0x0f, 0x60,
+	0x04, 0xdd, 0x15, 0x29, 0x70, 0x40, 0x80, 0xe8, 0x2a, 0x20, 0x22, 0x55, 0x08, 0x6d, 0x2d, 0xae,
+	0x68, 0x9c, 0x9d, 0xac, 0x57, 0xd9, 0x7f, 0x99, 0x19, 0x17, 0x72, 0x43, 0xe2, 0x8c, 0xd4, 0xcf,
+	0x00, 0x42, 0x20, 0x3e, 0x49, 0x8e, 0x39, 0x56, 0x91, 0x58, 0x88, 0x73, 0x00, 0x7c, 0xea, 0x47,
+	0x40, 0x33, 0xb3, 0x6b, 0x8f, 0x53, 0xa7, 0x89, 0xd3, 0x4b, 0x0f, 0x5c, 0xbc, 0xef, 0xbd, 0x79,
+	0xbf, 0xd9, 0x79, 0xbf, 0xf7, 0x7b, 0xe3, 0x85, 0x6f, 0x66, 0xfb, 0x81, 0x73, 0x30, 0x26, 0x34,
+	0x24, 0x54, 0x3e, 0x0f, 0x29, 0x4e, 0x02, 0xa2, 0x99, 0x76, 0x46, 0x53, 0x9e, 0x22, 0x38, 0x8f,
+	0x74, 0xee, 0x04, 0x21, 0x1f, 0x8d, 0x87, 0xf6, 0x6e, 0x1a, 0x3b, 0x41, 0x1a, 0xa4, 0x8e, 0x4c,
+	0x19, 0x8e, 0xf7, 0xa4, 0x27, 0x1d, 0x69, 0x29, 0x68, 0xc7, 0x0a, 0xd2, 0x34, 0x88, 0xc8, 0x3c,
+	0x8b, 0x87, 0x31, 0x61, 0x1c, 0xc7, 0x59, 0x91, 0xf0, 0xba, 0x38, 0x44, 0x94, 0x06, 0x0a, 0x59,
+	0x1a, 0xc5, 0x62, 0xb7, 0x58, 0x3c, 0x88, 0xe2, 0xd4, 0x27, 0x91, 0xc3, 0x38, 0xe6, 0x4c, 0xfd,
+	0x16, 0x19, 0x1f, 0x5c, 0x5a, 0xc3, 0x10, 0xb3, 0xa7, 0x4b, 0xea, 0x6c, 0x0b, 0x1c, 0xe3, 0x29,
+	0xc5, 0x01, 0x91, 0x4f, 0xc2, 0x1c, 0x36, 0x0a, 0xb3, 0x8c, 0x50, 0x27, 0x4c, 0x7c, 0xf2, 0x5d,
+	0x80, 0x39, 0xf9, 0x16, 0x1f, 0x2e, 0x38, 0xd9, 0xd0, 0x29, 0x2c, 0xb5, 0x4b, 0xef, 0xb8, 0x0a,
+	0xd7, 0xef, 0xa7, 0xfb, 0xa1, 0x47, 0x0e, 0xc6, 0x84, 0x71, 0x74, 0x13, 0x36, 0xe4, 0x9b, 0x0c,
+	0xd0, 0x05, 0xfd, 0xb6, 0xa7, 0x1c, 0x11, 0x8d, 0xc2, 0x38, 0xe4, 0x46, 0xb5, 0x0b, 0xfa, 0x37,
+	0x3c, 0xe5, 0x20, 0x04, 0xeb, 0x8c, 0x93, 0xcc, 0xa8, 0x75, 0x41, 0xbf, 0xe6, 0x49, 0x1b, 0x75,
+	0x60, 0x2b, 0x4c, 0x38, 0xa1, 0x0f, 0x71, 0x64, 0xb4, 0x65, 0x7c, 0xe6, 0xa3, 0x4f, 0xe0, 0x1a,
+	0xe3, 0x98, 0xf2, 0x01, 0x33, 0xea, 0x5d, 0xd0, 0x5f, 0xdf, 0xea, 0xd8, 0x8a, 0x5b, 0xbb, 0xe4,
+	0xd6, 0x1e, 0x94, 0xdc, 0xba, 0xad, 0xa3, 0xdc, 0xaa, 0x3c, 0xfa, 0xd3, 0x02, 0x5e, 0x09, 0x42,
+	0x1f, 0xc2, 0x06, 0x49, 0xfc, 0x01, 0x33, 0x1a, 0x2b, 0xa0, 0x15, 0x04, 0xbd, 0x0b, 0xdb, 0x7e,
+	0x48, 0xc9, 0x2e, 0x0f, 0xd3, 0xc4, 0x68, 0x76, 0x41, 0x7f, 0x63, 0x6b, 0xd3, 0x9e, 0xf5, 0x6a,
+	0xbb, 0x5c, 0xf2, 0xe6, 0x59, 0xa2, 0xbc, 0x0c, 0xf3, 0x91, 0xb1, 0x26, 0x99, 0x90, 0x36, 0xea,
+	0xc1, 0x26, 0x1b, 0x61, 0xea, 0x33, 0xa3, 0xd5, 0xad, 0xf5, 0xdb, 0x2e, 0x9c, 0xe6, 0x56, 0x11,
+	0xf1, 0x8a, 0x67, 0xef, 0x5f, 0x00, 0x91, 0xa0, 0x74, 0x27, 0x61, 0x1c, 0x27, 0xfc, 0x3a, 0xcc,
+	0x7e, 0x04, 0x9b, 0x42, 0x65, 0x03, 0x26, 0xb9, 0xbd, 0x6a, 0xa9, 0x05, 0x66, 0xb1, 0xd6, 0xfa,
+	0x4a, 0xb5, 0x36, 0x96, 0xd6, 0xda, 0xbc, 0xb0, 0xd6, 0x9f, 0xea, 0xf0, 0x25, 0x25, 0x1f, 0x96,
+	0xa5, 0x09, 0x23, 0x02, 0xf4, 0x80, 0x63, 0x3e, 0x66, 0xaa, 0xcc, 0x02, 0x24, 0x23, 0x5e, 0xb1,
+	0x82, 0x3e, 0x85, 0xf5, 0x6d, 0xcc, 0xb1, 0x2c, 0x79, 0x7d, 0xeb, 0xa6, 0xad, 0x49, 0x5b, 0xec,
+	0x25, 0xd6, 0xdc, 0x5b, 0xa2, 0xaa, 0x69, 0x6e, 0x6d, 0xf8, 0x98, 0xe3, 0x77, 0xd2, 0x38, 0xe4,
+	0x24, 0xce, 0xf8, 0xa1, 0x27, 0x91, 0xe8, 0x7d, 0xd8, 0xfe, 0x8c, 0xd2, 0x94, 0x0e, 0x0e, 0x33,
+	0x22, 0x29, 0x6a, 0xbb, 0xb7, 0xa7, 0xb9, 0xb5, 0x49, 0xca, 0xa0, 0x86, 0x98, 0x67, 0xa2, 0xb7,
+	0x60, 0x43, 0x3a, 0x92, 0x94, 0xb6, 0xbb, 0x39, 0xcd, 0xad, 0x97, 0x25, 0x44, 0x4b, 0x57, 0x19,
+	0x8b, 0x1c, 0x36, 0xae, 0xc4, 0xe1, 0xac, 0x95, 0x4d, 0xbd, 0x95, 0x06, 0x5c, 0x7b, 0x48, 0x28,
+	0x13, 0xdb, 0xac, 0xc9, 0x78, 0xe9, 0xa2, 0x7b, 0x10, 0x0a, 0x62, 0x42, 0xc6, 0xc3, 0x5d, 0xa1,
+	0x27, 0x41, 0xc6, 0x0d, 0x5b, 0x5d, 0x0d, 0x1e, 0x61, 0xe3, 0x88, 0xbb, 0xa8, 0x60, 0x41, 0x4b,
+	0xf4, 0x34, 0x1b, 0xfd, 0x0c, 0xe0, 0xda, 0x17, 0x04, 0xfb, 0x84, 0x32, 0xa3, 0xdd, 0xad, 0xf5,
+	0xd7, 0xb7, 0xfa, 0xf6, 0xe2, 0xbd, 0x61, 0x7f, 0x45, 0xd3, 0x98, 0xf0, 0x11, 0x19, 0xb3, 0xb2,
+	0x47, 0x0a, 0xe0, 0x7e, 0x73, 0x92, 0x5b, 0x5f, 0xeb, 0x57, 0x21, 0xc5, 0x7b, 0x38, 0xc1, 0x4e,
+	0x94, 0xee, 0x87, 0xce, 0x95, 0xee, 0xa4, 0x0b, 0xf7, 0x9e, 0xe6, 0x16, 0xb8, 0xe3, 0x95, 0x27,
+	0xeb, 0xfd, 0x01, 0xe0, 0xab, 0xa2, 0xb1, 0x0f, 0xc4, 0x7e, 0x4c, 0x9b, 0x87, 0x18, 0xf3, 0xdd,
+	0x91, 0x01, 0x84, 0xba, 0x3c, 0xe5, 0xe8, 0x77, 0x44, 0xf5, 0xb9, 0xee, 0x88, 0xda, 0xea, 0x77,
+	0x44, 0x39, 0x04, 0xf5, 0xa5, 0x43, 0xd0, 0xb8, 0x70, 0x08, 0x7e, 0xa8, 0xa9, 0x81, 0x2f, 0xeb,
+	0x5b, 0x61, 0x14, 0x3e, 0x9f, 0x8d, 0x42, 0x4d, 0x9e, 0x76, 0xa6, 0x30, 0xb5, 0xd7, 0x8e, 0x4f,
+	0x12, 0x1e, 0xee, 0x85, 0x84, 0x5e, 0x32, 0x10, 0x9a, 0xca, 0x6a, 0x8b, 0x2a, 0xd3, 0x25, 0x52,
+	0x7f, 0x51, 0x25, 0x72, 0x6e, 0x16, 0x1a, 0xd7, 0x98, 0x85, 0xde, 0xaf, 0x00, 0xbe, 0x26, 0xba,
+	0x70, 0x1f, 0x0f, 0x49, 0xf4, 0x25, 0x8e, 0xe7, 0x4a, 0xd3, 0x34, 0x05, 0x9e, 0x4b, 0x53, 0xd5,
+	0xeb, 0x6b, 0xaa, 0x36, 0xd7, 0x54, 0xef, 0xef, 0x2a, 0xbc, 0x75, 0xfe, 0xa4, 0x2b, 0x68, 0xe6,
+	0x0d, 0x4d, 0x33, 0x6d, 0x17, 0xfd, 0xaf, 0x89, 0x8b, 0x35, 0xf1, 0x3b, 0x80, 0xad, 0xf2, 0x2f,
+	0x05, 0xd9, 0x10, 0x2a, 0x98, 0xfc, 0xd7, 0x50, 0xfc, 0x6e, 0x08, 0x30, 0x9d, 0x45, 0x3d, 0x2d,
+	0x03, 0x25, 0xb0, 0xa9, 0xbc, 0x62, 0x3a, 0x6f, 0x6b, 0xd3, 0xc9, 0x29, 0xc1, 0xf1, 0x3d, 0x1f,
+	0x67, 0x9c, 0x50, 0xf7, 0x63, 0x71, 0x8a, 0x93, 0xdc, 0x7a, 0xfb, 0x59, 0xb4, 0x9c, 0xc3, 0x8a,
+	0xbe, 0xaa, 0xf7, 0x7a, 0xc5, 0x5b, 0x7a, 0x3f, 0x02, 0xf8, 0x8a, 0x38, 0xac, 0xa0, 0x67, 0x26,
+	0x88, 0x6d, 0xd8, 0xa2, 0x85, 0x5d, 0x88, 0xb7, 0x77, 0x79, 0xab, 0xdc, 0xfa, 0x51, 0x6e, 0x01,
+	0x6f, 0x86, 0x44, 0x77, 0x17, 0xa8, 0xac, 0x2e, 0xa3, 0x52, 0x40, 0x2a, 0x0b, 0xe4, 0x4d, 0xaa,
+	0x10, 0xed, 0x88, 0x6f, 0x47, 0xa1, 0xbb, 0xb9, 0x44, 0x7f, 0x01, 0x4b, 0x8e, 0xb4, 0xf8, 0x8d,
+	0x69, 0x3f, 0x0d, 0x73, 0xc9, 0x49, 0x6e, 0xe1, 0x67, 0x11, 0xb4, 0xfa, 0xa7, 0xec, 0x92, 0xd7,
+	0x68, 0x35, 0xeb, 0x22, 0xaf, 0xbe, 0xa8, 0x22, 0x77, 0xdf, 0x3b, 0x3e, 0x35, 0x2b, 0x8f, 0x4f,
+	0xcd, 0xca, 0x93, 0x53, 0x13, 0x7c, 0x3f, 0x31, 0xc1, 0x6f, 0x13, 0x13, 0x1c, 0x4d, 0x4c, 0x70,
+	0x3c, 0x31, 0xc1, 0x5f, 0x13, 0x13, 0xfc, 0x33, 0x31, 0x2b, 0x4f, 0x26, 0x26, 0x78, 0x74, 0x66,
+	0x56, 0x8e, 0xcf, 0xcc, 0xca, 0xe3, 0x33, 0xb3, 0x32, 0x6c, 0x4a, 0x29, 0xdd, 0xfd, 0x2f, 0x00,
+	0x00, 0xff, 0xff, 0x56, 0x94, 0x8e, 0x4e, 0x00, 0x0d, 0x00, 0x00,
 }
 
 func (this *LokiRequest) Equal(that interface{}) bool {
@@ -1145,6 +1190,42 @@ func (this *LokiPromResponse) Equal(that interface{}) bool {
 	}
 	return true
 }
+func (this *IndexStatsResponse) Equal(that interface{}) bool {
+	if that == nil {
+		return this == nil
+	}
+
+	that1, ok := that.(*IndexStatsResponse)
+	if !ok {
+		that2, ok := that.(IndexStatsResponse)
+		if ok {
+			that1 = &that2
+		} else {
+			return false
+		}
+	}
+	if that1 == nil {
+		return this == nil
+	} else if this == nil {
+		return false
+	}
+	if that1.Response == nil {
+		if this.Response != nil {
+			return false
+		}
+	} else if !this.Response.Equal(*that1.Response) {
+		return false
+	}
+	if len(this.Headers) != len(that1.Headers) {
+		return false
+	}
+	for i := range this.Headers {
+		if !this.Headers[i].Equal(that1.Headers[i]) {
+			return false
+		}
+	}
+	return true
+}
 func (this *LokiRequest) GoString() string {
 	if this == nil {
 		return "nil"
@@ -1280,6 +1361,17 @@ func (this *LokiPromResponse) GoString() string {
 	s = append(s, "}")
 	return strings.Join(s, "")
 }
+func (this *IndexStatsResponse) GoString() string {
+	if this == nil {
+		return "nil"
+	}
+	s := make([]string, 0, 6)
+	s = append(s, "&queryrange.IndexStatsResponse{")
+	s = append(s, "Response: "+fmt.Sprintf("%#v", this.Response)+",\n")
+	s = append(s, "Headers: "+fmt.Sprintf("%#v", this.Headers)+",\n")
+	s = append(s, "}")
+	return strings.Join(s, "")
+}
 func valueToGoStringQueryrange(v interface{}, typ string) string {
 	rv := reflect.ValueOf(v)
 	if rv.IsNil() {
@@ -1867,6 +1959,55 @@ func (m *LokiPromResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *IndexStatsResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *IndexStatsResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *IndexStatsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Headers) > 0 {
+		for iNdEx := len(m.Headers) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size := m.Headers[iNdEx].Size()
+				i -= size
+				if _, err := m.Headers[iNdEx].MarshalTo(dAtA[i:]); err != nil {
+					return 0, err
+				}
+				i = encodeVarintQueryrange(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x12
+		}
+	}
+	if m.Response != nil {
+		{
+			size := m.Response.Size()
+			i -= size
+			if _, err := m.Response.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+			i = encodeVarintQueryrange(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintQueryrange(dAtA []byte, offset int, v uint64) int {
 	offset -= sovQueryrange(v)
 	base := offset
@@ -2128,6 +2269,25 @@ func (m *LokiPromResponse) Size() (n int) {
 	return n
 }
 
+func (m *IndexStatsResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Response != nil {
+		l = m.Response.Size()
+		n += 1 + l + sovQueryrange(uint64(l))
+	}
+	if len(m.Headers) > 0 {
+		for _, e := range m.Headers {
+			l = e.Size()
+			n += 1 + l + sovQueryrange(uint64(l))
+		}
+	}
+	return n
+}
+
 func sovQueryrange(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -2266,6 +2426,17 @@ func (this *LokiPromResponse) String() string {
 	}, "")
 	return s
 }
+func (this *IndexStatsResponse) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{`&IndexStatsResponse{`,
+		`Response:` + fmt.Sprintf("%v", this.Response) + `,`,
+		`Headers:` + fmt.Sprintf("%v", this.Headers) + `,`,
+		`}`,
+	}, "")
+	return s
+}
 func valueToStringQueryrange(v interface{}) string {
 	rv := reflect.ValueOf(v)
 	if rv.IsNil() {
@@ -4106,6 +4277,129 @@ func (m *LokiPromResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *IndexStatsResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQueryrange
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: IndexStatsResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: IndexStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Response", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQueryrange
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQueryrange
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQueryrange
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Response == nil {
+				m.Response = &github_com_grafana_loki_pkg_storage_stores_shipper_indexgateway_indexgatewaypb.IndexStatsResponse{}
+			}
+			if err := m.Response.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Headers", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQueryrange
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQueryrange
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQueryrange
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Headers = append(m.Headers, github_com_grafana_loki_pkg_querier_queryrange_queryrangebase.PrometheusResponseHeader{})
+			if err := m.Headers[len(m.Headers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQueryrange(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthQueryrange
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthQueryrange
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipQueryrange(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0

pkg/querier/queryrange/queryrange.proto

@@ -7,6 +7,7 @@ import "google/protobuf/timestamp.proto";
 import "pkg/logproto/logproto.proto";
 import "pkg/logqlmodel/stats/stats.proto";
 import "pkg/querier/queryrange/queryrangebase/queryrange.proto";
+import "pkg/storage/stores/shipper/indexgateway/indexgatewaypb/gateway.proto";
 
 option (gogoproto.marshaler_all) = true;
 option (gogoproto.unmarshaler_all) = true;
@@ -133,3 +134,11 @@ message LokiPromResponse {
   queryrangebase.PrometheusResponse response = 1 [(gogoproto.nullable) = true];
   stats.Result statistics = 2 [(gogoproto.nullable) = false];
 }
+
+message IndexStatsResponse {
+  indexgatewaypb.IndexStatsResponse response = 1 [(gogoproto.customtype) = "github.com/grafana/loki/pkg/storage/stores/shipper/indexgateway/indexgatewaypb.IndexStatsResponse"];
+  repeated queryrangebase.PrometheusResponseHeader Headers = 2 [
+    (gogoproto.jsontag) = "-",
+    (gogoproto.customtype) = "github.com/grafana/loki/pkg/querier/queryrange/queryrangebase.PrometheusResponseHeader"
+  ];
+}

pkg/querier/queryrange/roundtrip.go

@@ -225,6 +225,7 @@ const (
 	QueryRangeOp   = "query_range"
 	SeriesOp       = "series"
 	LabelNamesOp   = "labels"
+	IndexStatsOp   = "index_stats"
 )
 
 func getOperation(path string) string {
@@ -237,6 +238,8 @@ func getOperation(path string) string {
 		return LabelNamesOp
 	case strings.HasSuffix(path, "/v1/query"):
 		return InstantQueryOp
+	case path == "/loki/api/v1/index/stats":
+		return IndexStatsOp
 	default:
 		return ""
 	}

pkg/storage/stores/shipper/indexgateway/indexgatewaypb/compat.go

@@ -0,0 +1,59 @@
+package indexgatewaypb
+
+import (
+	"time"
+
+	"github.com/opentracing/opentracing-go"
+	otlog "github.com/opentracing/opentracing-go/log"
+	"github.com/prometheus/common/model"
+	"github.com/prometheus/prometheus/model/timestamp"
+
+	"github.com/grafana/loki/pkg/querier/queryrange/queryrangebase"
+)
+
+// Satisfy queryrangebase.Request
+
+// GetStart returns the start timestamp of the request in milliseconds.
+func (m *IndexStatsRequest) GetStart() int64 {
+	return m.From.UnixNano() / (int64(time.Millisecond) / int64(time.Nanosecond))
+}
+
+// GetEnd returns the end timestamp of the request in milliseconds.
+func (m *IndexStatsRequest) GetEnd() int64 {
+	return m.Through.UnixNano() / (int64(time.Millisecond) / int64(time.Nanosecond))
+}
+
+// GetStep returns the step of the request in milliseconds.
+func (m *IndexStatsRequest) GetStep() int64 { return 0 }
+
+// GetQuery returns the query of the request.
+func (m *IndexStatsRequest) GetQuery() string {
+	return m.Matchers
+}
+
+// GetCachingOptions returns the caching options.
+func (m *IndexStatsRequest) GetCachingOptions() (res queryrangebase.CachingOptions) { return }
+
+// WithStartEnd clone the current request with different start and end timestamp.
+func (m *IndexStatsRequest) WithStartEnd(startTime int64, endTime int64) queryrangebase.Request {
+	new := *m
+	new.From = model.TimeFromUnixNano(startTime * int64(time.Millisecond))
+	new.Through = model.TimeFromUnixNano(endTime * int64(time.Millisecond))
+	return &new
+}
+
+// WithQuery clone the current request with a different query.
+func (m *IndexStatsRequest) WithQuery(query string) queryrangebase.Request {
+	new := *m
+	new.Matchers = query
+	return &new
+}
+
+// LogToSpan writes information about this request to an OpenTracing span
+func (m *IndexStatsRequest) LogToSpan(sp opentracing.Span) {
+	sp.LogFields(
+		otlog.String("query", m.GetQuery()),
+		otlog.String("start", timestamp.Time(m.GetStart()).String()),
+		otlog.String("end", timestamp.Time(m.GetEnd()).String()),
+	)
+}

pkg/storage/stores/shipper/indexgateway/indexgatewaypb/gateway.pb.go

@@ -748,65 +748,66 @@ func init() {
 }
 
 var fileDescriptor_33a7bd4603d312b2 = []byte{
-	// 920 bytes of a gzipped FileDescriptorProto
+	// 931 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0x4f, 0x6f, 0x1b, 0x45,
-	0x14, 0xf7, 0xd8, 0x5b, 0x27, 0x7e, 0x31, 0xd0, 0x4e, 0x51, 0xb1, 0x0c, 0x5d, 0xa7, 0x8b, 0x20,
-	0x11, 0x12, 0x5e, 0x28, 0xb9, 0x20, 0xc4, 0x01, 0x17, 0x88, 0x22, 0x4a, 0x55, 0x26, 0x50, 0xc1,
-	0x09, 0x8d, 0x9d, 0xf1, 0xee, 0x92, 0x5d, 0xcf, 0x76, 0x76, 0x96, 0x34, 0x37, 0xbe, 0x00, 0x12,
-	0xdf, 0x02, 0x3e, 0x05, 0x20, 0x4e, 0x3d, 0x86, 0x5b, 0xc5, 0xc1, 0x22, 0xce, 0x05, 0xe5, 0xd4,
-	0x8f, 0x80, 0xf6, 0xed, 0x5f, 0xdb, 0x49, 0x90, 0x4a, 0x2e, 0x3d, 0xed, 0xbc, 0xdf, 0x7b, 0x6f,
-	0xe6, 0xf7, 0x9b, 0x79, 0xf3, 0x66, 0xe1, 0xe3, 0x70, 0xdf, 0xb1, 0x23, 0x2d, 0x15, 0x77, 0x04,
-	0x7e, 0x45, 0x64, 0x47, 0xae, 0x17, 0x86, 0x42, 0xd9, 0xde, 0x64, 0x4f, 0x3c, 0x72, 0xb8, 0x16,
-	0x07, 0xfc, 0x70, 0xce, 0x08, 0x87, 0x76, 0x36, 0xea, 0x87, 0x4a, 0x6a, 0x49, 0x5f, 0x9c, 0xf7,
-	0x76, 0xdf, 0x76, 0x3c, 0xed, 0xc6, 0xc3, 0xfe, 0x48, 0x06, 0xb6, 0x23, 0x1d, 0x69, 0x63, 0xd8,
-	0x30, 0x1e, 0xa3, 0x85, 0x06, 0x8e, 0xd2, 0xf4, 0xee, 0xab, 0x09, 0x09, 0x5f, 0x3a, 0xa9, 0x23,
-	0x1f, 0xa4, 0x4e, 0xeb, 0xc7, 0x3a, 0xf4, 0xee, 0xf2, 0xa1, 0xf0, 0x1f, 0x70, 0x3f, 0x16, 0xd1,
-	0xa7, 0x52, 0x7d, 0x2e, 0xb4, 0xf2, 0x46, 0xf7, 0x78, 0x20, 0x98, 0x78, 0x18, 0x8b, 0x48, 0xd3,
-	0x1e, 0xac, 0x05, 0x08, 0x7e, 0x3b, 0xe1, 0x81, 0xe8, 0x90, 0x75, 0xb2, 0xd9, 0x62, 0x10, 0x14,
-	0x71, 0xf4, 0x26, 0x80, 0x9f, 0xcc, 0x91, 0xfa, 0xeb, 0xe8, 0x6f, 0x21, 0x82, 0xee, 0x3b, 0x60,
-	0x8c, 0x95, 0x0c, 0x3a, 0x8d, 0x75, 0xb2, 0xd9, 0x18, 0xd8, 0x8f, 0xa7, 0xbd, 0xda, 0x5f, 0xd3,
-	0xde, 0x46, 0x45, 0x45, 0xa8, 0x64, 0x20, 0xb4, 0x2b, 0xe2, 0xc8, 0x1e, 0xc9, 0x20, 0x90, 0x13,
-	0x3b, 0x90, 0x7b, 0xc2, 0xef, 0x7f, 0xe9, 0x05, 0x82, 0x61, 0x32, 0xdd, 0x81, 0x15, 0xed, 0x2a,
-	0x19, 0x3b, 0x6e, 0xc7, 0x78, 0xb6, 0x79, 0xf2, 0x7c, 0xda, 0x85, 0xd5, 0x80, 0xeb, 0x91, 0x2b,
-	0x54, 0xd4, 0xb9, 0x82, 0x64, 0x0b, 0xdb, 0xfa, 0x93, 0x80, 0x79, 0x37, 0x67, 0xfe, 0x8c, 0xdb,
-	0x91, 0xeb, 0xad, 0x5f, 0x92, 0xde, 0xc6, 0xff, 0xd3, 0x6b, 0x6d, 0xc0, 0x0b, 0x28, 0x89, 0x89,
-	0x28, 0x94, 0x93, 0x48, 0xd0, 0x1b, 0xd0, 0xfc, 0x1e, 0x8f, 0xbb, 0x43, 0xd6, 0x1b, 0x9b, 0x2d,
-	0x96, 0x59, 0xd6, 0xef, 0x04, 0xe8, 0xb6, 0xd0, 0x77, 0xdc, 0x78, 0xb2, 0xcf, 0xc4, 0x38, 0x17,
-	0x9c, 0xeb, 0x21, 0x97, 0xa4, 0xa7, 0x7e, 0x89, 0xe7, 0xd7, 0x58, 0x38, 0xbf, 0x0f, 0xe1, 0xfa,
-	0x9c, 0x82, 0x4c, 0xf1, 0x9b, 0x60, 0x28, 0x31, 0x4e, 0xf5, 0xae, 0xdd, 0xa6, 0xfd, 0xe2, 0x16,
-	0x14, 0x91, 0xe8, 0xb7, 0x7e, 0x25, 0x70, 0x75, 0x5b, 0xe8, 0x5d, 0xa1, 0x3c, 0x11, 0x3d, 0x8f,
-	0xfa, 0x77, 0xe0, 0x5a, 0x85, 0x7f, 0xa6, 0x7e, 0x0b, 0x9a, 0x11, 0x22, 0x99, 0xfe, 0x1b, 0xfd,
-	0xf9, 0x8e, 0xd2, 0x4f, 0xe3, 0x07, 0x46, 0x42, 0x89, 0x65, 0xb1, 0x56, 0x08, 0xcd, 0x14, 0xa7,
-	0x63, 0x68, 0xe2, 0x6d, 0xce, 0xf3, 0xaf, 0x97, 0xfb, 0x87, 0x85, 0x75, 0x9f, 0x7b, 0x6a, 0xf0,
-	0x7e, 0xa6, 0xe7, 0xdd, 0x6a, 0x77, 0x52, 0x7c, 0xcc, 0x27, 0xdc, 0xf6, 0xe5, 0xbe, 0x67, 0x57,
-	0xdb, 0x50, 0x9a, 0xf7, 0xd1, 0x1e, 0x0f, 0xb5, 0x50, 0x2c, 0x9b, 0xdd, 0xfa, 0x06, 0xe8, 0x17,
-	0xb1, 0x50, 0x87, 0x3b, 0x09, 0xbb, 0x82, 0x7d, 0x17, 0x56, 0x11, 0xfd, 0x4c, 0x1c, 0x66, 0x97,
-	0xad, 0xb0, 0xe9, 0x06, 0x18, 0x4a, 0x1e, 0x44, 0x9d, 0x7a, 0xc6, 0x6b, 0x41, 0x17, 0x93, 0x07,
-	0x0c, 0x03, 0xac, 0x0f, 0xa0, 0xc1, 0xe4, 0x01, 0x35, 0x01, 0x14, 0x9f, 0x38, 0x02, 0xbb, 0x1d,
-	0xce, 0xd6, 0x66, 0x15, 0x84, 0xbe, 0x0c, 0x57, 0xf0, 0x2e, 0xe0, 0x19, 0xb5, 0x59, 0x6a, 0x24,
-	0x9b, 0x5a, 0xe5, 0x95, 0x56, 0xc5, 0x16, 0xac, 0x24, 0x60, 0xb9, 0xab, 0xdd, 0xc5, 0xd5, 0x31,
-	0x1c, 0x13, 0x59, 0x1e, 0x9a, 0x14, 0x18, 0x94, 0x38, 0x7d, 0x0d, 0x5a, 0x9a, 0x0f, 0x7d, 0x71,
-	0xaf, 0xec, 0x24, 0x25, 0x90, 0x78, 0x5d, 0x1e, 0xb9, 0x0f, 0x0a, 0x46, 0x2d, 0x56, 0x02, 0xf4,
-	0x2d, 0xb8, 0x5a, 0x32, 0xbf, 0xaf, 0xc4, 0xd8, 0x7b, 0x84, 0xe5, 0xd0, 0x66, 0x4b, 0x38, 0xdd,
-	0x84, 0x97, 0x4a, 0x6c, 0x57, 0x73, 0xa5, 0xb1, 0x8b, 0xb6, 0xd9, 0x22, 0x9c, 0xec, 0x10, 0x8a,
-	0xfe, 0xe4, 0x61, 0xcc, 0x7d, 0x6c, 0x8f, 0x6d, 0x56, 0x41, 0xac, 0xdf, 0x08, 0x5c, 0x43, 0x01,
-	0xbb, 0x9a, 0xeb, 0xe7, 0xf2, 0x8a, 0xfc, 0x4c, 0x80, 0x56, 0x15, 0x64, 0x65, 0xf6, 0x06, 0xac,
-	0x44, 0x5a, 0x09, 0x1e, 0x44, 0xa8, 0xc2, 0x18, 0xac, 0x9d, 0x4e, 0x7b, 0x39, 0xc4, 0xf2, 0x01,
-	0xb5, 0xa0, 0x39, 0x4a, 0x7a, 0x46, 0x84, 0x1c, 0x8d, 0x01, 0x9c, 0x4e, 0x7b, 0x19, 0xc2, 0xb2,
-	0x2f, 0xed, 0xc1, 0x95, 0xe1, 0xa1, 0x16, 0xe9, 0xd2, 0xc6, 0xa0, 0x75, 0x3a, 0xed, 0xa5, 0x00,
-	0x4b, 0x3f, 0xc9, 0x5a, 0x62, 0xa2, 0xb1, 0x76, 0x8c, 0x72, 0xad, 0x0c, 0x62, 0xf9, 0xe0, 0xf6,
-	0x1f, 0x06, 0xb4, 0x91, 0xe9, 0x76, 0x5a, 0x53, 0xf4, 0x2b, 0x80, 0xb2, 0x10, 0xe9, 0xad, 0xc5,
-	0x82, 0x5b, 0x2a, 0xd2, 0xae, 0x75, 0x51, 0x48, 0x2a, 0xfc, 0x1d, 0x42, 0xbf, 0x86, 0xb5, 0x4a,
-	0xd3, 0xa4, 0x4b, 0x49, 0xcb, 0x6f, 0x42, 0xf7, 0xf5, 0x0b, 0x63, 0xd2, 0x99, 0xad, 0x1a, 0x65,
-	0xd0, 0x2a, 0xda, 0x11, 0x5d, 0x3f, 0x23, 0x67, 0xae, 0xd3, 0x76, 0x6f, 0x5d, 0x10, 0x51, 0xcc,
-	0xf9, 0x1d, 0xbc, 0x72, 0xce, 0x0b, 0x4d, 0xfb, 0x8b, 0xf9, 0x17, 0x3f, 0xe5, 0xdd, 0x9b, 0x67,
-	0xc6, 0x57, 0xd6, 0xf2, 0xa1, 0x73, 0xde, 0xdf, 0x11, 0xb5, 0xcf, 0x4c, 0x3e, 0xff, 0x3f, 0xea,
-	0xbf, 0x57, 0xdb, 0x85, 0xd5, 0x44, 0x70, 0x52, 0x96, 0xcb, 0x87, 0xbb, 0x74, 0xe9, 0x96, 0x0f,
-	0x77, 0xb9, 0xaa, 0xad, 0xda, 0x60, 0xeb, 0xe8, 0xd8, 0xac, 0x3d, 0x39, 0x36, 0x6b, 0x4f, 0x8f,
-	0x4d, 0xf2, 0xc3, 0xcc, 0x24, 0xbf, 0xcc, 0x4c, 0xf2, 0x78, 0x66, 0x92, 0xa3, 0x99, 0x49, 0xfe,
-	0x9e, 0x99, 0xe4, 0x9f, 0x99, 0x59, 0x7b, 0x3a, 0x33, 0xc9, 0x4f, 0x27, 0x66, 0xed, 0xe8, 0xc4,
-	0xac, 0x3d, 0x39, 0x31, 0x6b, 0xc3, 0x26, 0xb6, 0xe9, 0xf7, 0xfe, 0x0d, 0x00, 0x00, 0xff, 0xff,
-	0x79, 0x39, 0x20, 0x44, 0xc2, 0x0a, 0x00, 0x00,
+	0x14, 0xdf, 0xb1, 0x37, 0x4e, 0xfc, 0x62, 0xa0, 0x9d, 0xa2, 0x62, 0x2d, 0x74, 0x9d, 0x2e, 0x82,
+	0x44, 0x48, 0x78, 0xa1, 0xf4, 0x82, 0x10, 0x07, 0x5c, 0x20, 0x8a, 0x28, 0x51, 0x99, 0x40, 0x05,
+	0x5c, 0xd0, 0xd8, 0x19, 0xef, 0x2e, 0xd9, 0xf5, 0x6c, 0x67, 0x67, 0x49, 0x7d, 0xe3, 0xc0, 0x15,
+	0x89, 0x6f, 0x01, 0x9f, 0x02, 0x10, 0xa7, 0x1e, 0xc3, 0xad, 0xe2, 0x60, 0x11, 0xe7, 0x82, 0x72,
+	0xea, 0x47, 0x40, 0x3b, 0xfb, 0xd7, 0x76, 0x62, 0x44, 0x9b, 0x4b, 0x4e, 0x3b, 0xef, 0xf7, 0xde,
+	0x9b, 0x79, 0xbf, 0x99, 0x37, 0xbf, 0x1d, 0xf8, 0x30, 0x3c, 0x70, 0xec, 0x48, 0x72, 0x41, 0x1d,
+	0xa6, 0xbe, 0x2c, 0xb2, 0x23, 0xd7, 0x0b, 0x43, 0x26, 0x6c, 0x6f, 0xb4, 0xcf, 0x1e, 0x3a, 0x54,
+	0xb2, 0x43, 0x3a, 0x9e, 0x31, 0xc2, 0xbe, 0x9d, 0x8d, 0xba, 0xa1, 0xe0, 0x92, 0xe3, 0xe7, 0x67,
+	0xbd, 0xc6, 0x9b, 0x8e, 0x27, 0xdd, 0xb8, 0xdf, 0x1d, 0xf0, 0xc0, 0x76, 0xb8, 0xc3, 0x6d, 0x15,
+	0xd6, 0x8f, 0x87, 0xca, 0x52, 0x86, 0x1a, 0xa5, 0xe9, 0xc6, 0xcb, 0x49, 0x11, 0x3e, 0x77, 0x52,
+	0x47, 0x3e, 0x48, 0x9d, 0xd6, 0x8f, 0x35, 0xe8, 0xdc, 0xa5, 0x7d, 0xe6, 0xdf, 0xa7, 0x7e, 0xcc,
+	0xa2, 0x8f, 0xb9, 0xf8, 0x94, 0x49, 0xe1, 0x0d, 0x76, 0x69, 0xc0, 0x08, 0x7b, 0x10, 0xb3, 0x48,
+	0xe2, 0x0e, 0xac, 0x07, 0x0a, 0xfc, 0x66, 0x44, 0x03, 0xd6, 0x46, 0x1b, 0x68, 0xab, 0x49, 0x20,
+	0x28, 0xe2, 0xf0, 0x0d, 0x00, 0x3f, 0x99, 0x23, 0xf5, 0xd7, 0x94, 0xbf, 0xa9, 0x10, 0xe5, 0xbe,
+	0x03, 0xfa, 0x50, 0xf0, 0xa0, 0x5d, 0xdf, 0x40, 0x5b, 0xf5, 0x9e, 0xfd, 0x68, 0xd2, 0xd1, 0xfe,
+	0x9a, 0x74, 0x36, 0x2b, 0x2c, 0x42, 0xc1, 0x03, 0x26, 0x5d, 0x16, 0x47, 0xf6, 0x80, 0x07, 0x01,
+	0x1f, 0xd9, 0x01, 0xdf, 0x67, 0x7e, 0xf7, 0x73, 0x2f, 0x60, 0x44, 0x25, 0xe3, 0x1d, 0x58, 0x95,
+	0xae, 0xe0, 0xb1, 0xe3, 0xb6, 0xf5, 0xa7, 0x9b, 0x27, 0xcf, 0xc7, 0x06, 0xac, 0x05, 0x54, 0x0e,
+	0x5c, 0x26, 0xa2, 0xf6, 0x8a, 0x2a, 0xb6, 0xb0, 0xad, 0x3f, 0x11, 0x98, 0x77, 0xf3, 0xca, 0x9f,
+	0x72, 0x3b, 0x72, 0xbe, 0xb5, 0x0b, 0xe2, 0x5b, 0x7f, 0x36, 0xbe, 0xd6, 0x26, 0x3c, 0xa7, 0x28,
+	0x11, 0x16, 0x85, 0x7c, 0x14, 0x31, 0x7c, 0x1d, 0x1a, 0xdf, 0xa9, 0xe3, 0x6e, 0xa3, 0x8d, 0xfa,
+	0x56, 0x93, 0x64, 0x96, 0xf5, 0x3b, 0x02, 0xbc, 0xcd, 0xe4, 0x1d, 0x37, 0x1e, 0x1d, 0x10, 0x36,
+	0xcc, 0x09, 0xe7, 0x7c, 0xd0, 0x05, 0xf1, 0xa9, 0x5d, 0xe0, 0xf9, 0xd5, 0xe7, 0xce, 0xef, 0x7d,
+	0xb8, 0x36, 0xc3, 0x20, 0x63, 0xfc, 0x3a, 0xe8, 0x82, 0x0d, 0x53, 0xbe, 0xeb, 0xb7, 0x70, 0xb7,
+	0xb8, 0x05, 0x45, 0xa4, 0xf2, 0x5b, 0xbf, 0x22, 0xb8, 0xb2, 0xcd, 0xe4, 0x1e, 0x13, 0x1e, 0x8b,
+	0x2e, 0x23, 0xff, 0x1d, 0xb8, 0x5a, 0xa9, 0x3f, 0x63, 0x7f, 0x1b, 0x1a, 0x91, 0x42, 0x32, 0xfe,
+	0xd7, 0xbb, 0xb3, 0x8a, 0xd2, 0x4d, 0xe3, 0x7b, 0x7a, 0x52, 0x12, 0xc9, 0x62, 0xad, 0x10, 0x1a,
+	0x29, 0x8e, 0x87, 0xd0, 0x50, 0xb7, 0x39, 0xcf, 0xbf, 0x56, 0xee, 0x9f, 0x6a, 0xac, 0x7b, 0xd4,
+	0x13, 0xbd, 0x77, 0x33, 0x3e, 0x6f, 0x57, 0xd5, 0x49, 0xd0, 0x21, 0x1d, 0x51, 0xdb, 0xe7, 0x07,
+	0x9e, 0x5d, 0x95, 0xa1, 0x34, 0xef, 0x83, 0x7d, 0x1a, 0x4a, 0x26, 0x48, 0x36, 0xbb, 0xf5, 0x15,
+	0xe0, 0xcf, 0x62, 0x26, 0xc6, 0x3b, 0x49, 0x75, 0x45, 0xf5, 0x06, 0xac, 0x29, 0xf4, 0x13, 0x36,
+	0xce, 0x2e, 0x5b, 0x61, 0xe3, 0x4d, 0xd0, 0x05, 0x3f, 0x8c, 0xda, 0xb5, 0xac, 0xae, 0x39, 0x5e,
+	0x84, 0x1f, 0x12, 0x15, 0x60, 0xbd, 0x07, 0x75, 0xc2, 0x0f, 0xb1, 0x09, 0x20, 0xe8, 0xc8, 0x61,
+	0x4a, 0xed, 0xd4, 0x6c, 0x2d, 0x52, 0x41, 0xf0, 0x8b, 0xb0, 0xa2, 0xee, 0x82, 0x3a, 0xa3, 0x16,
+	0x49, 0x8d, 0x64, 0x53, 0xab, 0x75, 0xa5, 0x5d, 0x71, 0x1b, 0x56, 0x13, 0xb0, 0xdc, 0x55, 0x63,
+	0x7e, 0x75, 0x15, 0xae, 0x12, 0x49, 0x1e, 0x9a, 0x34, 0x18, 0x94, 0x38, 0x7e, 0x05, 0x9a, 0x92,
+	0xf6, 0x7d, 0xb6, 0x5b, 0x2a, 0x49, 0x09, 0x24, 0x5e, 0x97, 0x46, 0xee, 0xfd, 0xa2, 0xa2, 0x26,
+	0x29, 0x01, 0xfc, 0x06, 0x5c, 0x29, 0x2b, 0xbf, 0x27, 0xd8, 0xd0, 0x7b, 0xa8, 0xda, 0xa1, 0x45,
+	0x16, 0x70, 0xbc, 0x05, 0x2f, 0x94, 0xd8, 0x9e, 0xa4, 0x42, 0x2a, 0x15, 0x6d, 0x91, 0x79, 0x38,
+	0xd9, 0x21, 0x45, 0xfa, 0xa3, 0x07, 0x31, 0xf5, 0x95, 0x3c, 0xb6, 0x48, 0x05, 0xb1, 0x7e, 0x43,
+	0x70, 0x55, 0x11, 0xd8, 0x93, 0x54, 0x5e, 0xca, 0x2b, 0xf2, 0x33, 0x02, 0x5c, 0x65, 0x90, 0xb5,
+	0xd9, 0x6b, 0xb0, 0x1a, 0x49, 0xc1, 0x68, 0x10, 0x29, 0x16, 0x7a, 0x6f, 0xfd, 0x74, 0xd2, 0xc9,
+	0x21, 0x92, 0x0f, 0xb0, 0x05, 0x8d, 0x41, 0xa2, 0x19, 0x91, 0xaa, 0x51, 0xef, 0xc1, 0xe9, 0xa4,
+	0x93, 0x21, 0x24, 0xfb, 0xe2, 0x0e, 0xac, 0xf4, 0xc7, 0x92, 0xa5, 0x4b, 0xeb, 0xbd, 0xe6, 0xe9,
+	0xa4, 0x93, 0x02, 0x24, 0xfd, 0x24, 0x6b, 0xb1, 0x91, 0x54, 0xbd, 0xa3, 0x97, 0x6b, 0x65, 0x10,
+	0xc9, 0x07, 0xb7, 0xfe, 0xd0, 0xa1, 0xa5, 0x2a, 0xdd, 0x4e, 0x7b, 0x0a, 0x7f, 0x01, 0x50, 0x36,
+	0x22, 0xbe, 0x39, 0xdf, 0x70, 0x0b, 0x4d, 0x6a, 0x58, 0xcb, 0x42, 0x52, 0xe2, 0x6f, 0x21, 0xfc,
+	0x25, 0xac, 0x57, 0x44, 0x13, 0x2f, 0x24, 0x2d, 0xfe, 0x13, 0x8c, 0x57, 0x97, 0xc6, 0xa4, 0x33,
+	0x5b, 0x1a, 0x26, 0xd0, 0x2c, 0xe4, 0x08, 0x6f, 0x9c, 0x91, 0x33, 0xa3, 0xb4, 0xc6, 0xcd, 0x25,
+	0x11, 0xc5, 0x9c, 0xdf, 0xc2, 0x4b, 0xe7, 0xfc, 0xa1, 0x71, 0x77, 0x3e, 0x7f, 0xf9, 0xaf, 0xdc,
+	0xb8, 0x71, 0x66, 0x7c, 0x65, 0x2d, 0x1f, 0xda, 0xe7, 0xbd, 0x8e, 0xb0, 0x7d, 0x66, 0xf2, 0xf9,
+	0xef, 0xa8, 0xff, 0x5e, 0x6d, 0x0f, 0xd6, 0x12, 0xc2, 0x49, 0x5b, 0x2e, 0x1e, 0xee, 0xc2, 0xa5,
+	0x5b, 0x3c, 0xdc, 0xc5, 0xae, 0xb6, 0xb4, 0xde, 0x0f, 0xe8, 0xe8, 0xd8, 0xd4, 0x1e, 0x1f, 0x9b,
+	0xda, 0x93, 0x63, 0x13, 0x7d, 0x3f, 0x35, 0xd1, 0x2f, 0x53, 0x13, 0x3d, 0x9a, 0x9a, 0xe8, 0x68,
+	0x6a, 0xa2, 0xbf, 0xa7, 0x26, 0xfa, 0x67, 0x6a, 0x6a, 0x4f, 0xa6, 0x26, 0xfa, 0xe9, 0xc4, 0xd4,
+	0x8e, 0x4e, 0x4c, 0xed, 0xf1, 0x89, 0xa9, 0x7d, 0xbd, 0xbb, 0x4c, 0xc6, 0xff, 0xff, 0x93, 0xb6,
+	0xdf, 0x50, 0xba, 0xff, 0xce, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x32, 0x10, 0x4c, 0x62, 0x13,
+	0x0b, 0x00, 0x00,
 }
 
 func (this *LabelValuesForMetricNameRequest) Equal(that interface{}) bool {

pkg/storage/stores/shipper/indexgateway/indexgatewaypb/gateway.proto

@@ -5,6 +5,8 @@ package indexgatewaypb;
 import "github.com/gogo/protobuf/gogoproto/gogo.proto";
 import "pkg/logproto/logproto.proto";
 
+option go_package = "github.com/grafana/loki/pkg/storage/stores/shipper/indexgateway/indexgatewaypb";
+
 service IndexGateway {
   /// QueryIndex reads the indexes required for given query & sends back the batch of rows
   /// in rpc streams

pkg/storage/stores/tsdb/index_client.go

@@ -30,7 +30,9 @@ func NewIndexClient(idx Index) *IndexClient {
 // In the future, we should use dynamic sharding in TSDB to determine the shard factors
 // and we may no longer wish to send a shard label inside the queries,
 // but rather expose it as part of the stores.Index interface
-func (c *IndexClient) shard(matchers ...*labels.Matcher) ([]*labels.Matcher, *index.ShardAnnotation, error) {
+func cleanMatchers(matchers ...*labels.Matcher) ([]*labels.Matcher, *index.ShardAnnotation, error) {
+	// first use withoutNameLabel to make a copy with the name label removed
+	matchers = withoutNameLabel(matchers)
 	s, shardLabelIndex, err := astmapper.ShardFromMatchers(matchers)
 	if err != nil {
 		return nil, nil, err
@@ -45,6 +47,11 @@ func (c *IndexClient) shard(matchers ...*labels.Matcher) ([]*labels.Matcher, *in
 		}
 	}
 
+	if len(matchers) == 0 {
+		// hack to query all data
+		matchers = append(matchers, labels.MustNewMatcher(labels.MatchEqual, "", ""))
+	}
+
 	return matchers, shard, err
 
 }
@@ -53,8 +60,7 @@ func (c *IndexClient) shard(matchers ...*labels.Matcher) ([]*labels.Matcher, *in
 // They share almost the same fields, so we can add the missing `KB` field to the proto and then
 // use that within the tsdb package.
 func (c *IndexClient) GetChunkRefs(ctx context.Context, userID string, from, through model.Time, matchers ...*labels.Matcher) ([]logproto.ChunkRef, error) {
-	matchers = withoutNameLabel(matchers)
-	matchers, shard, err := c.shard(matchers...)
+	matchers, shard, err := cleanMatchers(matchers...)
 	if err != nil {
 		return nil, err
 	}
@@ -80,8 +86,7 @@ func (c *IndexClient) GetChunkRefs(ctx context.Context, userID string, from, thr
 }
 
 func (c *IndexClient) GetSeries(ctx context.Context, userID string, from, through model.Time, matchers ...*labels.Matcher) ([]labels.Labels, error) {
-	matchers = withoutNameLabel(matchers)
-	matchers, shard, err := c.shard(matchers...)
+	matchers, shard, err := cleanMatchers(matchers...)
 	if err != nil {
 		return nil, err
 	}
@@ -100,7 +105,10 @@ func (c *IndexClient) GetSeries(ctx context.Context, userID string, from, throug
 
 // tsdb no longer uses the __metric_name__="logs" hack, so we can ignore metric names!
 func (c *IndexClient) LabelValuesForMetricName(ctx context.Context, userID string, from, through model.Time, _ string, labelName string, matchers ...*labels.Matcher) ([]string, error) {
-	matchers = withoutNameLabel(matchers)
+	matchers, _, err := cleanMatchers(matchers...)
+	if err != nil {
+		return nil, err
+	}
 	return c.idx.LabelValues(ctx, userID, from, through, labelName, matchers...)
 }
 
@@ -110,8 +118,7 @@ func (c *IndexClient) LabelNamesForMetricName(ctx context.Context, userID string
 }
 
 func (c *IndexClient) Stats(ctx context.Context, userID string, from, through model.Time, matchers ...*labels.Matcher) (*stats.Stats, error) {
-	matchers = withoutNameLabel(matchers)
-	matchers, shard, err := c.shard(matchers...)
+	matchers, shard, err := cleanMatchers(matchers...)
 	if err != nil {
 		return nil, err
 	}