[TSDB] Ingester Index Sampling (#6852)

* queryrangebase definitions protos & aliases
Signed-off-by: Owen Diehl <ow.diehl@gmail.com>

* indexgatewaypb to logproto
Signed-off-by: Owen Diehl <ow.diehl@gmail.com>

* updates queryrange.proto for new definitions file
Signed-off-by: Owen Diehl <ow.diehl@gmail.com>

* s/indexgatewaypb/logproto/g
Signed-off-by: Owen Diehl <ow.diehl@gmail.com>

* renames to indexseries for clobbering reasons
Signed-off-by: Owen Diehl <ow.diehl@gmail.com>

* more indexgatewaypb removal compatibility work
Signed-off-by: Owen Diehl <ow.diehl@gmail.com>

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

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

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

* query ingesters for index stats
Signed-off-by: Owen Diehl <ow.diehl@gmail.com>

* compatibility during rollouts for idx-gw+ingester-querier post proto refactor
Signed-off-by: Owen Diehl <ow.diehl@gmail.com>

* proto compatibility with old indexgateway pkg path
Signed-off-by: Owen Diehl <ow.diehl@gmail.com>

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

* gofmt
Signed-off-by: Owen Diehl <ow.diehl@gmail.com>
pull/6856/head
Owen Diehl 3 years ago committed by GitHub
parent bab049ca6f
commit 57cec8e496
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
  1. 5
      pkg/ingester/flush_test.go
  2. 47
      pkg/ingester/ingester.go
  3. 5
      pkg/ingester/ingester_test.go
  4. 49
      pkg/ingester/instance.go
  5. 353
      pkg/logproto/indexgateway.pb.go
  6. 25
      pkg/logproto/indexgateway.proto
  7. 596
      pkg/logproto/logproto.pb.go
  8. 18
      pkg/logproto/logproto.proto
  9. 43
      pkg/querier/ingester_querier.go
  10. 42
      pkg/storage/async_store.go

@ -32,6 +32,7 @@ import (
"github.com/grafana/loki/pkg/storage/chunk"
"github.com/grafana/loki/pkg/storage/chunk/fetcher"
"github.com/grafana/loki/pkg/storage/config"
"github.com/grafana/loki/pkg/storage/stores/index/stats"
"github.com/grafana/loki/pkg/validation"
)
@ -345,6 +346,10 @@ func (s *testStore) Stop() {}
func (s *testStore) SetChunkFilterer(_ chunk.RequestChunkFilterer) {}
func (s *testStore) Stats(ctx context.Context, userID string, from, through model.Time, matchers ...*labels.Matcher) (*stats.Stats, error) {
return &stats.Stats{}, nil
}
func pushTestSamples(t *testing.T, ing logproto.PusherServer) map[string][]logproto.Stream {
userIDs := []string{"1", "2", "3"}

@ -11,6 +11,7 @@ import (
"time"
"github.com/go-kit/log/level"
"github.com/grafana/dskit/concurrency"
"github.com/grafana/dskit/modules"
"github.com/grafana/dskit/ring"
"github.com/grafana/dskit/services"
@ -35,6 +36,7 @@ import (
"github.com/grafana/loki/pkg/storage/chunk"
"github.com/grafana/loki/pkg/storage/chunk/fetcher"
"github.com/grafana/loki/pkg/storage/config"
index_stats "github.com/grafana/loki/pkg/storage/stores/index/stats"
"github.com/grafana/loki/pkg/usagestats"
"github.com/grafana/loki/pkg/util"
errUtil "github.com/grafana/loki/pkg/util"
@ -162,6 +164,7 @@ type ChunkStore interface {
SelectSamples(ctx context.Context, req logql.SelectSampleParams) (iter.SampleIterator, error)
GetChunkRefs(ctx context.Context, userID string, from, through model.Time, matchers ...*labels.Matcher) ([][]chunk.Chunk, []*fetcher.Fetcher, error)
GetSchemaConfigs() []config.PeriodConfig
Stats(ctx context.Context, userID string, from, through model.Time, matchers ...*labels.Matcher) (*index_stats.Stats, error)
}
// Interface is an interface for the Ingester
@ -864,6 +867,50 @@ func (i *Ingester) Series(ctx context.Context, req *logproto.SeriesRequest) (*lo
return instance.Series(ctx, req)
}
func (i *Ingester) GetStats(ctx context.Context, req *logproto.IndexStatsRequest) (*logproto.IndexStatsResponse, error) {
user, err := tenant.TenantID(ctx)
if err != nil {
return nil, err
}
instance, err := i.GetOrCreateInstance(user)
if err != nil {
return nil, err
}
matchers, err := syntax.ParseMatchers(req.Matchers)
if err != nil {
return nil, err
}
type f func() (*logproto.IndexStatsResponse, error)
jobs := []f{
f(func() (*logproto.IndexStatsResponse, error) {
return instance.GetStats(ctx, req)
}),
f(func() (*logproto.IndexStatsResponse, error) {
return i.store.Stats(ctx, user, req.From, req.Through, matchers...)
}),
}
resps := make([]*logproto.IndexStatsResponse, len(jobs))
if err := concurrency.ForEachJob(
ctx,
len(jobs),
2,
func(ctx context.Context, idx int) error {
res, err := jobs[idx]()
resps[idx] = res
return err
},
); err != nil {
return nil, err
}
merged := index_stats.MergeStats(resps...)
return &merged, nil
}
// Watch implements grpc_health_v1.HealthCheck.
func (*Ingester) Watch(*grpc_health_v1.HealthCheckRequest, grpc_health_v1.Health_WatchServer) error {
return nil

@ -36,6 +36,7 @@ import (
"github.com/grafana/loki/pkg/storage/chunk"
"github.com/grafana/loki/pkg/storage/chunk/fetcher"
"github.com/grafana/loki/pkg/storage/config"
"github.com/grafana/loki/pkg/storage/stores/index/stats"
"github.com/grafana/loki/pkg/validation"
)
@ -318,6 +319,10 @@ func (s *mockStore) GetChunkFetcher(tm model.Time) *fetcher.Fetcher {
return nil
}
func (s *mockStore) Stats(ctx context.Context, userID string, from, through model.Time, matchers ...*labels.Matcher) (*stats.Stats, error) {
return &stats.Stats{}, nil
}
func (s *mockStore) Stop() {}
type mockQuerierServer struct {

@ -498,7 +498,7 @@ func (i *instance) Series(ctx context.Context, req *logproto.SeriesRequest) (*lo
series = make([]logproto.SeriesIdentifier, 0, i.streams.Len())
err = i.forMatchingStreams(ctx, req.Start, nil, shard, func(stream *stream) error {
// consider the stream only if it overlaps the request time range
if shouldConsiderStream(stream, req) {
if shouldConsiderStream(stream, req.Start, req.End) {
series = append(series, logproto.SeriesIdentifier{
Labels: stream.labels.Map(),
})
@ -513,7 +513,7 @@ func (i *instance) Series(ctx context.Context, req *logproto.SeriesRequest) (*lo
for _, matchers := range groups {
err = i.forMatchingStreams(ctx, req.Start, matchers, shard, func(stream *stream) error {
// consider the stream only if it overlaps the request time range
if shouldConsiderStream(stream, req) {
if shouldConsiderStream(stream, req.Start, req.End) {
// exit early when this stream was added by an earlier group
key := stream.labels.Hash()
if _, found := dedupedSeries[key]; found {
@ -539,6 +539,47 @@ func (i *instance) Series(ctx context.Context, req *logproto.SeriesRequest) (*lo
return &logproto.SeriesResponse{Series: series}, nil
}
func (i *instance) GetStats(ctx context.Context, req *logproto.IndexStatsRequest) (*logproto.IndexStatsResponse, error) {
matchers, err := syntax.ParseMatchers(req.Matchers)
if err != nil {
return nil, err
}
res := &logproto.IndexStatsResponse{}
from, through := req.From.Time(), req.Through.Time()
if err = i.forMatchingStreams(ctx, from, matchers, nil, func(s *stream) error {
// checks for equality against chunk flush fields
var zeroValueTime time.Time
// Consider streams which overlap our time range
if shouldConsiderStream(s, from, through) {
s.chunkMtx.RLock()
res.Streams++
for _, chk := range s.chunks {
// Consider chunks which overlap our time range
// and haven't been flushed.
// Flushed chunks will already be counted
// by the TSDB manager+shipper
chkFrom, chkThrough := chk.chunk.Bounds()
if !chk.flushed.Equal(zeroValueTime) && from.Before(chkThrough) && through.After(chkFrom) {
res.Chunks++
res.Entries += uint64(chk.chunk.Size())
res.Bytes += uint64(chk.chunk.UncompressedSize())
}
}
s.chunkMtx.RUnlock()
}
return nil
}); err != nil {
return nil, err
}
return res, nil
}
func (i *instance) numStreams() int {
return i.streams.Len()
}
@ -773,10 +814,10 @@ func sendSampleBatches(ctx context.Context, it iter.SampleIterator, queryServer
return nil
}
func shouldConsiderStream(stream *stream, req *logproto.SeriesRequest) bool {
func shouldConsiderStream(stream *stream, reqFrom, reqThrough time.Time) bool {
from, to := stream.Bounds()
if req.End.UnixNano() > from.UnixNano() && req.Start.UnixNano() <= to.UnixNano() {
if reqThrough.UnixNano() > from.UnixNano() && reqFrom.UnixNano() <= to.UnixNano() {
return true
}
return false

@ -0,0 +1,353 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: pkg/logproto/indexgateway.proto
package logproto
import (
context "context"
fmt "fmt"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
func init() { proto.RegisterFile("pkg/logproto/indexgateway.proto", fileDescriptor_d27585148d0a52c8) }
var fileDescriptor_d27585148d0a52c8 = []byte{
// 360 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xb1, 0x4e, 0xf3, 0x30,
0x14, 0x85, 0x6d, 0xfd, 0xd2, 0x2f, 0x30, 0x88, 0xc1, 0x4b, 0x51, 0x0a, 0x46, 0x42, 0x0c, 0x30,
0xd0, 0x20, 0x78, 0x03, 0x90, 0x1a, 0x55, 0x2a, 0x48, 0x14, 0x89, 0xa1, 0x03, 0xc2, 0x29, 0xb7,
0x69, 0xd4, 0x34, 0x0e, 0x89, 0x23, 0xe8, 0xc6, 0x23, 0xf0, 0x18, 0x3c, 0x0a, 0x63, 0xc7, 0x8e,
0xd4, 0x5d, 0x18, 0x3b, 0x33, 0xa1, 0x38, 0x4a, 0xeb, 0x56, 0xa9, 0xc4, 0x14, 0xfb, 0x9c, 0x73,
0xbf, 0xab, 0xf8, 0x5e, 0x72, 0x10, 0xf5, 0x3d, 0x3b, 0x10, 0x5e, 0x14, 0x0b, 0x29, 0x6c, 0x3f,
0x7c, 0x82, 0x57, 0x8f, 0x4b, 0x78, 0xe1, 0xc3, 0x9a, 0x96, 0xe8, 0x8e, 0xa9, 0x45, 0xae, 0x75,
0xea, 0xf9, 0xb2, 0x97, 0xba, 0xb5, 0x8e, 0x18, 0xd8, 0x9e, 0xf0, 0x84, 0xad, 0x63, 0x6e, 0xda,
0xd5, 0xb7, 0x1c, 0x93, 0x9d, 0xf2, 0x72, 0xab, 0xba, 0xc4, 0x2f, 0x0e, 0xb9, 0x79, 0xfe, 0xf3,
0x8f, 0x6c, 0x37, 0x32, 0xbc, 0x93, 0xe3, 0x69, 0x83, 0x90, 0xdb, 0x14, 0xe2, 0xa1, 0x16, 0x69,
0xb5, 0x36, 0xcf, 0x2f, 0xd4, 0x16, 0x3c, 0xa7, 0x90, 0x48, 0x6b, 0xaf, 0xdc, 0x4c, 0x22, 0x11,
0x26, 0x70, 0x86, 0x69, 0x93, 0x6c, 0x39, 0x20, 0xaf, 0x7a, 0x69, 0xd8, 0x6f, 0x41, 0x97, 0x1a,
0x71, 0x43, 0x2e, 0x60, 0xfb, 0x6b, 0xdc, 0x9c, 0x76, 0x88, 0x68, 0x9d, 0x6c, 0x3a, 0x20, 0xef,
0x20, 0xf6, 0x21, 0xa1, 0xd6, 0x52, 0x3a, 0x17, 0x0b, 0x52, 0xb5, 0xd4, 0x9b, 0x73, 0x1e, 0x48,
0xa5, 0xc9, 0x5d, 0x08, 0x6e, 0xf8, 0x00, 0x92, 0xba, 0x88, 0xaf, 0x41, 0xc6, 0x7e, 0x27, 0xbb,
0xd1, 0xe3, 0x45, 0xe5, 0x9a, 0x48, 0xd1, 0xa3, 0xb2, 0x92, 0x34, 0xf8, 0x8f, 0x64, 0x57, 0x4b,
0xf7, 0x3c, 0x48, 0x57, 0x1b, 0x9c, 0xac, 0x94, 0x95, 0x64, 0xfe, 0xd0, 0xc1, 0x21, 0x1b, 0xd9,
0x8f, 0x49, 0x2e, 0x13, 0x73, 0x40, 0xfa, 0xf9, 0xb5, 0x5a, 0x32, 0x20, 0xd3, 0x2c, 0x40, 0x97,
0xed, 0xd1, 0x84, 0xa1, 0xf1, 0x84, 0xa1, 0xd9, 0x84, 0xe1, 0x37, 0xc5, 0xf0, 0x87, 0x62, 0xf8,
0x53, 0x31, 0x3c, 0x52, 0x0c, 0x7f, 0x29, 0x86, 0xbf, 0x15, 0x43, 0x33, 0xc5, 0xf0, 0xfb, 0x94,
0xa1, 0xd1, 0x94, 0xa1, 0xf1, 0x94, 0xa1, 0xf6, 0x91, 0xb9, 0x7e, 0x31, 0xef, 0xf2, 0x90, 0xdb,
0x81, 0xe8, 0xfb, 0xb6, 0xb9, 0x67, 0xee, 0x7f, 0xfd, 0xb9, 0xf8, 0x0d, 0x00, 0x00, 0xff, 0xff,
0xf0, 0xa4, 0xc7, 0x87, 0xde, 0x02, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// IndexGatewayClient is the client API for IndexGateway service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type IndexGatewayClient interface {
/// QueryIndex reads the indexes required for given query & sends back the batch of rows
/// in rpc streams
QueryIndex(ctx context.Context, in *QueryIndexRequest, opts ...grpc.CallOption) (IndexGateway_QueryIndexClient, error)
/// GetChunkRef returns chunk reference that match the provided label matchers
GetChunkRef(ctx context.Context, in *GetChunkRefRequest, opts ...grpc.CallOption) (*GetChunkRefResponse, error)
GetSeries(ctx context.Context, in *GetSeriesRequest, opts ...grpc.CallOption) (*GetSeriesResponse, error)
LabelNamesForMetricName(ctx context.Context, in *LabelNamesForMetricNameRequest, opts ...grpc.CallOption) (*LabelResponse, error)
LabelValuesForMetricName(ctx context.Context, in *LabelValuesForMetricNameRequest, opts ...grpc.CallOption) (*LabelResponse, error)
// Note: this MUST be the same as the variant defined in
// logproto.proto on the Querier service.
GetStats(ctx context.Context, in *IndexStatsRequest, opts ...grpc.CallOption) (*IndexStatsResponse, error)
}
type indexGatewayClient struct {
cc *grpc.ClientConn
}
func NewIndexGatewayClient(cc *grpc.ClientConn) IndexGatewayClient {
return &indexGatewayClient{cc}
}
func (c *indexGatewayClient) QueryIndex(ctx context.Context, in *QueryIndexRequest, opts ...grpc.CallOption) (IndexGateway_QueryIndexClient, error) {
stream, err := c.cc.NewStream(ctx, &_IndexGateway_serviceDesc.Streams[0], "/indexgatewaypb.IndexGateway/QueryIndex", opts...)
if err != nil {
return nil, err
}
x := &indexGatewayQueryIndexClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type IndexGateway_QueryIndexClient interface {
Recv() (*QueryIndexResponse, error)
grpc.ClientStream
}
type indexGatewayQueryIndexClient struct {
grpc.ClientStream
}
func (x *indexGatewayQueryIndexClient) Recv() (*QueryIndexResponse, error) {
m := new(QueryIndexResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *indexGatewayClient) GetChunkRef(ctx context.Context, in *GetChunkRefRequest, opts ...grpc.CallOption) (*GetChunkRefResponse, error) {
out := new(GetChunkRefResponse)
err := c.cc.Invoke(ctx, "/indexgatewaypb.IndexGateway/GetChunkRef", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *indexGatewayClient) GetSeries(ctx context.Context, in *GetSeriesRequest, opts ...grpc.CallOption) (*GetSeriesResponse, error) {
out := new(GetSeriesResponse)
err := c.cc.Invoke(ctx, "/indexgatewaypb.IndexGateway/GetSeries", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *indexGatewayClient) LabelNamesForMetricName(ctx context.Context, in *LabelNamesForMetricNameRequest, opts ...grpc.CallOption) (*LabelResponse, error) {
out := new(LabelResponse)
err := c.cc.Invoke(ctx, "/indexgatewaypb.IndexGateway/LabelNamesForMetricName", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *indexGatewayClient) LabelValuesForMetricName(ctx context.Context, in *LabelValuesForMetricNameRequest, opts ...grpc.CallOption) (*LabelResponse, error) {
out := new(LabelResponse)
err := c.cc.Invoke(ctx, "/indexgatewaypb.IndexGateway/LabelValuesForMetricName", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *indexGatewayClient) GetStats(ctx context.Context, in *IndexStatsRequest, opts ...grpc.CallOption) (*IndexStatsResponse, error) {
out := new(IndexStatsResponse)
err := c.cc.Invoke(ctx, "/indexgatewaypb.IndexGateway/GetStats", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// IndexGatewayServer is the server API for IndexGateway service.
type IndexGatewayServer interface {
/// QueryIndex reads the indexes required for given query & sends back the batch of rows
/// in rpc streams
QueryIndex(*QueryIndexRequest, IndexGateway_QueryIndexServer) error
/// GetChunkRef returns chunk reference that match the provided label matchers
GetChunkRef(context.Context, *GetChunkRefRequest) (*GetChunkRefResponse, error)
GetSeries(context.Context, *GetSeriesRequest) (*GetSeriesResponse, error)
LabelNamesForMetricName(context.Context, *LabelNamesForMetricNameRequest) (*LabelResponse, error)
LabelValuesForMetricName(context.Context, *LabelValuesForMetricNameRequest) (*LabelResponse, error)
// Note: this MUST be the same as the variant defined in
// logproto.proto on the Querier service.
GetStats(context.Context, *IndexStatsRequest) (*IndexStatsResponse, error)
}
// UnimplementedIndexGatewayServer can be embedded to have forward compatible implementations.
type UnimplementedIndexGatewayServer struct {
}
func (*UnimplementedIndexGatewayServer) QueryIndex(req *QueryIndexRequest, srv IndexGateway_QueryIndexServer) error {
return status.Errorf(codes.Unimplemented, "method QueryIndex not implemented")
}
func (*UnimplementedIndexGatewayServer) GetChunkRef(ctx context.Context, req *GetChunkRefRequest) (*GetChunkRefResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetChunkRef not implemented")
}
func (*UnimplementedIndexGatewayServer) GetSeries(ctx context.Context, req *GetSeriesRequest) (*GetSeriesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetSeries not implemented")
}
func (*UnimplementedIndexGatewayServer) LabelNamesForMetricName(ctx context.Context, req *LabelNamesForMetricNameRequest) (*LabelResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method LabelNamesForMetricName not implemented")
}
func (*UnimplementedIndexGatewayServer) LabelValuesForMetricName(ctx context.Context, req *LabelValuesForMetricNameRequest) (*LabelResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method LabelValuesForMetricName not implemented")
}
func (*UnimplementedIndexGatewayServer) GetStats(ctx context.Context, req *IndexStatsRequest) (*IndexStatsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetStats not implemented")
}
func RegisterIndexGatewayServer(s *grpc.Server, srv IndexGatewayServer) {
s.RegisterService(&_IndexGateway_serviceDesc, srv)
}
func _IndexGateway_QueryIndex_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(QueryIndexRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(IndexGatewayServer).QueryIndex(m, &indexGatewayQueryIndexServer{stream})
}
type IndexGateway_QueryIndexServer interface {
Send(*QueryIndexResponse) error
grpc.ServerStream
}
type indexGatewayQueryIndexServer struct {
grpc.ServerStream
}
func (x *indexGatewayQueryIndexServer) Send(m *QueryIndexResponse) error {
return x.ServerStream.SendMsg(m)
}
func _IndexGateway_GetChunkRef_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetChunkRefRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(IndexGatewayServer).GetChunkRef(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/indexgatewaypb.IndexGateway/GetChunkRef",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IndexGatewayServer).GetChunkRef(ctx, req.(*GetChunkRefRequest))
}
return interceptor(ctx, in, info, handler)
}
func _IndexGateway_GetSeries_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetSeriesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(IndexGatewayServer).GetSeries(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/indexgatewaypb.IndexGateway/GetSeries",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IndexGatewayServer).GetSeries(ctx, req.(*GetSeriesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _IndexGateway_LabelNamesForMetricName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(LabelNamesForMetricNameRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(IndexGatewayServer).LabelNamesForMetricName(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/indexgatewaypb.IndexGateway/LabelNamesForMetricName",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IndexGatewayServer).LabelNamesForMetricName(ctx, req.(*LabelNamesForMetricNameRequest))
}
return interceptor(ctx, in, info, handler)
}
func _IndexGateway_LabelValuesForMetricName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(LabelValuesForMetricNameRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(IndexGatewayServer).LabelValuesForMetricName(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/indexgatewaypb.IndexGateway/LabelValuesForMetricName",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IndexGatewayServer).LabelValuesForMetricName(ctx, req.(*LabelValuesForMetricNameRequest))
}
return interceptor(ctx, in, info, handler)
}
func _IndexGateway_GetStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(IndexStatsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(IndexGatewayServer).GetStats(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/indexgatewaypb.IndexGateway/GetStats",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IndexGatewayServer).GetStats(ctx, req.(*IndexStatsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _IndexGateway_serviceDesc = grpc.ServiceDesc{
ServiceName: "indexgatewaypb.IndexGateway",
HandlerType: (*IndexGatewayServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "GetChunkRef",
Handler: _IndexGateway_GetChunkRef_Handler,
},
{
MethodName: "GetSeries",
Handler: _IndexGateway_GetSeries_Handler,
},
{
MethodName: "LabelNamesForMetricName",
Handler: _IndexGateway_LabelNamesForMetricName_Handler,
},
{
MethodName: "LabelValuesForMetricName",
Handler: _IndexGateway_LabelValuesForMetricName_Handler,
},
{
MethodName: "GetStats",
Handler: _IndexGateway_GetStats_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "QueryIndex",
Handler: _IndexGateway_QueryIndex_Handler,
ServerStreams: true,
},
},
Metadata: "pkg/logproto/indexgateway.proto",
}

@ -0,0 +1,25 @@
syntax = "proto3";
package indexgatewaypb;
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
import "pkg/logproto/logproto.proto";
option go_package = "github.com/grafana/loki/pkg/logproto";
// This exists in a different file to retain proto namespacing compatibility with it's prior definition, but has been relocated to the logproto go pkg.
service IndexGateway {
/// QueryIndex reads the indexes required for given query & sends back the batch of rows
/// in rpc streams
rpc QueryIndex(logproto.QueryIndexRequest) returns (stream logproto.QueryIndexResponse);
/// GetChunkRef returns chunk reference that match the provided label matchers
rpc GetChunkRef(logproto.GetChunkRefRequest) returns (logproto.GetChunkRefResponse) {}
rpc GetSeries(logproto.GetSeriesRequest) returns (logproto.GetSeriesResponse) {}
rpc LabelNamesForMetricName(logproto.LabelNamesForMetricNameRequest) returns (logproto.LabelResponse) {}
rpc LabelValuesForMetricName(logproto.LabelValuesForMetricNameRequest) returns (logproto.LabelResponse) {}
// Note: this MUST be the same as the variant defined in
// logproto.proto on the Querier service.
rpc GetStats(logproto.IndexStatsRequest) returns (logproto.IndexStatsResponse) {}
}

@ -2355,144 +2355,138 @@ func init() {
func init() { proto.RegisterFile("pkg/logproto/logproto.proto", fileDescriptor_c28a5f14f1f4c79a) }
var fileDescriptor_c28a5f14f1f4c79a = []byte{
// 2183 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xcd, 0x6f, 0x1b, 0xc7,
0x15, 0xe7, 0xf0, 0x4b, 0xe4, 0x23, 0x25, 0xd1, 0x63, 0x59, 0x62, 0x68, 0x9b, 0x94, 0x17, 0xa9,
0xcd, 0x3a, 0x36, 0x15, 0x2b, 0x6d, 0xe3, 0xd8, 0x4d, 0x0b, 0x51, 0x8a, 0x65, 0xd9, 0x8a, 0xa3,
0xac, 0x5c, 0x07, 0x08, 0xd0, 0xba, 0x2b, 0x72, 0x48, 0x2e, 0xc4, 0xe5, 0xd2, 0xbb, 0xc3, 0x38,
0x02, 0x0a, 0xb4, 0x7f, 0x40, 0x03, 0xa4, 0xa7, 0xa2, 0xf7, 0x02, 0x2d, 0x7a, 0xe8, 0xa1, 0x7f,
0x40, 0xdb, 0x5b, 0xdd, 0x9b, 0x7b, 0x0b, 0x72, 0x60, 0x6b, 0xf9, 0x52, 0x08, 0x3d, 0xe4, 0xdc,
0x43, 0x51, 0xcc, 0xd7, 0xee, 0x70, 0x45, 0x3a, 0xa6, 0x6b, 0xa0, 0xf0, 0x45, 0x9c, 0x79, 0x33,
0xf3, 0xde, 0xbc, 0xdf, 0xbc, 0xcf, 0x15, 0x9c, 0xee, 0xef, 0xb7, 0x57, 0xba, 0x6e, 0xbb, 0xef,
0xb9, 0xd4, 0x0d, 0x06, 0x35, 0xfe, 0x17, 0x67, 0xd4, 0xbc, 0x74, 0xb9, 0x6d, 0xd3, 0xce, 0x60,
0xaf, 0xd6, 0x70, 0x9d, 0x95, 0xb6, 0xdb, 0x76, 0x57, 0x38, 0x79, 0x6f, 0xd0, 0xe2, 0x33, 0x71,
0x98, 0x8d, 0xc4, 0xc1, 0x52, 0xa5, 0xed, 0xba, 0xed, 0x2e, 0x09, 0x77, 0x51, 0xdb, 0x21, 0x3e,
0xb5, 0x9c, 0xbe, 0xdc, 0xb0, 0x2c, 0xc5, 0x3e, 0xe8, 0x3a, 0x6e, 0x93, 0x74, 0x57, 0x7c, 0x6a,
0x51, 0x5f, 0xfc, 0x15, 0x3b, 0x8c, 0x8f, 0x20, 0xb7, 0x33, 0xf0, 0x3b, 0x26, 0x79, 0x30, 0x20,
0x3e, 0xc5, 0x37, 0x61, 0xc6, 0xa7, 0x1e, 0xb1, 0x1c, 0xbf, 0x88, 0x96, 0x13, 0xd5, 0xdc, 0xea,
0x52, 0x2d, 0xb8, 0xec, 0x2e, 0x5f, 0x58, 0x6b, 0x5a, 0x7d, 0x4a, 0xbc, 0xfa, 0xa9, 0x2f, 0x87,
0x95, 0xb4, 0x20, 0x1d, 0x0d, 0x2b, 0xea, 0x94, 0xa9, 0x06, 0xc6, 0x1c, 0xe4, 0x05, 0x63, 0xbf,
0xef, 0xf6, 0x7c, 0x62, 0xfc, 0x25, 0x0e, 0xf9, 0x0f, 0x07, 0xc4, 0x3b, 0x50, 0xa2, 0x4a, 0x90,
0xf1, 0x49, 0x97, 0x34, 0xa8, 0xeb, 0x15, 0xd1, 0x32, 0xaa, 0x66, 0xcd, 0x60, 0x8e, 0x17, 0x20,
0xd5, 0xb5, 0x1d, 0x9b, 0x16, 0xe3, 0xcb, 0xa8, 0x3a, 0x6b, 0x8a, 0x09, 0xbe, 0x06, 0x29, 0x9f,
0x5a, 0x1e, 0x2d, 0x26, 0x96, 0x51, 0x35, 0xb7, 0x5a, 0xaa, 0x09, 0xf5, 0x6b, 0x4a, 0xfd, 0xda,
0x5d, 0xa5, 0x7e, 0x3d, 0xf3, 0x68, 0x58, 0x89, 0x7d, 0xfe, 0xf7, 0x0a, 0x32, 0xc5, 0x11, 0xfc,
0x1d, 0x48, 0x90, 0x5e, 0xb3, 0x98, 0x9c, 0xe2, 0x24, 0x3b, 0x80, 0xaf, 0x40, 0xb6, 0x69, 0x7b,
0xa4, 0x41, 0x6d, 0xb7, 0x57, 0x4c, 0x2d, 0xa3, 0xea, 0xdc, 0xea, 0xc9, 0x10, 0x92, 0x0d, 0xb5,
0x64, 0x86, 0xbb, 0xf0, 0x25, 0x48, 0xfb, 0x1d, 0xcb, 0x6b, 0xfa, 0xc5, 0x99, 0xe5, 0x44, 0x35,
0x5b, 0x5f, 0x38, 0x1a, 0x56, 0x0a, 0x82, 0x72, 0xc9, 0x75, 0x6c, 0x4a, 0x9c, 0x3e, 0x3d, 0x30,
0xe5, 0x1e, 0x7c, 0x11, 0x66, 0x9a, 0xa4, 0x4b, 0x28, 0xf1, 0x8b, 0x19, 0x8e, 0x78, 0x41, 0x63,
0xcf, 0x17, 0x4c, 0xb5, 0xe1, 0x56, 0x32, 0x93, 0x2e, 0xcc, 0x18, 0xff, 0x41, 0x80, 0x77, 0x2d,
0xa7, 0xdf, 0x25, 0xcf, 0x8d, 0x67, 0x80, 0x5c, 0xfc, 0x85, 0x91, 0x4b, 0x4c, 0x8b, 0x5c, 0x08,
0x43, 0x72, 0x3a, 0x18, 0x52, 0x5f, 0x03, 0x83, 0xb1, 0x0d, 0x69, 0x41, 0xfa, 0x3a, 0x1b, 0x0a,
0x75, 0x4e, 0x28, 0x6d, 0x0a, 0xa1, 0x36, 0x09, 0x7e, 0x4f, 0xe3, 0xa7, 0x30, 0x2b, 0x71, 0x14,
0x96, 0x8a, 0xd7, 0x9e, 0xdb, 0x07, 0xe6, 0x1e, 0x0d, 0x2b, 0x28, 0xf4, 0x83, 0xc0, 0xf8, 0xf1,
0x1b, 0x5c, 0x36, 0xf5, 0x25, 0xde, 0xf3, 0x35, 0xe1, 0x72, 0x5b, 0xbd, 0x36, 0xf1, 0xd9, 0xc1,
0x24, 0x83, 0xca, 0x14, 0x7b, 0x8c, 0x9f, 0xc0, 0xc9, 0x91, 0xe7, 0x94, 0xd7, 0xb8, 0x0a, 0x69,
0x9f, 0x78, 0x36, 0x51, 0xb7, 0xd0, 0x00, 0xd9, 0xe5, 0x74, 0x4d, 0x3c, 0x9f, 0x9b, 0x72, 0xff,
0x74, 0xd2, 0x7f, 0x8f, 0x20, 0xbf, 0x6d, 0xed, 0x91, 0xae, 0xb2, 0x23, 0x0c, 0xc9, 0x9e, 0xe5,
0x10, 0x89, 0x27, 0x1f, 0xe3, 0x45, 0x48, 0x7f, 0x62, 0x75, 0x07, 0x44, 0xb0, 0xcc, 0x98, 0x72,
0x36, 0xad, 0x47, 0xa2, 0x17, 0xf6, 0x48, 0x14, 0xd8, 0x95, 0x71, 0x01, 0x66, 0xe5, 0x7d, 0x25,
0x50, 0xe1, 0xe5, 0x18, 0x50, 0x59, 0x75, 0x39, 0xe3, 0x17, 0x08, 0x66, 0x47, 0xde, 0x0b, 0x1b,
0x90, 0xee, 0xb2, 0xa3, 0xbe, 0x50, 0xae, 0x0e, 0x47, 0xc3, 0x8a, 0xa4, 0x98, 0xf2, 0x97, 0xbd,
0x3e, 0xe9, 0x51, 0x8e, 0x7b, 0x9c, 0xe3, 0xbe, 0x18, 0xe2, 0xfe, 0x5e, 0x8f, 0x7a, 0x07, 0xea,
0xf1, 0xe7, 0x19, 0x8a, 0x2c, 0xf4, 0xc9, 0xed, 0xa6, 0x1a, 0xe0, 0xd7, 0x20, 0xd9, 0xb1, 0xfc,
0x0e, 0x07, 0x25, 0x59, 0x4f, 0x1d, 0x0d, 0x2b, 0xe8, 0xb2, 0xc9, 0x49, 0xc6, 0x27, 0x90, 0xd7,
0x99, 0xe0, 0x9b, 0x90, 0x0d, 0x62, 0x36, 0xbf, 0xd4, 0xb3, 0xa1, 0x98, 0x93, 0x32, 0xe3, 0xd4,
0xe7, 0x80, 0x84, 0x87, 0xf1, 0x19, 0x48, 0x76, 0xed, 0x1e, 0xe1, 0x0f, 0x94, 0xad, 0x67, 0x8e,
0x86, 0x15, 0x3e, 0x37, 0xf9, 0x5f, 0xc3, 0x81, 0xb4, 0xb0, 0x31, 0xfc, 0x7a, 0x54, 0x62, 0xa2,
0x9e, 0x16, 0x1c, 0x75, 0x6e, 0x15, 0x48, 0x71, 0x14, 0x39, 0x3b, 0x54, 0xcf, 0x1e, 0x0d, 0x2b,
0x82, 0x60, 0x8a, 0x1f, 0x26, 0x4e, 0xd3, 0x91, 0x8b, 0x63, 0x73, 0xa9, 0xe6, 0x26, 0xe4, 0xb7,
0x49, 0xdb, 0x6a, 0x1c, 0x48, 0xa1, 0x0b, 0x8a, 0x1d, 0x13, 0x88, 0x14, 0x8f, 0x73, 0x90, 0x0f,
0x24, 0xde, 0x77, 0x7c, 0xe9, 0xa8, 0xb9, 0x80, 0xf6, 0xbe, 0x6f, 0xfc, 0x0a, 0x81, 0xb4, 0xee,
0xe7, 0x7a, 0xbc, 0xeb, 0x30, 0xe3, 0x73, 0x89, 0xea, 0xf1, 0x74, 0xa7, 0xe1, 0x0b, 0xe1, 0xb3,
0xc9, 0x8d, 0xa6, 0x1a, 0xe0, 0x1a, 0x80, 0xf0, 0xdf, 0x9b, 0xa1, 0x62, 0x73, 0x47, 0xc3, 0x8a,
0x46, 0x35, 0xb5, 0xb1, 0xf1, 0x4b, 0x04, 0xb9, 0xbb, 0x96, 0x1d, 0x38, 0xce, 0x02, 0xa4, 0x1e,
0x30, 0x0f, 0x96, 0x9e, 0x23, 0x26, 0x2c, 0x44, 0x35, 0x49, 0xd7, 0x3a, 0xb8, 0xe1, 0x7a, 0x9c,
0xe7, 0xac, 0x19, 0xcc, 0xc3, 0x34, 0x97, 0x1c, 0x9b, 0xe6, 0x52, 0x53, 0x07, 0xeb, 0x5b, 0xc9,
0x4c, 0xbc, 0x90, 0x30, 0x7e, 0x8e, 0x20, 0x2f, 0x6e, 0x26, 0x5d, 0xe4, 0x3a, 0xa4, 0xc5, 0xc5,
0xa5, 0x8d, 0x4d, 0x8c, 0x68, 0xa0, 0x45, 0x33, 0x79, 0x04, 0x7f, 0x1f, 0xe6, 0x9a, 0x9e, 0xdb,
0xef, 0x93, 0xe6, 0xae, 0x0c, 0x8b, 0xf1, 0x68, 0x58, 0xdc, 0xd0, 0xd7, 0xcd, 0xc8, 0x76, 0xe3,
0xaf, 0xcc, 0x11, 0x45, 0x88, 0x92, 0x50, 0x05, 0x2a, 0xa2, 0x17, 0xce, 0x47, 0xf1, 0x69, 0xf3,
0xd1, 0x22, 0xa4, 0xdb, 0x9e, 0x3b, 0xe8, 0xfb, 0xc5, 0x84, 0x08, 0x13, 0x62, 0x36, 0x5d, 0x9e,
0x32, 0x6e, 0xc1, 0x9c, 0x52, 0x65, 0x42, 0x9c, 0x2e, 0x45, 0xe3, 0xf4, 0x56, 0x93, 0xf4, 0xa8,
0xdd, 0xb2, 0x83, 0xc8, 0x2b, 0xf7, 0x1b, 0x9f, 0x21, 0x28, 0x44, 0xb7, 0xe0, 0xef, 0x69, 0x66,
0xce, 0xd8, 0x9d, 0x9f, 0xcc, 0xae, 0xc6, 0xe3, 0xa0, 0xcf, 0x03, 0x8a, 0x72, 0x81, 0xd2, 0x3b,
0x90, 0xd3, 0xc8, 0x2c, 0xdf, 0xed, 0x13, 0x65, 0x92, 0x6c, 0x18, 0xfa, 0x62, 0x5c, 0x98, 0x29,
0x9f, 0x5c, 0x8b, 0x5f, 0x45, 0xcc, 0xa0, 0x67, 0x47, 0x5e, 0x12, 0x5f, 0x85, 0x64, 0xcb, 0x73,
0x9d, 0xa9, 0x9e, 0x89, 0x9f, 0xc0, 0xdf, 0x82, 0x38, 0x75, 0xa7, 0x7a, 0xa4, 0x38, 0x75, 0xd9,
0x1b, 0x49, 0xe5, 0x13, 0xfc, 0x72, 0x72, 0x66, 0xfc, 0x0e, 0xc1, 0x3c, 0x3b, 0x23, 0x10, 0x58,
0xef, 0x0c, 0x7a, 0xfb, 0xb8, 0x0a, 0x05, 0x26, 0xe9, 0xbe, 0x2d, 0xd3, 0xda, 0x7d, 0xbb, 0x29,
0xd5, 0x9c, 0x63, 0x74, 0x95, 0xed, 0xb6, 0x9a, 0x78, 0x09, 0x66, 0x06, 0xbe, 0xd8, 0x20, 0x74,
0x4e, 0xb3, 0xe9, 0x56, 0x13, 0xbf, 0xa1, 0x89, 0x63, 0x58, 0x6b, 0x95, 0x1d, 0xc7, 0x70, 0xc7,
0xb2, 0xbd, 0x20, 0xb6, 0x5c, 0x80, 0x74, 0x83, 0x09, 0x16, 0x76, 0xc2, 0xd2, 0x6a, 0xb0, 0x99,
0x5f, 0xc8, 0x94, 0xcb, 0xc6, 0xb7, 0x21, 0x1b, 0x9c, 0x1e, 0x9b, 0x4d, 0xc7, 0xbe, 0x80, 0x71,
0x1d, 0xe6, 0x45, 0xcc, 0x1c, 0x7f, 0x38, 0x3f, 0xee, 0x70, 0x5e, 0x1d, 0x3e, 0x0d, 0x29, 0x81,
0x0a, 0x86, 0x64, 0xd3, 0xa2, 0x96, 0x3a, 0xc2, 0xc6, 0x46, 0x11, 0x16, 0xef, 0x7a, 0x56, 0xcf,
0x6f, 0x11, 0x8f, 0x6f, 0x0a, 0x6c, 0xd7, 0x38, 0x05, 0x27, 0x59, 0x9c, 0x20, 0x9e, 0xbf, 0xee,
0x0e, 0x7a, 0x54, 0xba, 0xa7, 0x71, 0x09, 0x16, 0x46, 0xc9, 0xd2, 0xd4, 0x17, 0x20, 0xd5, 0x60,
0x04, 0xce, 0x7d, 0xd6, 0x14, 0x13, 0xe3, 0xd7, 0x08, 0xf0, 0x26, 0xa1, 0x9c, 0xf5, 0xd6, 0x86,
0xaf, 0xd5, 0xa3, 0x8e, 0x45, 0x1b, 0x1d, 0xe2, 0xf9, 0xaa, 0x36, 0x53, 0xf3, 0xff, 0x47, 0x3d,
0x6a, 0x5c, 0x81, 0x93, 0x23, 0xb7, 0x94, 0x3a, 0x95, 0x20, 0xd3, 0x90, 0x34, 0x59, 0x3f, 0x04,
0x73, 0xe3, 0x0f, 0x71, 0xc8, 0x88, 0xb7, 0x25, 0x2d, 0x7c, 0x05, 0x72, 0x2d, 0x66, 0x6b, 0x5e,
0xdf, 0xb3, 0x25, 0x04, 0xc9, 0xfa, 0xfc, 0xd1, 0xb0, 0xa2, 0x93, 0x4d, 0x7d, 0x82, 0x2f, 0x47,
0x0c, 0xaf, 0xbe, 0x70, 0x38, 0xac, 0xa4, 0x7f, 0xc0, 0x8c, 0x6f, 0x83, 0x65, 0x2f, 0x6e, 0x86,
0x1b, 0x81, 0x39, 0xde, 0x96, 0xde, 0xc6, 0x8b, 0xd3, 0xfa, 0xdb, 0xec, 0xfa, 0x5f, 0x0e, 0x2b,
0x17, 0xb4, 0x9e, 0xb0, 0xef, 0xb9, 0x0e, 0xa1, 0x1d, 0x32, 0xf0, 0x57, 0x1a, 0xae, 0xe3, 0xb8,
0xbd, 0x15, 0xde, 0xd7, 0x71, 0xa5, 0x59, 0x0a, 0x66, 0xc7, 0xa5, 0x03, 0xde, 0x85, 0x19, 0xda,
0xf1, 0xdc, 0x41, 0xbb, 0xc3, 0xb3, 0x4b, 0xa2, 0x7e, 0x6d, 0x7a, 0x7e, 0x8a, 0x83, 0xa9, 0x06,
0xf8, 0x1c, 0x43, 0x8b, 0x34, 0xf6, 0xfd, 0x81, 0xc3, 0xd3, 0xd3, 0xac, 0x2a, 0x6f, 0x02, 0xb2,
0xf1, 0x59, 0x1c, 0x2a, 0xdc, 0x84, 0xef, 0xf1, 0x32, 0xec, 0x86, 0xeb, 0xbd, 0x4f, 0xa8, 0x67,
0x37, 0xee, 0x58, 0x0e, 0x51, 0xb6, 0x51, 0x81, 0x9c, 0xc3, 0x89, 0xf7, 0x35, 0xe7, 0x00, 0x27,
0xd8, 0x87, 0xcf, 0x02, 0x70, 0xb7, 0x13, 0xeb, 0xc2, 0x4f, 0xb2, 0x9c, 0xc2, 0x97, 0xd7, 0x47,
0x90, 0x5a, 0x99, 0x52, 0x33, 0x89, 0xd0, 0x56, 0x14, 0xa1, 0xa9, 0xf9, 0x04, 0xb0, 0xe8, 0xb6,
0x9e, 0x1a, 0xb5, 0x75, 0xe3, 0x6f, 0x08, 0xca, 0xdb, 0xea, 0xe6, 0x2f, 0x08, 0x87, 0xd2, 0x37,
0xfe, 0x92, 0xf4, 0x4d, 0xfc, 0x6f, 0xfa, 0x1a, 0x7f, 0xd6, 0x5c, 0xde, 0x24, 0x2d, 0xa5, 0xc7,
0xba, 0x96, 0x2e, 0x5e, 0xc6, 0x35, 0xe3, 0x2f, 0xf1, 0x59, 0x12, 0x91, 0x67, 0x79, 0x37, 0x0c,
0x07, 0x5c, 0x03, 0x19, 0x0e, 0xce, 0x43, 0xd2, 0x23, 0x2d, 0x95, 0x7c, 0x71, 0x34, 0xc6, 0x93,
0x96, 0xc9, 0xd7, 0x8d, 0x3f, 0x22, 0x28, 0x6c, 0x12, 0x3a, 0x5a, 0xd6, 0xbc, 0x4a, 0xfa, 0xdf,
0x84, 0x13, 0xda, 0xfd, 0xa5, 0xf6, 0x6f, 0x45, 0x6a, 0x99, 0x53, 0xa1, 0xfe, 0x5b, 0xbd, 0x26,
0xf9, 0x54, 0x36, 0x9e, 0xa3, 0x65, 0xcc, 0x0e, 0xe4, 0xb4, 0x45, 0xbc, 0x16, 0x29, 0x60, 0xc6,
0x25, 0xd5, 0xfa, 0x82, 0xd4, 0x49, 0xb4, 0x9e, 0xb2, 0xfa, 0x0c, 0xd2, 0xfd, 0x2e, 0x60, 0xde,
0x0b, 0x73, 0xb6, 0x7a, 0xa4, 0xe6, 0xd4, 0xdb, 0x41, 0x3d, 0x13, 0xcc, 0xf1, 0x39, 0x48, 0x7a,
0xee, 0x43, 0x55, 0x99, 0xce, 0x86, 0x22, 0x4d, 0xf7, 0xa1, 0xc9, 0x97, 0x8c, 0xeb, 0x90, 0x30,
0xdd, 0x87, 0xb8, 0x0c, 0xe0, 0x59, 0xbd, 0x36, 0xb9, 0x17, 0xf4, 0x23, 0x79, 0x53, 0xa3, 0x4c,
0xc8, 0xaf, 0xeb, 0x70, 0x42, 0xbf, 0x91, 0x78, 0xee, 0x1a, 0xcc, 0x30, 0x62, 0x08, 0xd7, 0x42,
0x04, 0x2e, 0xd1, 0xd0, 0xab, 0x4d, 0xcc, 0x66, 0x20, 0xa4, 0xe3, 0x33, 0x90, 0xa5, 0xd6, 0x5e,
0x97, 0xdc, 0x09, 0x7d, 0x3e, 0x24, 0xb0, 0x55, 0xd6, 0x4a, 0xdd, 0xd3, 0x0a, 0x85, 0x90, 0x80,
0x2f, 0x42, 0x21, 0xbc, 0xf3, 0x8e, 0x47, 0x5a, 0xf6, 0xa7, 0xfc, 0x85, 0xf3, 0xe6, 0x31, 0x3a,
0xae, 0xc2, 0x7c, 0x48, 0xdb, 0xe5, 0x69, 0x37, 0xc9, 0xb7, 0x46, 0xc9, 0x0c, 0x1b, 0xae, 0xee,
0x7b, 0x0f, 0x06, 0x56, 0x97, 0x07, 0xb2, 0xbc, 0xa9, 0x51, 0x8c, 0x3f, 0x21, 0x38, 0x21, 0x9e,
0x9a, 0x5a, 0xf4, 0x95, 0xb4, 0xfa, 0xdf, 0x20, 0xc0, 0xba, 0x06, 0xd2, 0xb4, 0xbe, 0xa1, 0x7f,
0xf2, 0x61, 0x79, 0x3d, 0x37, 0xee, 0x9b, 0x26, 0x6b, 0x41, 0x65, 0x09, 0x18, 0xe7, 0xbb, 0x78,
0x0b, 0x2a, 0x28, 0xaa, 0xfa, 0x63, 0x9d, 0xf3, 0xde, 0x01, 0x25, 0xbe, 0x6c, 0x20, 0x79, 0xe7,
0xcc, 0x09, 0xa6, 0xf8, 0x61, 0xb2, 0xd4, 0x07, 0x86, 0x64, 0x28, 0x2b, 0xfa, 0x11, 0xe1, 0xe2,
0x79, 0xc8, 0x06, 0x5f, 0x17, 0x71, 0x0e, 0x66, 0x6e, 0x7c, 0x60, 0x7e, 0xb4, 0x66, 0x6e, 0x14,
0x62, 0x38, 0x0f, 0x99, 0xfa, 0xda, 0xfa, 0x6d, 0x3e, 0x43, 0xab, 0x6b, 0x90, 0xde, 0x19, 0xf8,
0x1d, 0xe2, 0xe1, 0xb7, 0x21, 0xc9, 0x46, 0x58, 0x73, 0x5a, 0xed, 0xd3, 0x6e, 0x69, 0x31, 0x4a,
0x96, 0x35, 0x60, 0x6c, 0xf5, 0x5f, 0x09, 0x65, 0xc8, 0x1e, 0xfe, 0x2e, 0xa4, 0x84, 0x75, 0x6a,
0xdb, 0xf5, 0xcf, 0x8c, 0xa5, 0xa5, 0x63, 0x74, 0xc5, 0xe7, 0x4d, 0x84, 0xef, 0x40, 0x8e, 0x13,
0x65, 0xdb, 0x7f, 0x26, 0xda, 0x7d, 0x8f, 0x70, 0x3a, 0x3b, 0x61, 0x55, 0xe3, 0x77, 0x0d, 0x52,
0x3c, 0x40, 0xe8, 0xb7, 0xd1, 0x3f, 0x56, 0xe9, 0xb7, 0x19, 0xf9, 0x28, 0x64, 0xc4, 0xf0, 0x3b,
0x90, 0x64, 0x45, 0xac, 0x0e, 0x87, 0xd6, 0xad, 0xeb, 0x70, 0xe8, 0xad, 0x32, 0x17, 0xfb, 0x6e,
0xf0, 0xd1, 0x61, 0x29, 0xda, 0x7d, 0xa9, 0xe3, 0xc5, 0xe3, 0x0b, 0x81, 0xe4, 0x0f, 0x44, 0xf7,
0xad, 0xca, 0x67, 0x7c, 0x76, 0x54, 0x54, 0xa4, 0xda, 0x2e, 0x95, 0x27, 0x2d, 0x07, 0x0c, 0xb7,
0x21, 0xa7, 0x95, 0xae, 0x3a, 0xac, 0xc7, 0xeb, 0x6e, 0x1d, 0xd6, 0x31, 0xf5, 0xae, 0x11, 0x5b,
0xfd, 0x21, 0x64, 0x54, 0x73, 0x84, 0x3f, 0x84, 0xb9, 0xd1, 0xd6, 0x00, 0xbf, 0xa6, 0xdd, 0x66,
0xb4, 0xe3, 0x2a, 0x2d, 0x6b, 0x4b, 0xe3, 0xfb, 0x89, 0x58, 0x15, 0xad, 0xfe, 0x3b, 0x01, 0x79,
0xee, 0x62, 0x9b, 0x16, 0x25, 0x0f, 0xad, 0x03, 0xbc, 0x05, 0x10, 0xc6, 0x4e, 0x7c, 0x3a, 0x62,
0x3f, 0x7a, 0x44, 0x2d, 0x9d, 0x19, 0xbf, 0x28, 0xb8, 0xbf, 0x89, 0x74, 0x20, 0x58, 0x49, 0x3e,
0x06, 0x88, 0xb0, 0x1a, 0x19, 0x07, 0x84, 0x96, 0xe9, 0x8d, 0x18, 0xbe, 0x01, 0xd9, 0x20, 0x05,
0xe2, 0xd2, 0xc8, 0xee, 0xd1, 0xc7, 0x3e, 0x3d, 0x76, 0x2d, 0xe0, 0xf3, 0x23, 0x58, 0x9a, 0x50,
0xe0, 0xe1, 0x6a, 0xc4, 0x3e, 0x27, 0xd6, 0x80, 0xcf, 0xb2, 0xe4, 0x1f, 0x43, 0x71, 0x52, 0x41,
0x8d, 0xbf, 0x19, 0x39, 0x36, 0xb9, 0xe8, 0x7e, 0x96, 0x84, 0x4d, 0xc8, 0x30, 0xc5, 0x58, 0x4c,
0xd4, 0x1f, 0xe8, 0x58, 0xac, 0xd7, 0x1f, 0xe8, 0x78, 0x18, 0x35, 0x62, 0xf5, 0x8f, 0x1f, 0x3f,
0x29, 0xc7, 0xbe, 0x78, 0x52, 0x8e, 0x7d, 0xf5, 0xa4, 0x8c, 0x7e, 0x76, 0x58, 0x46, 0xbf, 0x3d,
0x2c, 0xa3, 0x47, 0x87, 0x65, 0xf4, 0xf8, 0xb0, 0x8c, 0xfe, 0x71, 0x58, 0x46, 0xff, 0x3c, 0x2c,
0xc7, 0xbe, 0x3a, 0x2c, 0xa3, 0xcf, 0x9f, 0x96, 0x63, 0x8f, 0x9f, 0x96, 0x63, 0x5f, 0x3c, 0x2d,
0xc7, 0x3e, 0x7e, 0x5d, 0xff, 0xb7, 0x97, 0x67, 0xb5, 0xac, 0x9e, 0xb5, 0xd2, 0x75, 0xf7, 0xed,
0x15, 0xfd, 0xbf, 0x66, 0x7b, 0x69, 0xfe, 0xf3, 0xd6, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xa7,
0x7e, 0x53, 0x54, 0x4c, 0x1b, 0x00, 0x00,
// 2088 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0x4f, 0x6f, 0x1b, 0xc7,
0x15, 0xe7, 0x90, 0x4b, 0x8a, 0x7c, 0xa4, 0x24, 0x66, 0x2c, 0xcb, 0x0c, 0x6d, 0x73, 0xe5, 0x45,
0x6a, 0x0b, 0x8e, 0x4d, 0xd6, 0x4a, 0xdb, 0x38, 0x76, 0xd3, 0x42, 0x94, 0x62, 0x5b, 0xb6, 0xe2,
0x28, 0x2b, 0xd7, 0x01, 0x02, 0x14, 0xc6, 0x8a, 0x1c, 0x92, 0x0b, 0x71, 0xb9, 0xf4, 0xee, 0x30,
0x8e, 0x80, 0x02, 0xed, 0x07, 0x68, 0x80, 0xf4, 0x54, 0xf4, 0x5e, 0xa0, 0x45, 0x0f, 0x3d, 0x14,
0xe8, 0xb5, 0xed, 0xad, 0xee, 0xcd, 0xbd, 0x05, 0x39, 0xb0, 0xb5, 0x7c, 0x29, 0x74, 0xca, 0x27,
0x28, 0x8a, 0xf9, 0xb7, 0x3b, 0x5c, 0x53, 0x8d, 0xe9, 0x1a, 0x28, 0x72, 0x11, 0x67, 0xde, 0xcc,
0xbc, 0x37, 0xef, 0x37, 0xef, 0xef, 0x0a, 0x4e, 0x0f, 0xf7, 0xbb, 0x8d, 0xbe, 0xdf, 0x1d, 0x06,
0x3e, 0xf5, 0xa3, 0x41, 0x9d, 0xff, 0xc5, 0x79, 0x35, 0xaf, 0x5e, 0xee, 0xba, 0xb4, 0x37, 0xda,
0xab, 0xb7, 0x7c, 0xaf, 0xd1, 0xf5, 0xbb, 0x7e, 0x83, 0x93, 0xf7, 0x46, 0x1d, 0x3e, 0x13, 0x87,
0xd9, 0x48, 0x1c, 0xac, 0x9a, 0x5d, 0xdf, 0xef, 0xf6, 0x49, 0xbc, 0x8b, 0xba, 0x1e, 0x09, 0xa9,
0xe3, 0x0d, 0xe5, 0x86, 0x15, 0x29, 0xf6, 0x61, 0xdf, 0xf3, 0xdb, 0xa4, 0xdf, 0x08, 0xa9, 0x43,
0x43, 0xf1, 0x57, 0xec, 0xb0, 0x3e, 0x82, 0xe2, 0xce, 0x28, 0xec, 0xd9, 0xe4, 0xe1, 0x88, 0x84,
0x14, 0xdf, 0x82, 0xb9, 0x90, 0x06, 0xc4, 0xf1, 0xc2, 0x0a, 0x5a, 0xc9, 0xac, 0x16, 0xd7, 0x4e,
0xd5, 0xa3, 0xcb, 0xee, 0xf2, 0x85, 0xf5, 0xb6, 0x33, 0xa4, 0x24, 0x68, 0x9e, 0xfc, 0x72, 0x6c,
0xe6, 0x04, 0xe9, 0x68, 0x6c, 0xaa, 0x53, 0xb6, 0x1a, 0x58, 0x0b, 0x50, 0x12, 0x8c, 0xc3, 0xa1,
0x3f, 0x08, 0x89, 0xf5, 0xd7, 0x34, 0x94, 0x3e, 0x1c, 0x91, 0xe0, 0x40, 0x89, 0xaa, 0x42, 0x3e,
0x24, 0x7d, 0xd2, 0xa2, 0x7e, 0x50, 0x41, 0x2b, 0x68, 0xb5, 0x60, 0x47, 0x73, 0xbc, 0x04, 0xd9,
0xbe, 0xeb, 0xb9, 0xb4, 0x92, 0x5e, 0x41, 0xab, 0xf3, 0xb6, 0x98, 0xe0, 0x6b, 0x90, 0x0d, 0xa9,
0x13, 0xd0, 0x4a, 0x66, 0x05, 0xad, 0x16, 0xd7, 0xaa, 0x75, 0xa1, 0x7e, 0x5d, 0xa9, 0x5f, 0xbf,
0xa7, 0xd4, 0x6f, 0xe6, 0x1f, 0x8f, 0xcd, 0xd4, 0xe7, 0xff, 0x30, 0x91, 0x2d, 0x8e, 0xe0, 0xef,
0x41, 0x86, 0x0c, 0xda, 0x15, 0x63, 0x86, 0x93, 0xec, 0x00, 0xbe, 0x02, 0x85, 0xb6, 0x1b, 0x90,
0x16, 0x75, 0xfd, 0x41, 0x25, 0xbb, 0x82, 0x56, 0x17, 0xd6, 0x4e, 0xc4, 0x90, 0x6c, 0xaa, 0x25,
0x3b, 0xde, 0x85, 0x2f, 0x41, 0x2e, 0xec, 0x39, 0x41, 0x3b, 0xac, 0xcc, 0xad, 0x64, 0x56, 0x0b,
0xcd, 0xa5, 0xa3, 0xb1, 0x59, 0x16, 0x94, 0x4b, 0xbe, 0xe7, 0x52, 0xe2, 0x0d, 0xe9, 0x81, 0x2d,
0xf7, 0xe0, 0x8b, 0x30, 0xd7, 0x26, 0x7d, 0x42, 0x49, 0x58, 0xc9, 0x73, 0xc4, 0xcb, 0x1a, 0x7b,
0xbe, 0x60, 0xab, 0x0d, 0xb7, 0x8d, 0x7c, 0xae, 0x3c, 0x67, 0xfd, 0x1b, 0x01, 0xde, 0x75, 0xbc,
0x61, 0x9f, 0xbc, 0x30, 0x9e, 0x11, 0x72, 0xe9, 0x97, 0x46, 0x2e, 0x33, 0x2b, 0x72, 0x31, 0x0c,
0xc6, 0x6c, 0x30, 0x64, 0xbf, 0x06, 0x06, 0x6b, 0x1b, 0x72, 0x82, 0xf4, 0x75, 0x36, 0x14, 0xeb,
0x9c, 0x51, 0xda, 0x94, 0x63, 0x6d, 0x32, 0xfc, 0x9e, 0xd6, 0x4f, 0x61, 0x5e, 0xe2, 0x28, 0x2c,
0x15, 0xaf, 0xbf, 0xb0, 0x0f, 0x2c, 0x3c, 0x1e, 0x9b, 0x28, 0xf6, 0x83, 0xc8, 0xf8, 0xf1, 0x9b,
0x5c, 0x36, 0x0d, 0x25, 0xde, 0x8b, 0x75, 0xe1, 0x72, 0x5b, 0x83, 0x2e, 0x09, 0xd9, 0x41, 0x83,
0x41, 0x65, 0x8b, 0x3d, 0xd6, 0x4f, 0xe0, 0xc4, 0xc4, 0x73, 0xca, 0x6b, 0x5c, 0x85, 0x5c, 0x48,
0x02, 0x97, 0xa8, 0x5b, 0x68, 0x80, 0xec, 0x72, 0xba, 0x26, 0x9e, 0xcf, 0x6d, 0xb9, 0x7f, 0x36,
0xe9, 0xbf, 0x47, 0x50, 0xda, 0x76, 0xf6, 0x48, 0x5f, 0xd9, 0x11, 0x06, 0x63, 0xe0, 0x78, 0x44,
0xe2, 0xc9, 0xc7, 0x78, 0x19, 0x72, 0x9f, 0x38, 0xfd, 0x11, 0x11, 0x2c, 0xf3, 0xb6, 0x9c, 0xcd,
0xea, 0x91, 0xe8, 0xa5, 0x3d, 0x12, 0x45, 0x76, 0x65, 0x5d, 0x80, 0x79, 0x79, 0x5f, 0x09, 0x54,
0x7c, 0x39, 0x06, 0x54, 0x41, 0x5d, 0xce, 0xfa, 0x05, 0x82, 0xf9, 0x89, 0xf7, 0xc2, 0x16, 0xe4,
0xfa, 0xec, 0x68, 0x28, 0x94, 0x6b, 0xc2, 0xd1, 0xd8, 0x94, 0x14, 0x5b, 0xfe, 0xb2, 0xd7, 0x27,
0x03, 0xca, 0x71, 0x4f, 0x73, 0xdc, 0x97, 0x63, 0xdc, 0xdf, 0x1b, 0xd0, 0xe0, 0x40, 0x3d, 0xfe,
0x22, 0x43, 0x91, 0x85, 0x3e, 0xb9, 0xdd, 0x56, 0x03, 0xfc, 0x3a, 0x18, 0x3d, 0x27, 0xec, 0x71,
0x50, 0x8c, 0x66, 0xf6, 0x68, 0x6c, 0xa2, 0xcb, 0x36, 0x27, 0x59, 0x9f, 0x40, 0x49, 0x67, 0x82,
0x6f, 0x41, 0x21, 0x8a, 0xd9, 0xfc, 0x52, 0xff, 0x1d, 0x8a, 0x05, 0x29, 0x33, 0x4d, 0x43, 0x0e,
0x48, 0x7c, 0x18, 0x9f, 0x01, 0xa3, 0xef, 0x0e, 0x08, 0x7f, 0xa0, 0x42, 0x33, 0x7f, 0x34, 0x36,
0xf9, 0xdc, 0xe6, 0x7f, 0x2d, 0x0f, 0x72, 0xc2, 0xc6, 0xf0, 0x1b, 0x49, 0x89, 0x99, 0x66, 0x4e,
0x70, 0xd4, 0xb9, 0x99, 0x90, 0xe5, 0x28, 0x72, 0x76, 0xa8, 0x59, 0x38, 0x1a, 0x9b, 0x82, 0x60,
0x8b, 0x1f, 0x26, 0x4e, 0xd3, 0x91, 0x8b, 0x63, 0x73, 0xa9, 0xe6, 0x4d, 0x28, 0x6d, 0x93, 0xae,
0xd3, 0x3a, 0x90, 0x42, 0x97, 0x14, 0x3b, 0x26, 0x10, 0x29, 0x1e, 0xe7, 0xa0, 0x14, 0x49, 0x7c,
0xe0, 0x85, 0xd2, 0x51, 0x8b, 0x11, 0xed, 0xfd, 0xd0, 0xfa, 0x15, 0x02, 0x69, 0xdd, 0x2f, 0xf4,
0x78, 0xd7, 0x61, 0x2e, 0xe4, 0x12, 0xd5, 0xe3, 0xe9, 0x4e, 0xc3, 0x17, 0xe2, 0x67, 0x93, 0x1b,
0x6d, 0x35, 0xc0, 0x75, 0x00, 0xe1, 0xbf, 0xb7, 0x62, 0xc5, 0x16, 0x8e, 0xc6, 0xa6, 0x46, 0xb5,
0xb5, 0xb1, 0xf5, 0x4b, 0x04, 0xc5, 0x7b, 0x8e, 0x1b, 0x39, 0xce, 0x12, 0x64, 0x1f, 0x32, 0x0f,
0x96, 0x9e, 0x23, 0x26, 0x2c, 0x44, 0xb5, 0x49, 0xdf, 0x39, 0xb8, 0xe1, 0x07, 0x9c, 0xe7, 0xbc,
0x1d, 0xcd, 0xe3, 0x34, 0x67, 0x4c, 0x4d, 0x73, 0xd9, 0x99, 0x83, 0xf5, 0x6d, 0x23, 0x9f, 0x2e,
0x67, 0xac, 0x9f, 0x23, 0x28, 0x89, 0x9b, 0x49, 0x17, 0xb9, 0x0e, 0x39, 0x71, 0x71, 0x69, 0x63,
0xc7, 0x46, 0x34, 0xd0, 0xa2, 0x99, 0x3c, 0x82, 0x7f, 0x08, 0x0b, 0xed, 0xc0, 0x1f, 0x0e, 0x49,
0x7b, 0x57, 0x86, 0xc5, 0x74, 0x32, 0x2c, 0x6e, 0xea, 0xeb, 0x76, 0x62, 0xbb, 0xf5, 0x37, 0xe6,
0x88, 0x22, 0x44, 0x49, 0xa8, 0x22, 0x15, 0xd1, 0x4b, 0xe7, 0xa3, 0xf4, 0xac, 0xf9, 0x68, 0x19,
0x72, 0xdd, 0xc0, 0x1f, 0x0d, 0xc3, 0x4a, 0x46, 0x84, 0x09, 0x31, 0x9b, 0x2d, 0x4f, 0x59, 0xb7,
0x61, 0x41, 0xa9, 0x72, 0x4c, 0x9c, 0xae, 0x26, 0xe3, 0xf4, 0x56, 0x9b, 0x0c, 0xa8, 0xdb, 0x71,
0xa3, 0xc8, 0x2b, 0xf7, 0x5b, 0x9f, 0x21, 0x28, 0x27, 0xb7, 0xe0, 0x1f, 0x68, 0x66, 0xce, 0xd8,
0x9d, 0x3f, 0x9e, 0x5d, 0x9d, 0xc7, 0xc1, 0x90, 0x07, 0x14, 0xe5, 0x02, 0xd5, 0x77, 0xa0, 0xa8,
0x91, 0x59, 0xbe, 0xdb, 0x27, 0xca, 0x24, 0xd9, 0x30, 0xf6, 0xc5, 0xb4, 0x30, 0x53, 0x3e, 0xb9,
0x96, 0xbe, 0x8a, 0x98, 0x41, 0xcf, 0x4f, 0xbc, 0x24, 0xbe, 0x0a, 0x46, 0x27, 0xf0, 0xbd, 0x99,
0x9e, 0x89, 0x9f, 0xc0, 0xdf, 0x81, 0x34, 0xf5, 0x67, 0x7a, 0xa4, 0x34, 0xf5, 0xd9, 0x1b, 0x49,
0xe5, 0x33, 0xfc, 0x72, 0x72, 0x66, 0xfd, 0x0e, 0xc1, 0x22, 0x3b, 0x23, 0x10, 0xd8, 0xe8, 0x8d,
0x06, 0xfb, 0x78, 0x15, 0xca, 0x4c, 0xd2, 0x03, 0x57, 0xa6, 0xb5, 0x07, 0x6e, 0x5b, 0xaa, 0xb9,
0xc0, 0xe8, 0x2a, 0xdb, 0x6d, 0xb5, 0xf1, 0x29, 0x98, 0x1b, 0x85, 0x62, 0x83, 0xd0, 0x39, 0xc7,
0xa6, 0x5b, 0x6d, 0xfc, 0xa6, 0x26, 0x8e, 0x61, 0xad, 0x55, 0x76, 0x1c, 0xc3, 0x1d, 0xc7, 0x0d,
0xa2, 0xd8, 0x72, 0x01, 0x72, 0x2d, 0x26, 0x58, 0xd8, 0x09, 0x4b, 0xab, 0xd1, 0x66, 0x7e, 0x21,
0x5b, 0x2e, 0x5b, 0xdf, 0x85, 0x42, 0x74, 0x7a, 0x6a, 0x36, 0x9d, 0xfa, 0x02, 0xd6, 0x75, 0x58,
0x14, 0x31, 0x73, 0xfa, 0xe1, 0xd2, 0xb4, 0xc3, 0x25, 0x75, 0xf8, 0x34, 0x64, 0x05, 0x2a, 0x18,
0x8c, 0xb6, 0x43, 0x1d, 0x75, 0x84, 0x8d, 0xad, 0x0a, 0x2c, 0xdf, 0x0b, 0x9c, 0x41, 0xd8, 0x21,
0x01, 0xdf, 0x14, 0xd9, 0xae, 0x75, 0x12, 0x4e, 0xb0, 0x38, 0x41, 0x82, 0x70, 0xc3, 0x1f, 0x0d,
0xa8, 0x74, 0x4f, 0xeb, 0x12, 0x2c, 0x4d, 0x92, 0xa5, 0xa9, 0x2f, 0x41, 0xb6, 0xc5, 0x08, 0x9c,
0xfb, 0xbc, 0x2d, 0x26, 0xd6, 0xaf, 0x11, 0xe0, 0x9b, 0x84, 0x72, 0xd6, 0x5b, 0x9b, 0xa1, 0x56,
0x8f, 0x7a, 0x0e, 0x6d, 0xf5, 0x48, 0x10, 0xaa, 0xda, 0x4c, 0xcd, 0xff, 0x1f, 0xf5, 0xa8, 0x75,
0x05, 0x4e, 0x4c, 0xdc, 0x52, 0xea, 0x54, 0x85, 0x7c, 0x4b, 0xd2, 0x64, 0xfd, 0x10, 0xcd, 0xad,
0x3f, 0xa4, 0x21, 0x2f, 0xde, 0x96, 0x74, 0xf0, 0x15, 0x28, 0x76, 0x98, 0xad, 0x05, 0xc3, 0xc0,
0x95, 0x10, 0x18, 0xcd, 0xc5, 0xa3, 0xb1, 0xa9, 0x93, 0x6d, 0x7d, 0x82, 0x2f, 0x27, 0x0c, 0xaf,
0xb9, 0x74, 0x38, 0x36, 0x73, 0x3f, 0x62, 0xc6, 0xb7, 0xc9, 0xb2, 0x17, 0x37, 0xc3, 0xcd, 0xc8,
0x1c, 0xef, 0x48, 0x6f, 0xe3, 0xc5, 0x69, 0xf3, 0x6d, 0x76, 0xfd, 0x2f, 0xc7, 0xe6, 0x05, 0xad,
0x27, 0x1c, 0x06, 0xbe, 0x47, 0x68, 0x8f, 0x8c, 0xc2, 0x46, 0xcb, 0xf7, 0x3c, 0x7f, 0xd0, 0xe0,
0x7d, 0x1d, 0x57, 0x9a, 0xa5, 0x60, 0x76, 0x5c, 0x3a, 0xe0, 0x3d, 0x98, 0xa3, 0xbd, 0xc0, 0x1f,
0x75, 0x7b, 0x3c, 0xbb, 0x64, 0x9a, 0xd7, 0x66, 0xe7, 0xa7, 0x38, 0xd8, 0x6a, 0x80, 0xcf, 0x31,
0xb4, 0x48, 0x6b, 0x3f, 0x1c, 0x79, 0x3c, 0x3d, 0xcd, 0xab, 0xf2, 0x26, 0x22, 0x5b, 0x9f, 0xa5,
0xc1, 0xe4, 0x26, 0x7c, 0x9f, 0x97, 0x61, 0x37, 0xfc, 0xe0, 0x7d, 0x42, 0x03, 0xb7, 0x75, 0xd7,
0xf1, 0x88, 0xb2, 0x0d, 0x13, 0x8a, 0x1e, 0x27, 0x3e, 0xd0, 0x9c, 0x03, 0xbc, 0x68, 0x1f, 0x3e,
0x0b, 0xc0, 0xdd, 0x4e, 0xac, 0x0b, 0x3f, 0x29, 0x70, 0x0a, 0x5f, 0xde, 0x98, 0x40, 0xaa, 0x31,
0xa3, 0x66, 0x12, 0xa1, 0xad, 0x24, 0x42, 0x33, 0xf3, 0x89, 0x60, 0xd1, 0x6d, 0x3d, 0x3b, 0x69,
0xeb, 0xd6, 0xdf, 0x11, 0xd4, 0xb6, 0xd5, 0xcd, 0x5f, 0x12, 0x0e, 0xa5, 0x6f, 0xfa, 0x15, 0xe9,
0x9b, 0xf9, 0xdf, 0xf4, 0xb5, 0xfe, 0xa2, 0xb9, 0xbc, 0x4d, 0x3a, 0x4a, 0x8f, 0x0d, 0x2d, 0x5d,
0xbc, 0x8a, 0x6b, 0xa6, 0x5f, 0xe1, 0xb3, 0x64, 0x12, 0xcf, 0xf2, 0x6e, 0x1c, 0x0e, 0xb8, 0x06,
0x32, 0x1c, 0x9c, 0x07, 0x23, 0x20, 0x1d, 0x95, 0x7c, 0x71, 0x32, 0xc6, 0x93, 0x8e, 0xcd, 0xd7,
0xad, 0x3f, 0x21, 0x28, 0xdf, 0x24, 0x74, 0xb2, 0xac, 0xf9, 0x26, 0xe9, 0x7f, 0x0b, 0x5e, 0xd3,
0xee, 0x2f, 0xb5, 0x7f, 0x2b, 0x51, 0xcb, 0x9c, 0x8c, 0xf5, 0xdf, 0x1a, 0xb4, 0xc9, 0xa7, 0xb2,
0xf1, 0x9c, 0x2c, 0x63, 0x76, 0xa0, 0xa8, 0x2d, 0xe2, 0xf5, 0x44, 0x01, 0x33, 0x2d, 0xa9, 0x36,
0x97, 0xa4, 0x4e, 0xa2, 0xf5, 0x94, 0xd5, 0x67, 0x94, 0xee, 0x77, 0x01, 0xf3, 0x5e, 0x98, 0xb3,
0xd5, 0x23, 0x35, 0xa7, 0xde, 0x89, 0xea, 0x99, 0x68, 0x8e, 0xcf, 0x81, 0x11, 0xf8, 0x8f, 0x54,
0x65, 0x3a, 0x1f, 0x8b, 0xb4, 0xfd, 0x47, 0x36, 0x5f, 0xb2, 0xae, 0x43, 0xc6, 0xf6, 0x1f, 0xe1,
0x1a, 0x40, 0xe0, 0x0c, 0xba, 0xe4, 0x7e, 0xd4, 0x8f, 0x94, 0x6c, 0x8d, 0x72, 0x4c, 0x7e, 0xdd,
0x80, 0xd7, 0xf4, 0x1b, 0x89, 0xe7, 0xae, 0xc3, 0x1c, 0x23, 0xc6, 0x70, 0x2d, 0x25, 0xe0, 0x12,
0x0d, 0xbd, 0xda, 0xc4, 0x6c, 0x06, 0x62, 0x3a, 0x3e, 0x03, 0x05, 0xea, 0xec, 0xf5, 0xc9, 0xdd,
0xd8, 0xe7, 0x63, 0x02, 0x5b, 0x65, 0xad, 0xd4, 0x7d, 0xad, 0x50, 0x88, 0x09, 0xf8, 0x22, 0x94,
0xe3, 0x3b, 0xef, 0x04, 0xa4, 0xe3, 0x7e, 0xca, 0x5f, 0xb8, 0x64, 0x3f, 0x47, 0xc7, 0xab, 0xb0,
0x18, 0xd3, 0x76, 0x79, 0xda, 0x35, 0xf8, 0xd6, 0x24, 0x99, 0x61, 0xc3, 0xd5, 0x7d, 0xef, 0xe1,
0xc8, 0xe9, 0xf3, 0x40, 0x56, 0xb2, 0x35, 0x8a, 0xf5, 0x67, 0x04, 0xaf, 0x89, 0xa7, 0xa6, 0x0e,
0xfd, 0x46, 0x5a, 0xfd, 0x6f, 0x10, 0x60, 0x5d, 0x03, 0x69, 0x5a, 0xdf, 0xd2, 0x3f, 0xf9, 0xb0,
0xbc, 0x5e, 0x9c, 0xf6, 0x4d, 0x93, 0xb5, 0xa0, 0xb2, 0x04, 0x4c, 0xf3, 0x5d, 0xbc, 0x05, 0x15,
0x14, 0x55, 0xfd, 0xb1, 0xce, 0x79, 0xef, 0x80, 0x92, 0x50, 0x36, 0x90, 0xbc, 0x73, 0xe6, 0x04,
0x5b, 0xfc, 0x30, 0x59, 0xea, 0x03, 0x83, 0x11, 0xcb, 0x4a, 0x7e, 0x44, 0xb8, 0x78, 0x1e, 0x0a,
0xd1, 0xd7, 0x45, 0x5c, 0x84, 0xb9, 0x1b, 0x1f, 0xd8, 0x1f, 0xad, 0xdb, 0x9b, 0xe5, 0x14, 0x2e,
0x41, 0xbe, 0xb9, 0xbe, 0x71, 0x87, 0xcf, 0xd0, 0xda, 0x3a, 0xe4, 0x76, 0x46, 0x61, 0x8f, 0x04,
0xf8, 0x6d, 0x30, 0xd8, 0x08, 0x6b, 0x4e, 0xab, 0x7d, 0xda, 0xad, 0x2e, 0x27, 0xc9, 0xb2, 0x06,
0x4c, 0xad, 0xfd, 0xd1, 0x50, 0x86, 0x1c, 0xe0, 0xef, 0x43, 0x56, 0x58, 0xa7, 0xb6, 0x5d, 0xff,
0xcc, 0x58, 0x3d, 0xf5, 0x1c, 0x5d, 0xf1, 0xf9, 0x36, 0xc2, 0x77, 0xa1, 0xc8, 0x89, 0xb2, 0xed,
0x3f, 0x93, 0xec, 0xbe, 0x27, 0x38, 0x9d, 0x3d, 0x66, 0x55, 0xe3, 0x77, 0x0d, 0xb2, 0x3c, 0x40,
0xe8, 0xb7, 0xd1, 0x3f, 0x56, 0xe9, 0xb7, 0x99, 0xf8, 0x28, 0x64, 0xa5, 0xf0, 0x3b, 0x60, 0xb0,
0x22, 0x56, 0x87, 0x43, 0xeb, 0xd6, 0x75, 0x38, 0xf4, 0x56, 0x99, 0x8b, 0x7d, 0x37, 0xfa, 0xe8,
0x70, 0x2a, 0xd9, 0x7d, 0xa9, 0xe3, 0x95, 0xe7, 0x17, 0x22, 0xc9, 0x1f, 0x88, 0xee, 0x5b, 0x95,
0xcf, 0xf8, 0xec, 0xa4, 0xa8, 0x44, 0xb5, 0x5d, 0xad, 0x1d, 0xb7, 0x1c, 0x31, 0xdc, 0x86, 0xa2,
0x56, 0xba, 0xea, 0xb0, 0x3e, 0x5f, 0x77, 0xeb, 0xb0, 0x4e, 0xa9, 0x77, 0xad, 0x14, 0xbe, 0x09,
0x79, 0x16, 0xf9, 0x99, 0x03, 0xe0, 0xd3, 0xc9, 0x00, 0xaf, 0x39, 0x76, 0xf5, 0xcc, 0xf4, 0xc5,
0xc8, 0x6e, 0x7e, 0x0c, 0x79, 0xd5, 0x65, 0xe1, 0x0f, 0x61, 0x61, 0xb2, 0xc7, 0xc0, 0xaf, 0x6b,
0x6a, 0x4d, 0xb6, 0x6e, 0xd5, 0x15, 0x6d, 0x69, 0x7a, 0x63, 0x92, 0x5a, 0x45, 0xcd, 0x8f, 0x9f,
0x3c, 0xad, 0xa5, 0xbe, 0x78, 0x5a, 0x4b, 0x7d, 0xf5, 0xb4, 0x86, 0x7e, 0x76, 0x58, 0x43, 0xbf,
0x3d, 0xac, 0xa1, 0xc7, 0x87, 0x35, 0xf4, 0xe4, 0xb0, 0x86, 0xfe, 0x79, 0x58, 0x43, 0xff, 0x3a,
0xac, 0xa5, 0xbe, 0x3a, 0xac, 0xa1, 0xcf, 0x9f, 0xd5, 0x52, 0x4f, 0x9e, 0xd5, 0x52, 0x5f, 0x3c,
0xab, 0xa5, 0x3e, 0x7e, 0x43, 0xff, 0x17, 0x4a, 0xe0, 0x74, 0x9c, 0x81, 0xd3, 0xe8, 0xfb, 0xfb,
0x6e, 0x43, 0xff, 0x0f, 0xcc, 0x5e, 0x8e, 0xff, 0xbc, 0xf5, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff,
0xdc, 0x73, 0x3e, 0x8e, 0x98, 0x19, 0x00, 0x00,
}
func (x Direction) String() string {
@ -4495,6 +4489,9 @@ type QuerierClient interface {
Series(ctx context.Context, in *SeriesRequest, opts ...grpc.CallOption) (*SeriesResponse, error)
TailersCount(ctx context.Context, in *TailersCountRequest, opts ...grpc.CallOption) (*TailersCountResponse, error)
GetChunkIDs(ctx context.Context, in *GetChunkIDsRequest, opts ...grpc.CallOption) (*GetChunkIDsResponse, error)
// Note: this MUST be the same as the variant defined in
// indexgateway.proto on the IndexGateway service.
GetStats(ctx context.Context, in *IndexStatsRequest, opts ...grpc.CallOption) (*IndexStatsResponse, error)
}
type querierClient struct {
@ -4637,6 +4634,15 @@ func (c *querierClient) GetChunkIDs(ctx context.Context, in *GetChunkIDsRequest,
return out, nil
}
func (c *querierClient) GetStats(ctx context.Context, in *IndexStatsRequest, opts ...grpc.CallOption) (*IndexStatsResponse, error) {
out := new(IndexStatsResponse)
err := c.cc.Invoke(ctx, "/logproto.Querier/GetStats", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// QuerierServer is the server API for Querier service.
type QuerierServer interface {
Query(*QueryRequest, Querier_QueryServer) error
@ -4646,6 +4652,9 @@ type QuerierServer interface {
Series(context.Context, *SeriesRequest) (*SeriesResponse, error)
TailersCount(context.Context, *TailersCountRequest) (*TailersCountResponse, error)
GetChunkIDs(context.Context, *GetChunkIDsRequest) (*GetChunkIDsResponse, error)
// Note: this MUST be the same as the variant defined in
// indexgateway.proto on the IndexGateway service.
GetStats(context.Context, *IndexStatsRequest) (*IndexStatsResponse, error)
}
// UnimplementedQuerierServer can be embedded to have forward compatible implementations.
@ -4673,6 +4682,9 @@ func (*UnimplementedQuerierServer) TailersCount(ctx context.Context, req *Tailer
func (*UnimplementedQuerierServer) GetChunkIDs(ctx context.Context, req *GetChunkIDsRequest) (*GetChunkIDsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetChunkIDs not implemented")
}
func (*UnimplementedQuerierServer) GetStats(ctx context.Context, req *IndexStatsRequest) (*IndexStatsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetStats not implemented")
}
func RegisterQuerierServer(s *grpc.Server, srv QuerierServer) {
s.RegisterService(&_Querier_serviceDesc, srv)
@ -4813,6 +4825,24 @@ func _Querier_GetChunkIDs_Handler(srv interface{}, ctx context.Context, dec func
return interceptor(ctx, in, info, handler)
}
func _Querier_GetStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(IndexStatsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(QuerierServer).GetStats(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/logproto.Querier/GetStats",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(QuerierServer).GetStats(ctx, req.(*IndexStatsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _Querier_serviceDesc = grpc.ServiceDesc{
ServiceName: "logproto.Querier",
HandlerType: (*QuerierServer)(nil),
@ -4833,6 +4863,10 @@ var _Querier_serviceDesc = grpc.ServiceDesc{
MethodName: "GetChunkIDs",
Handler: _Querier_GetChunkIDs_Handler,
},
{
MethodName: "GetStats",
Handler: _Querier_GetStats_Handler,
},
},
Streams: []grpc.StreamDesc{
{
@ -4960,292 +4994,6 @@ var _Ingester_serviceDesc = grpc.ServiceDesc{
Metadata: "pkg/logproto/logproto.proto",
}
// IndexGatewayClient is the client API for IndexGateway service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type IndexGatewayClient interface {
/// QueryIndex reads the indexes required for given query & sends back the batch of rows
/// in rpc streams
QueryIndex(ctx context.Context, in *QueryIndexRequest, opts ...grpc.CallOption) (IndexGateway_QueryIndexClient, error)
/// GetChunkRef returns chunk reference that match the provided label matchers
GetChunkRef(ctx context.Context, in *GetChunkRefRequest, opts ...grpc.CallOption) (*GetChunkRefResponse, error)
GetSeries(ctx context.Context, in *GetSeriesRequest, opts ...grpc.CallOption) (*GetSeriesResponse, error)
LabelNamesForMetricName(ctx context.Context, in *LabelNamesForMetricNameRequest, opts ...grpc.CallOption) (*LabelResponse, error)
LabelValuesForMetricName(ctx context.Context, in *LabelValuesForMetricNameRequest, opts ...grpc.CallOption) (*LabelResponse, error)
GetStats(ctx context.Context, in *IndexStatsRequest, opts ...grpc.CallOption) (*IndexStatsResponse, error)
}
type indexGatewayClient struct {
cc *grpc.ClientConn
}
func NewIndexGatewayClient(cc *grpc.ClientConn) IndexGatewayClient {
return &indexGatewayClient{cc}
}
func (c *indexGatewayClient) QueryIndex(ctx context.Context, in *QueryIndexRequest, opts ...grpc.CallOption) (IndexGateway_QueryIndexClient, error) {
stream, err := c.cc.NewStream(ctx, &_IndexGateway_serviceDesc.Streams[0], "/logproto.IndexGateway/QueryIndex", opts...)
if err != nil {
return nil, err
}
x := &indexGatewayQueryIndexClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type IndexGateway_QueryIndexClient interface {
Recv() (*QueryIndexResponse, error)
grpc.ClientStream
}
type indexGatewayQueryIndexClient struct {
grpc.ClientStream
}
func (x *indexGatewayQueryIndexClient) Recv() (*QueryIndexResponse, error) {
m := new(QueryIndexResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *indexGatewayClient) GetChunkRef(ctx context.Context, in *GetChunkRefRequest, opts ...grpc.CallOption) (*GetChunkRefResponse, error) {
out := new(GetChunkRefResponse)
err := c.cc.Invoke(ctx, "/logproto.IndexGateway/GetChunkRef", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *indexGatewayClient) GetSeries(ctx context.Context, in *GetSeriesRequest, opts ...grpc.CallOption) (*GetSeriesResponse, error) {
out := new(GetSeriesResponse)
err := c.cc.Invoke(ctx, "/logproto.IndexGateway/GetSeries", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *indexGatewayClient) LabelNamesForMetricName(ctx context.Context, in *LabelNamesForMetricNameRequest, opts ...grpc.CallOption) (*LabelResponse, error) {
out := new(LabelResponse)
err := c.cc.Invoke(ctx, "/logproto.IndexGateway/LabelNamesForMetricName", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *indexGatewayClient) LabelValuesForMetricName(ctx context.Context, in *LabelValuesForMetricNameRequest, opts ...grpc.CallOption) (*LabelResponse, error) {
out := new(LabelResponse)
err := c.cc.Invoke(ctx, "/logproto.IndexGateway/LabelValuesForMetricName", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *indexGatewayClient) GetStats(ctx context.Context, in *IndexStatsRequest, opts ...grpc.CallOption) (*IndexStatsResponse, error) {
out := new(IndexStatsResponse)
err := c.cc.Invoke(ctx, "/logproto.IndexGateway/GetStats", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// IndexGatewayServer is the server API for IndexGateway service.
type IndexGatewayServer interface {
/// QueryIndex reads the indexes required for given query & sends back the batch of rows
/// in rpc streams
QueryIndex(*QueryIndexRequest, IndexGateway_QueryIndexServer) error
/// GetChunkRef returns chunk reference that match the provided label matchers
GetChunkRef(context.Context, *GetChunkRefRequest) (*GetChunkRefResponse, error)
GetSeries(context.Context, *GetSeriesRequest) (*GetSeriesResponse, error)
LabelNamesForMetricName(context.Context, *LabelNamesForMetricNameRequest) (*LabelResponse, error)
LabelValuesForMetricName(context.Context, *LabelValuesForMetricNameRequest) (*LabelResponse, error)
GetStats(context.Context, *IndexStatsRequest) (*IndexStatsResponse, error)
}
// UnimplementedIndexGatewayServer can be embedded to have forward compatible implementations.
type UnimplementedIndexGatewayServer struct {
}
func (*UnimplementedIndexGatewayServer) QueryIndex(req *QueryIndexRequest, srv IndexGateway_QueryIndexServer) error {
return status.Errorf(codes.Unimplemented, "method QueryIndex not implemented")
}
func (*UnimplementedIndexGatewayServer) GetChunkRef(ctx context.Context, req *GetChunkRefRequest) (*GetChunkRefResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetChunkRef not implemented")
}
func (*UnimplementedIndexGatewayServer) GetSeries(ctx context.Context, req *GetSeriesRequest) (*GetSeriesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetSeries not implemented")
}
func (*UnimplementedIndexGatewayServer) LabelNamesForMetricName(ctx context.Context, req *LabelNamesForMetricNameRequest) (*LabelResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method LabelNamesForMetricName not implemented")
}
func (*UnimplementedIndexGatewayServer) LabelValuesForMetricName(ctx context.Context, req *LabelValuesForMetricNameRequest) (*LabelResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method LabelValuesForMetricName not implemented")
}
func (*UnimplementedIndexGatewayServer) GetStats(ctx context.Context, req *IndexStatsRequest) (*IndexStatsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetStats not implemented")
}
func RegisterIndexGatewayServer(s *grpc.Server, srv IndexGatewayServer) {
s.RegisterService(&_IndexGateway_serviceDesc, srv)
}
func _IndexGateway_QueryIndex_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(QueryIndexRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(IndexGatewayServer).QueryIndex(m, &indexGatewayQueryIndexServer{stream})
}
type IndexGateway_QueryIndexServer interface {
Send(*QueryIndexResponse) error
grpc.ServerStream
}
type indexGatewayQueryIndexServer struct {
grpc.ServerStream
}
func (x *indexGatewayQueryIndexServer) Send(m *QueryIndexResponse) error {
return x.ServerStream.SendMsg(m)
}
func _IndexGateway_GetChunkRef_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetChunkRefRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(IndexGatewayServer).GetChunkRef(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/logproto.IndexGateway/GetChunkRef",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IndexGatewayServer).GetChunkRef(ctx, req.(*GetChunkRefRequest))
}
return interceptor(ctx, in, info, handler)
}
func _IndexGateway_GetSeries_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetSeriesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(IndexGatewayServer).GetSeries(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/logproto.IndexGateway/GetSeries",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IndexGatewayServer).GetSeries(ctx, req.(*GetSeriesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _IndexGateway_LabelNamesForMetricName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(LabelNamesForMetricNameRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(IndexGatewayServer).LabelNamesForMetricName(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/logproto.IndexGateway/LabelNamesForMetricName",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IndexGatewayServer).LabelNamesForMetricName(ctx, req.(*LabelNamesForMetricNameRequest))
}
return interceptor(ctx, in, info, handler)
}
func _IndexGateway_LabelValuesForMetricName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(LabelValuesForMetricNameRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(IndexGatewayServer).LabelValuesForMetricName(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/logproto.IndexGateway/LabelValuesForMetricName",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IndexGatewayServer).LabelValuesForMetricName(ctx, req.(*LabelValuesForMetricNameRequest))
}
return interceptor(ctx, in, info, handler)
}
func _IndexGateway_GetStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(IndexStatsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(IndexGatewayServer).GetStats(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/logproto.IndexGateway/GetStats",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IndexGatewayServer).GetStats(ctx, req.(*IndexStatsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _IndexGateway_serviceDesc = grpc.ServiceDesc{
ServiceName: "logproto.IndexGateway",
HandlerType: (*IndexGatewayServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "GetChunkRef",
Handler: _IndexGateway_GetChunkRef_Handler,
},
{
MethodName: "GetSeries",
Handler: _IndexGateway_GetSeries_Handler,
},
{
MethodName: "LabelNamesForMetricName",
Handler: _IndexGateway_LabelNamesForMetricName_Handler,
},
{
MethodName: "LabelValuesForMetricName",
Handler: _IndexGateway_LabelValuesForMetricName_Handler,
},
{
MethodName: "GetStats",
Handler: _IndexGateway_GetStats_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "QueryIndex",
Handler: _IndexGateway_QueryIndex_Handler,
ServerStreams: true,
},
},
Metadata: "pkg/logproto/logproto.proto",
}
func (m *PushRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)

@ -26,6 +26,10 @@ service Querier {
rpc TailersCount(TailersCountRequest) returns (TailersCountResponse) {}
rpc GetChunkIDs(GetChunkIDsRequest) returns (GetChunkIDsResponse) {}
// Note: this MUST be the same as the variant defined in
// indexgateway.proto on the IndexGateway service.
rpc GetStats(IndexStatsRequest) returns (IndexStatsResponse) {}
}
service Ingester {
@ -277,20 +281,6 @@ message ChunkRef {
uint32 checksum = 5 [(gogoproto.jsontag) = "-"];
}
service IndexGateway {
/// QueryIndex reads the indexes required for given query & sends back the batch of rows
/// in rpc streams
rpc QueryIndex(QueryIndexRequest) returns (stream QueryIndexResponse);
/// GetChunkRef returns chunk reference that match the provided label matchers
rpc GetChunkRef(GetChunkRefRequest) returns (GetChunkRefResponse) {}
rpc GetSeries(GetSeriesRequest) returns (GetSeriesResponse) {}
rpc LabelNamesForMetricName(LabelNamesForMetricNameRequest) returns (LabelResponse) {}
rpc LabelValuesForMetricName(LabelValuesForMetricNameRequest) returns (LabelResponse) {}
rpc GetStats(IndexStatsRequest) returns (IndexStatsResponse) {}
}
message LabelValuesForMetricNameRequest {
string metric_name = 1;
string label_name = 2;

@ -6,6 +6,7 @@ import (
"strings"
"time"
"github.com/gogo/status"
"github.com/grafana/dskit/ring"
ring_client "github.com/grafana/dskit/ring/client"
"github.com/grafana/dskit/services"
@ -13,13 +14,16 @@ import (
"github.com/prometheus/common/model"
"github.com/prometheus/prometheus/model/labels"
"github.com/weaveworks/common/httpgrpc"
"google.golang.org/grpc/codes"
"github.com/grafana/loki/pkg/distributor/clientpool"
"github.com/grafana/loki/pkg/ingester/client"
"github.com/grafana/loki/pkg/iter"
"github.com/grafana/loki/pkg/logproto"
"github.com/grafana/loki/pkg/logql"
"github.com/grafana/loki/pkg/logql/syntax"
"github.com/grafana/loki/pkg/logqlmodel/stats"
index_stats "github.com/grafana/loki/pkg/storage/stores/index/stats"
util_log "github.com/grafana/loki/pkg/util/log"
)
@ -287,6 +291,32 @@ func (q *IngesterQuerier) GetChunkIDs(ctx context.Context, from, through model.T
return chunkIDs, nil
}
func (q *IngesterQuerier) Stats(ctx context.Context, userID string, from, through model.Time, matchers ...*labels.Matcher) (*index_stats.Stats, error) {
resps, err := q.forAllIngesters(ctx, func(querierClient logproto.QuerierClient) (interface{}, error) {
return querierClient.GetStats(ctx, &logproto.IndexStatsRequest{
From: from,
Through: through,
Matchers: syntax.MatchersString(matchers),
})
})
if err != nil {
if isUnimplementedCallError(err) {
// Handle communication with older ingesters gracefully
return &index_stats.Stats{}, nil
}
return nil, err
}
casted := make([]*index_stats.Stats, 0, len(resps))
for _, resp := range resps {
casted = append(casted, resp.response.(*index_stats.Stats))
}
merged := index_stats.MergeStats(casted...)
return &merged, nil
}
func convertMatchersToString(matchers []*labels.Matcher) string {
out := strings.Builder{}
out.WriteRune('{')
@ -302,3 +332,16 @@ func convertMatchersToString(matchers []*labels.Matcher) string {
out.WriteRune('}')
return out.String()
}
// isUnimplementedCallError tells if the GRPC error is a gRPC error with code Unimplemented.
func isUnimplementedCallError(err error) bool {
if err == nil {
return false
}
s, ok := status.FromError(err)
if !ok {
return false
}
return (s.Code() == codes.Unimplemented)
}

@ -6,6 +6,7 @@ import (
"time"
"github.com/go-kit/log/level"
"github.com/grafana/dskit/concurrency"
"github.com/prometheus/common/model"
"github.com/prometheus/prometheus/model/labels"
@ -13,13 +14,14 @@ import (
"github.com/grafana/loki/pkg/storage/chunk/fetcher"
"github.com/grafana/loki/pkg/storage/config"
"github.com/grafana/loki/pkg/storage/stores"
"github.com/grafana/loki/pkg/util/spanlogger"
"github.com/grafana/loki/pkg/storage/stores/index/stats"
util_log "github.com/grafana/loki/pkg/util/log"
"github.com/grafana/loki/pkg/util/spanlogger"
)
type IngesterQuerier interface {
GetChunkIDs(ctx context.Context, from, through model.Time, matchers ...*labels.Matcher) ([]string, error)
Stats(ctx context.Context, userID string, from, through model.Time, matchers ...*labels.Matcher) (*stats.Stats, error)
}
type AsyncStoreCfg struct {
@ -97,6 +99,42 @@ func (a *AsyncStore) GetChunkRefs(ctx context.Context, userID string, from, thro
return a.mergeIngesterAndStoreChunks(userID, storeChunks, fetchers, ingesterChunks)
}
func (a *AsyncStore) Stats(ctx context.Context, userID string, from, through model.Time, matchers ...*labels.Matcher) (*stats.Stats, error) {
if a.queryIngestersWithin != 0 {
// don't query ingesters if the query does not overlap with queryIngestersWithin.
if !through.After(model.Now().Add(-a.queryIngestersWithin)) {
return a.Store.Stats(ctx, userID, from, through, matchers...)
}
}
type f func() (*stats.Stats, error)
jobs := []f{
f(func() (*stats.Stats, error) {
return a.ingesterQuerier.Stats(ctx, userID, from, through, matchers...)
}),
f(func() (*stats.Stats, error) {
return a.Store.Stats(ctx, userID, from, through, matchers...)
}),
}
resps := make([]*stats.Stats, len(jobs))
if err := concurrency.ForEachJob(
ctx,
len(jobs),
2,
func(ctx context.Context, i int) error {
resp, err := jobs[i]()
resps[i] = resp
return err
},
); err != nil {
return nil, err
}
merged := stats.MergeStats(resps...)
return &merged, nil
}
func (a *AsyncStore) mergeIngesterAndStoreChunks(userID string, storeChunks [][]chunk.Chunk, fetchers []*fetcher.Fetcher, ingesterChunkIDs []string) ([][]chunk.Chunk, []*fetcher.Fetcher, error) {
ingesterChunkIDs = filterDuplicateChunks(a.scfg, storeChunks, ingesterChunkIDs)
level.Debug(util_log.Logger).Log("msg", "post-filtering ingester chunks", "count", len(ingesterChunkIDs))

Loading…
Cancel
Save