From 3ca718f26ba079b0882ace1aeb7434f1c291ae44 Mon Sep 17 00:00:00 2001 From: Michael Hoffmann Date: Sat, 27 Apr 2024 09:29:51 +0200 Subject: [PATCH 1/2] Proxy: acceptance test for proxy store with replica labels Signed-off-by: Michael Hoffmann --- pkg/store/acceptance_test.go | 43 +++++++++++++++++++++++++++++++----- 1 file changed, 38 insertions(+), 5 deletions(-) diff --git a/pkg/store/acceptance_test.go b/pkg/store/acceptance_test.go index 6355ebb1c6..c9aeae651f 100644 --- a/pkg/store/acceptance_test.go +++ b/pkg/store/acceptance_test.go @@ -109,6 +109,7 @@ func testStoreAPIsAcceptance(t *testing.T, startStore startStoreFn) { }, labelValuesCalls: []labelValuesCallCase{ {start: timestamp.FromTime(minTime), end: timestamp.FromTime(maxTime), label: "foo", expectedValues: []string{"foovalue1"}}, + {start: timestamp.FromTime(minTime), end: timestamp.FromTime(maxTime), label: "replica"}, }, }, { @@ -740,7 +741,7 @@ func testStoreAPIsAcceptance(t *testing.T, startStore startStoreFn) { }) } for _, c := range tc.labelValuesCalls { - t.Run("label_name_values", func(t *testing.T) { + t.Run("label_values", func(t *testing.T) { resp, err := store.LabelValues(context.Background(), &storepb.LabelValuesRequest{ Start: c.start, End: c.end, @@ -764,10 +765,11 @@ func testStoreAPIsAcceptance(t *testing.T, startStore startStoreFn) { t.Run("series", func(t *testing.T) { srv := newStoreSeriesServer(context.Background()) err := store.Series(&storepb.SeriesRequest{ - MinTime: c.start, - MaxTime: c.end, - Matchers: c.matchers, - SkipChunks: c.skipChunks, + MinTime: c.start, + MaxTime: c.end, + Matchers: c.matchers, + SkipChunks: c.skipChunks, + WithoutReplicaLabels: []string{"replica"}, }, srv) if c.expectErr != nil { testutil.NotOk(t, err) @@ -1026,3 +1028,34 @@ func TestProxyStoreWithTSDBSelector_Acceptance(t *testing.T) { testStoreAPIsAcceptance(t, startStore) } + +func TestProxyStoreWithReplicas_Acceptance(t *testing.T) { + t.Cleanup(func() { custom.TolerantVerifyLeak(t) }) + + startStore := func(tt *testing.T, extLset labels.Labels, appendFn func(app storage.Appender)) storepb.StoreServer { + startNestedStore := func(tt *testing.T, extLset labels.Labels, appendFn func(app storage.Appender)) storepb.StoreServer { + db, err := e2eutil.NewTSDB() + testutil.Ok(tt, err) + tt.Cleanup(func() { testutil.Ok(tt, db.Close()) }) + appendFn(db.Appender(context.Background())) + + return NewTSDBStore(nil, db, component.Rule, extLset) + + } + + extLset1 := labels.NewBuilder(extLset).Set("replica", "r1").Labels() + extLset2 := labels.NewBuilder(extLset).Set("replica", "r2").Labels() + + p1 := startNestedStore(tt, extLset1, appendFn) + p2 := startNestedStore(tt, extLset2, appendFn) + + clients := []Client{ + storetestutil.TestClient{StoreClient: storepb.ServerAsClient(p1), ExtLset: []labels.Labels{extLset1}}, + storetestutil.TestClient{StoreClient: storepb.ServerAsClient(p2), ExtLset: []labels.Labels{extLset2}}, + } + + return NewProxyStore(nil, nil, func() []Client { return clients }, component.Query, labels.EmptyLabels(), 0*time.Second, RetrievalStrategy(EagerRetrieval)) + } + + testStoreAPIsAcceptance(t, startStore) +} From a719ea3227a5ddc851958d92b147812523e86878 Mon Sep 17 00:00:00 2001 From: Michael Hoffmann Date: Sat, 27 Apr 2024 10:10:40 +0200 Subject: [PATCH 2/2] Stores: handle replica labels in label_value and label_names grpcs Signed-off-by: Michael Hoffmann --- pkg/query/querier.go | 21 ++- pkg/store/acceptance_test.go | 49 ++++--- pkg/store/bucket.go | 31 ++-- pkg/store/prometheus.go | 14 +- pkg/store/proxy.go | 2 + pkg/store/storepb/rpc.pb.go | 267 ++++++++++++++++++++++++----------- pkg/store/storepb/rpc.proto | 6 + pkg/store/tsdb.go | 14 +- 8 files changed, 282 insertions(+), 122 deletions(-) diff --git a/pkg/query/querier.go b/pkg/query/querier.go index d55285b459..c26bd025ce 100644 --- a/pkg/query/querier.go +++ b/pkg/query/querier.go @@ -399,14 +399,19 @@ func (q *querier) LabelValues(ctx context.Context, name string, matchers ...*lab if err != nil { return nil, nil, errors.Wrap(err, "converting prom matchers to storepb matchers") } - - resp, err := q.proxy.LabelValues(ctx, &storepb.LabelValuesRequest{ + req := &storepb.LabelValuesRequest{ Label: name, PartialResponseStrategy: q.partialResponseStrategy, Start: q.mint, End: q.maxt, Matchers: pbMatchers, - }) + } + + if q.isDedupEnabled() { + req.WithoutReplicaLabels = q.replicaLabels + } + + resp, err := q.proxy.LabelValues(ctx, req) if err != nil { return nil, nil, errors.Wrap(err, "proxy LabelValues()") } @@ -433,12 +438,18 @@ func (q *querier) LabelNames(ctx context.Context, matchers ...*labels.Matcher) ( return nil, nil, errors.Wrap(err, "converting prom matchers to storepb matchers") } - resp, err := q.proxy.LabelNames(ctx, &storepb.LabelNamesRequest{ + req := &storepb.LabelNamesRequest{ PartialResponseStrategy: q.partialResponseStrategy, Start: q.mint, End: q.maxt, Matchers: pbMatchers, - }) + } + + if q.isDedupEnabled() { + req.WithoutReplicaLabels = q.replicaLabels + } + + resp, err := q.proxy.LabelNames(ctx, req) if err != nil { return nil, nil, errors.Wrap(err, "proxy LabelNames()") } diff --git a/pkg/store/acceptance_test.go b/pkg/store/acceptance_test.go index c9aeae651f..d0921be50a 100644 --- a/pkg/store/acceptance_test.go +++ b/pkg/store/acceptance_test.go @@ -723,9 +723,10 @@ func testStoreAPIsAcceptance(t *testing.T, startStore startStoreFn) { for _, c := range tc.labelNameCalls { t.Run("label_names", func(t *testing.T) { resp, err := store.LabelNames(context.Background(), &storepb.LabelNamesRequest{ - Start: c.start, - End: c.end, - Matchers: c.matchers, + Start: c.start, + End: c.end, + Matchers: c.matchers, + WithoutReplicaLabels: []string{"replica"}, }) if c.expectErr != nil { testutil.NotOk(t, err) @@ -743,10 +744,11 @@ func testStoreAPIsAcceptance(t *testing.T, startStore startStoreFn) { for _, c := range tc.labelValuesCalls { t.Run("label_values", func(t *testing.T) { resp, err := store.LabelValues(context.Background(), &storepb.LabelValuesRequest{ - Start: c.start, - End: c.end, - Label: c.label, - Matchers: c.matchers, + Start: c.start, + End: c.end, + Label: c.label, + Matchers: c.matchers, + WithoutReplicaLabels: []string{"replica"}, }) if c.expectErr != nil { testutil.NotOk(t, err) @@ -884,23 +886,24 @@ func TestBucketStore_Acceptance(t *testing.T) { tt.Skip("Bucket Store cannot handle empty HEAD") } - id := createBlockFromHead(tt, auxDir, h) + for _, replica := range []string{"r1", "r2"} { + id := createBlockFromHead(tt, auxDir, h) - auxBlockDir := filepath.Join(auxDir, id.String()) - meta, err := metadata.ReadFromDir(auxBlockDir) - testutil.Ok(t, err) - stats, err := block.GatherIndexHealthStats(ctx, logger, filepath.Join(auxBlockDir, block.IndexFilename), meta.MinTime, meta.MaxTime) - testutil.Ok(t, err) - _, err = metadata.InjectThanos(log.NewNopLogger(), auxBlockDir, metadata.Thanos{ - Labels: extLset.Map(), - Downsample: metadata.ThanosDownsample{Resolution: 0}, - Source: metadata.TestSource, - IndexStats: metadata.IndexStats{SeriesMaxSize: stats.SeriesMaxSize, ChunkMaxSize: stats.ChunkMaxSize}, - }, nil) - testutil.Ok(tt, err) - - testutil.Ok(tt, block.Upload(ctx, logger, bkt, auxBlockDir, metadata.NoneFunc)) - testutil.Ok(tt, block.Upload(ctx, logger, bkt, auxBlockDir, metadata.NoneFunc)) + auxBlockDir := filepath.Join(auxDir, id.String()) + meta, err := metadata.ReadFromDir(auxBlockDir) + testutil.Ok(t, err) + stats, err := block.GatherIndexHealthStats(ctx, logger, filepath.Join(auxBlockDir, block.IndexFilename), meta.MinTime, meta.MaxTime) + testutil.Ok(t, err) + _, err = metadata.InjectThanos(log.NewNopLogger(), auxBlockDir, metadata.Thanos{ + Labels: labels.NewBuilder(extLset).Set("replica", replica).Labels().Map(), + Downsample: metadata.ThanosDownsample{Resolution: 0}, + Source: metadata.TestSource, + IndexStats: metadata.IndexStats{SeriesMaxSize: stats.SeriesMaxSize, ChunkMaxSize: stats.ChunkMaxSize}, + }, nil) + testutil.Ok(tt, err) + + testutil.Ok(tt, block.Upload(ctx, logger, bkt, auxBlockDir, metadata.NoneFunc)) + } chunkPool, err := NewDefaultChunkBytesPool(2e5) testutil.Ok(tt, err) diff --git a/pkg/store/bucket.go b/pkg/store/bucket.go index 1b530cd9ed..43ac0d6c1a 100644 --- a/pkg/store/bucket.go +++ b/pkg/store/bucket.go @@ -1749,6 +1749,12 @@ func (s *BucketStore) LabelNames(ctx context.Context, req *storepb.LabelNamesReq return nil, status.Error(codes.InvalidArgument, errors.Wrap(err, "translate request hints labels matchers").Error()) } } + extLsetToRemove := make(map[string]struct{}) + if len(req.WithoutReplicaLabels) > 0 { + for _, l := range req.WithoutReplicaLabels { + extLsetToRemove[l] = struct{}{} + } + } g, gctx := errgroup.WithContext(ctx) @@ -1805,15 +1811,18 @@ func (s *BucketStore) LabelNames(ctx context.Context, req *storepb.LabelNamesReq // b.extLset is already sorted by label name, no need to sort it again. extRes := make([]string, 0, b.extLset.Len()) b.extLset.Range(func(l labels.Label) { - extRes = append(extRes, l.Name) + if _, ok := extLsetToRemove[l.Name]; !ok { + extRes = append(extRes, l.Name) + } }) result = strutil.MergeSlices(res, extRes) } else { seriesReq := &storepb.SeriesRequest{ - MinTime: req.Start, - MaxTime: req.End, - SkipChunks: true, + MinTime: req.Start, + MaxTime: req.End, + SkipChunks: true, + WithoutReplicaLabels: req.WithoutReplicaLabels, } blockClient := newBlockSeriesClient( newCtx, @@ -1830,7 +1839,7 @@ func (s *BucketStore) LabelNames(ctx context.Context, req *storepb.LabelNamesReq s.metrics.seriesFetchDurationSum, nil, nil, - nil, + extLsetToRemove, s.enabledLazyExpandedPostings, s.metrics.lazyExpandedPostingsCount, s.metrics.lazyExpandedPostingSizeBytes, @@ -1932,6 +1941,11 @@ func (s *BucketStore) LabelValues(ctx context.Context, req *storepb.LabelValuesR if err != nil { return nil, status.Error(codes.InvalidArgument, errors.Wrap(err, "translate request labels matchers").Error()) } + for i := range req.WithoutReplicaLabels { + if req.Label == req.WithoutReplicaLabels[i] { + return &storepb.LabelValuesResponse{}, nil + } + } tenant, _ := tenancy.GetTenantFromGRPCMetadata(ctx) @@ -2016,9 +2030,10 @@ func (s *BucketStore) LabelValues(ctx context.Context, req *storepb.LabelValuesR result = res } else { seriesReq := &storepb.SeriesRequest{ - MinTime: req.Start, - MaxTime: req.End, - SkipChunks: true, + MinTime: req.Start, + MaxTime: req.End, + SkipChunks: true, + WithoutReplicaLabels: req.WithoutReplicaLabels, } blockClient := newBlockSeriesClient( newCtx, diff --git a/pkg/store/prometheus.go b/pkg/store/prometheus.go index c03d489a95..d52fcb07d9 100644 --- a/pkg/store/prometheus.go +++ b/pkg/store/prometheus.go @@ -606,9 +606,16 @@ func (p *PrometheusStore) LabelNames(ctx context.Context, r *storepb.LabelNamesR } } + extLsetToRemove := map[string]struct{}{} + for _, lbl := range r.WithoutReplicaLabels { + extLsetToRemove[lbl] = struct{}{} + } + if len(lbls) > 0 { extLset.Range(func(l labels.Label) { - lbls = append(lbls, l.Name) + if _, ok := extLsetToRemove[l.Name]; !ok { + lbls = append(lbls, l.Name) + } }) sort.Strings(lbls) } @@ -621,6 +628,11 @@ func (p *PrometheusStore) LabelValues(ctx context.Context, r *storepb.LabelValue if r.Label == "" { return nil, status.Error(codes.InvalidArgument, "label name parameter cannot be empty") } + for i := range r.WithoutReplicaLabels { + if r.Label == r.WithoutReplicaLabels[i] { + return &storepb.LabelValuesResponse{}, nil + } + } extLset := p.externalLabelsFn() diff --git a/pkg/store/proxy.go b/pkg/store/proxy.go index 03ccd86b64..778879e117 100644 --- a/pkg/store/proxy.go +++ b/pkg/store/proxy.go @@ -531,6 +531,7 @@ func (s *ProxyStore) LabelNames(ctx context.Context, r *storepb.LabelNamesReques Start: r.Start, End: r.End, Matchers: append(r.Matchers, MatchersForLabelSets(extraMatchers)...), + WithoutReplicaLabels: r.WithoutReplicaLabels, }) if err != nil { err = errors.Wrapf(err, "fetch label names from store %s", st) @@ -633,6 +634,7 @@ func (s *ProxyStore) LabelValues(ctx context.Context, r *storepb.LabelValuesRequ Start: r.Start, End: r.End, Matchers: append(r.Matchers, MatchersForLabelSets(extraMatchers)...), + WithoutReplicaLabels: r.WithoutReplicaLabels, }) if err != nil { msg := "fetch label values from store %s" diff --git a/pkg/store/storepb/rpc.pb.go b/pkg/store/storepb/rpc.pb.go index db64cf60c8..b5e85d69d8 100644 --- a/pkg/store/storepb/rpc.pb.go +++ b/pkg/store/storepb/rpc.pb.go @@ -657,6 +657,8 @@ type LabelNamesRequest struct { // implementation of a specific store. Hints *types.Any `protobuf:"bytes,5,opt,name=hints,proto3" json:"hints,omitempty"` Matchers []LabelMatcher `protobuf:"bytes,6,rep,name=matchers,proto3" json:"matchers"` + // same as in series request. + WithoutReplicaLabels []string `protobuf:"bytes,7,rep,name=without_replica_labels,json=withoutReplicaLabels,proto3" json:"without_replica_labels,omitempty"` } func (m *LabelNamesRequest) Reset() { *m = LabelNamesRequest{} } @@ -746,6 +748,8 @@ type LabelValuesRequest struct { // implementation of a specific store. Hints *types.Any `protobuf:"bytes,6,opt,name=hints,proto3" json:"hints,omitempty"` Matchers []LabelMatcher `protobuf:"bytes,7,rep,name=matchers,proto3" json:"matchers"` + // same as in series request. + WithoutReplicaLabels []string `protobuf:"bytes,8,rep,name=without_replica_labels,json=withoutReplicaLabels,proto3" json:"without_replica_labels,omitempty"` } func (m *LabelValuesRequest) Reset() { *m = LabelValuesRequest{} } @@ -846,90 +850,91 @@ func init() { func init() { proto.RegisterFile("store/storepb/rpc.proto", fileDescriptor_a938d55a388af629) } var fileDescriptor_a938d55a388af629 = []byte{ - // 1323 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xdd, 0x6e, 0x13, 0xc7, - 0x17, 0xf7, 0x7a, 0xbd, 0xfe, 0x38, 0x4e, 0xf2, 0x37, 0x83, 0x09, 0x1b, 0x23, 0x39, 0xfe, 0xbb, - 0xaa, 0x64, 0x21, 0x6a, 0x53, 0x83, 0x90, 0x5a, 0x71, 0x93, 0x04, 0x43, 0xa2, 0x12, 0x53, 0xc6, - 0x09, 0x69, 0xa9, 0x2a, 0x6b, 0x6d, 0x4f, 0xd6, 0x2b, 0xec, 0xdd, 0x65, 0x67, 0xb6, 0x89, 0x6f, - 0xdb, 0xdb, 0xaa, 0xaa, 0xfa, 0x08, 0x7d, 0x8a, 0x3e, 0x02, 0x77, 0xe5, 0xb2, 0xea, 0x05, 0x6a, - 0xe1, 0x45, 0xaa, 0x39, 0x3b, 0x6b, 0x7b, 0xd3, 0x00, 0x45, 0x70, 0x13, 0xcd, 0xf9, 0xfd, 0xce, - 0x9c, 0x39, 0xdf, 0xde, 0xc0, 0x65, 0x2e, 0xbc, 0x80, 0xb5, 0xf0, 0xaf, 0x3f, 0x68, 0x05, 0xfe, - 0xb0, 0xe9, 0x07, 0x9e, 0xf0, 0x48, 0x56, 0x8c, 0x2d, 0xd7, 0xe3, 0x95, 0x8d, 0xa4, 0x82, 0x98, - 0xf9, 0x8c, 0x47, 0x2a, 0x95, 0xb2, 0xed, 0xd9, 0x1e, 0x1e, 0x5b, 0xf2, 0xa4, 0xd0, 0x5a, 0xf2, - 0x82, 0x1f, 0x78, 0xd3, 0x33, 0xf7, 0x94, 0xc9, 0x89, 0x35, 0x60, 0x93, 0xb3, 0x94, 0xed, 0x79, - 0xf6, 0x84, 0xb5, 0x50, 0x1a, 0x84, 0xc7, 0x2d, 0xcb, 0x9d, 0x45, 0x54, 0xfd, 0x7f, 0xb0, 0x7a, - 0x14, 0x38, 0x82, 0x51, 0xc6, 0x7d, 0xcf, 0xe5, 0xac, 0xfe, 0x83, 0x06, 0x2b, 0x0a, 0x79, 0x1a, - 0x32, 0x2e, 0xc8, 0x16, 0x80, 0x70, 0xa6, 0x8c, 0xb3, 0xc0, 0x61, 0xdc, 0xd4, 0x6a, 0x7a, 0xa3, - 0xd8, 0xbe, 0x22, 0x6f, 0x4f, 0x99, 0x18, 0xb3, 0x90, 0xf7, 0x87, 0x9e, 0x3f, 0x6b, 0x1e, 0x38, - 0x53, 0xd6, 0x43, 0x95, 0xed, 0xcc, 0xb3, 0x17, 0x9b, 0x29, 0xba, 0x74, 0x89, 0xac, 0x43, 0x56, - 0x30, 0xd7, 0x72, 0x85, 0x99, 0xae, 0x69, 0x8d, 0x02, 0x55, 0x12, 0x31, 0x21, 0x17, 0x30, 0x7f, - 0xe2, 0x0c, 0x2d, 0x53, 0xaf, 0x69, 0x0d, 0x9d, 0xc6, 0x62, 0x7d, 0x15, 0x8a, 0x7b, 0xee, 0xb1, - 0xa7, 0x7c, 0xa8, 0xff, 0x92, 0x86, 0x95, 0x48, 0x8e, 0xbc, 0x24, 0x43, 0xc8, 0x62, 0xa0, 0xb1, - 0x43, 0xab, 0xcd, 0x28, 0xb1, 0xcd, 0xfb, 0x12, 0xdd, 0xbe, 0x2d, 0x5d, 0xf8, 0xf3, 0xc5, 0xe6, - 0x4d, 0xdb, 0x11, 0xe3, 0x70, 0xd0, 0x1c, 0x7a, 0xd3, 0x56, 0xa4, 0xf0, 0x89, 0xe3, 0xa9, 0x53, - 0xcb, 0x7f, 0x62, 0xb7, 0x12, 0x39, 0x6b, 0x3e, 0xc6, 0xdb, 0x54, 0x99, 0x26, 0x1b, 0x90, 0x9f, - 0x3a, 0x6e, 0x5f, 0x06, 0x82, 0x8e, 0xeb, 0x34, 0x37, 0x75, 0x5c, 0x19, 0x29, 0x52, 0xd6, 0x69, - 0x44, 0x29, 0xd7, 0xa7, 0xd6, 0x29, 0x52, 0x2d, 0x28, 0xa0, 0xd5, 0x83, 0x99, 0xcf, 0xcc, 0x4c, - 0x4d, 0x6b, 0xac, 0xb5, 0x2f, 0xc4, 0xde, 0xf5, 0x62, 0x82, 0x2e, 0x74, 0xc8, 0x2d, 0x00, 0x7c, - 0xb0, 0xcf, 0x99, 0xe0, 0xa6, 0x81, 0xf1, 0xcc, 0x6f, 0x44, 0x2e, 0xf5, 0x98, 0x50, 0x69, 0x2d, - 0x4c, 0x94, 0xcc, 0xeb, 0x3f, 0x1a, 0xb0, 0x1a, 0xa5, 0x3c, 0x2e, 0xd5, 0xb2, 0xc3, 0xda, 0xeb, - 0x1d, 0x4e, 0x27, 0x1d, 0xbe, 0x25, 0x29, 0x31, 0x1c, 0xb3, 0x80, 0x9b, 0x3a, 0xbe, 0x5e, 0x4e, - 0x64, 0x73, 0x3f, 0x22, 0x95, 0x03, 0x73, 0x5d, 0xd2, 0x86, 0x4b, 0xd2, 0x64, 0xc0, 0xb8, 0x37, - 0x09, 0x85, 0xe3, 0xb9, 0xfd, 0x13, 0xc7, 0x1d, 0x79, 0x27, 0x18, 0xb4, 0x4e, 0x2f, 0x4e, 0xad, - 0x53, 0x3a, 0xe7, 0x8e, 0x90, 0x22, 0xd7, 0x00, 0x2c, 0xdb, 0x0e, 0x98, 0x6d, 0x09, 0x16, 0xc5, - 0xba, 0xd6, 0x5e, 0x89, 0x5f, 0xdb, 0xb2, 0xed, 0x80, 0x2e, 0xf1, 0xe4, 0x73, 0xd8, 0xf0, 0xad, - 0x40, 0x38, 0xd6, 0x44, 0xbe, 0x82, 0x95, 0xef, 0x8f, 0x1c, 0x6e, 0x0d, 0x26, 0x6c, 0x64, 0x66, - 0x6b, 0x5a, 0x23, 0x4f, 0x2f, 0x2b, 0x85, 0xb8, 0x33, 0xee, 0x28, 0x9a, 0x7c, 0x73, 0xce, 0x5d, - 0x2e, 0x02, 0x4b, 0x30, 0x7b, 0x66, 0xe6, 0xb0, 0x2c, 0x9b, 0xf1, 0xc3, 0x5f, 0x26, 0x6d, 0xf4, - 0x94, 0xda, 0xbf, 0x8c, 0xc7, 0x04, 0xd9, 0x84, 0x22, 0x7f, 0xe2, 0xf8, 0xfd, 0xe1, 0x38, 0x74, - 0x9f, 0x70, 0x33, 0x8f, 0xae, 0x80, 0x84, 0x76, 0x10, 0x21, 0x57, 0xc1, 0x18, 0x3b, 0xae, 0xe0, - 0x66, 0xa1, 0xa6, 0x61, 0x42, 0xa3, 0x09, 0x6c, 0xc6, 0x13, 0xd8, 0xdc, 0x72, 0x67, 0x34, 0x52, - 0x21, 0x04, 0x32, 0x5c, 0x30, 0xdf, 0x04, 0x4c, 0x1b, 0x9e, 0x49, 0x19, 0x8c, 0xc0, 0x72, 0x6d, - 0x66, 0x16, 0x11, 0x8c, 0x04, 0x72, 0x03, 0x8a, 0x4f, 0x43, 0x16, 0xcc, 0xfa, 0x91, 0xed, 0x15, - 0xb4, 0x4d, 0xe2, 0x28, 0x1e, 0x4a, 0x6a, 0x57, 0x32, 0x14, 0x9e, 0xce, 0xcf, 0xe4, 0x3a, 0x00, - 0x1f, 0x5b, 0xc1, 0xa8, 0xef, 0xb8, 0xc7, 0x9e, 0xb9, 0x8a, 0x77, 0x16, 0x0d, 0x29, 0x19, 0x9c, - 0xac, 0x02, 0x8f, 0x8f, 0xe4, 0x26, 0xac, 0x9f, 0x38, 0x62, 0xec, 0x85, 0xa2, 0xaf, 0xe6, 0xb1, - 0xaf, 0x86, 0x6d, 0xad, 0xa6, 0x37, 0x0a, 0xb4, 0xac, 0x58, 0x1a, 0x91, 0xd8, 0x24, 0xbc, 0xfe, - 0xab, 0x06, 0xb0, 0x70, 0x01, 0x53, 0x24, 0x98, 0xdf, 0x9f, 0x3a, 0x93, 0x89, 0xc3, 0x55, 0x3b, - 0x82, 0x84, 0xf6, 0x11, 0x21, 0x35, 0xc8, 0x1c, 0x87, 0xee, 0x10, 0xbb, 0xb1, 0xb8, 0x68, 0x82, - 0xbb, 0xa1, 0x3b, 0xa4, 0xc8, 0x90, 0x6b, 0x90, 0xb7, 0x03, 0x2f, 0xf4, 0x1d, 0xd7, 0xc6, 0x9e, - 0x2a, 0xb6, 0x4b, 0xb1, 0xd6, 0x3d, 0x85, 0xd3, 0xb9, 0x06, 0xf9, 0x28, 0x4e, 0x99, 0x81, 0xaa, - 0xf3, 0x8d, 0x40, 0x25, 0xa8, 0x32, 0x58, 0x3f, 0x81, 0xc2, 0x3c, 0x64, 0x74, 0x51, 0x65, 0x66, - 0xc4, 0x4e, 0xe7, 0x2e, 0x46, 0xfc, 0x88, 0x9d, 0x92, 0xff, 0xc3, 0x8a, 0xf0, 0x84, 0x35, 0xe9, - 0x23, 0xc6, 0xd5, 0xe0, 0x14, 0x11, 0x43, 0x33, 0x9c, 0xac, 0x41, 0x7a, 0x30, 0xc3, 0x15, 0x90, - 0xa7, 0xe9, 0xc1, 0x4c, 0xae, 0x3a, 0x95, 0xab, 0x0c, 0xe6, 0x4a, 0x49, 0xf5, 0x0a, 0x64, 0x64, - 0x64, 0xb2, 0xd8, 0xae, 0xa5, 0xc6, 0xb3, 0x40, 0xf1, 0x5c, 0x6f, 0x43, 0x3e, 0x8e, 0x47, 0xd9, - 0xd3, 0xce, 0xb1, 0xa7, 0x27, 0xec, 0x6d, 0x82, 0x81, 0x81, 0x49, 0x85, 0x44, 0x8a, 0x95, 0x54, - 0xff, 0x49, 0x83, 0xb5, 0x78, 0x3b, 0xa8, 0xa5, 0xd9, 0x80, 0xec, 0x7c, 0x8b, 0xcb, 0x14, 0xad, - 0xcd, 0xbb, 0x00, 0xd1, 0xdd, 0x14, 0x55, 0x3c, 0xa9, 0x40, 0xee, 0xc4, 0x0a, 0x5c, 0x99, 0x78, - 0xdc, 0xd8, 0xbb, 0x29, 0x1a, 0x03, 0xe4, 0x5a, 0xdc, 0xda, 0xfa, 0xeb, 0x5b, 0x7b, 0x37, 0xa5, - 0x9a, 0x7b, 0x3b, 0x0f, 0xd9, 0x80, 0xf1, 0x70, 0x22, 0xea, 0xbf, 0xa5, 0xe1, 0x02, 0xb6, 0x4a, - 0xd7, 0x9a, 0x2e, 0x56, 0xd6, 0x1b, 0x47, 0x5c, 0x7b, 0x8f, 0x11, 0x4f, 0xbf, 0xe7, 0x88, 0x97, - 0xc1, 0xe0, 0xc2, 0x0a, 0x84, 0x5a, 0xef, 0x91, 0x40, 0x4a, 0xa0, 0x33, 0x77, 0xa4, 0x36, 0x9c, - 0x3c, 0x2e, 0x26, 0xdd, 0x78, 0xfb, 0xa4, 0x2f, 0x6f, 0xda, 0xec, 0x7f, 0xdf, 0xb4, 0xf5, 0x00, - 0xc8, 0x72, 0xe6, 0x54, 0x39, 0xcb, 0x60, 0xc8, 0xf6, 0x89, 0x7e, 0x02, 0x0b, 0x34, 0x12, 0x48, - 0x05, 0xf2, 0xaa, 0x52, 0xb2, 0x5f, 0x25, 0x31, 0x97, 0x17, 0xbe, 0xea, 0x6f, 0xf5, 0xb5, 0xfe, - 0x7b, 0x5a, 0x3d, 0xfa, 0xc8, 0x9a, 0x84, 0x8b, 0x7a, 0x95, 0xc1, 0xc0, 0x0e, 0x54, 0x0d, 0x1c, - 0x09, 0x6f, 0xae, 0x62, 0xfa, 0x3d, 0xaa, 0xa8, 0x7f, 0xa8, 0x2a, 0x66, 0xce, 0xa9, 0xa2, 0x71, - 0x4e, 0x15, 0xb3, 0xef, 0x56, 0xc5, 0xdc, 0x3b, 0x54, 0x31, 0x84, 0x8b, 0x89, 0x84, 0xaa, 0x32, - 0xae, 0x43, 0xf6, 0x3b, 0x44, 0x54, 0x1d, 0x95, 0xf4, 0xa1, 0x0a, 0x79, 0xf5, 0x5b, 0x28, 0xcc, - 0x3f, 0x3b, 0x48, 0x11, 0x72, 0x87, 0xdd, 0x2f, 0xba, 0x0f, 0x8e, 0xba, 0xa5, 0x14, 0x29, 0x80, - 0xf1, 0xf0, 0xb0, 0x43, 0xbf, 0x2e, 0x69, 0x24, 0x0f, 0x19, 0x7a, 0x78, 0xbf, 0x53, 0x4a, 0x4b, - 0x8d, 0xde, 0xde, 0x9d, 0xce, 0xce, 0x16, 0x2d, 0xe9, 0x52, 0xa3, 0x77, 0xf0, 0x80, 0x76, 0x4a, - 0x19, 0x89, 0xd3, 0xce, 0x4e, 0x67, 0xef, 0x51, 0xa7, 0x64, 0x48, 0xfc, 0x4e, 0x67, 0xfb, 0xf0, - 0x5e, 0x29, 0x7b, 0x75, 0x1b, 0x32, 0xf2, 0x77, 0x9b, 0xe4, 0x40, 0xa7, 0x5b, 0x47, 0x91, 0xd5, - 0x9d, 0x07, 0x87, 0xdd, 0x83, 0x92, 0x26, 0xb1, 0xde, 0xe1, 0x7e, 0x29, 0x2d, 0x0f, 0xfb, 0x7b, - 0xdd, 0x92, 0x8e, 0x87, 0xad, 0xaf, 0x22, 0x73, 0xa8, 0xd5, 0xa1, 0x25, 0xa3, 0xfd, 0x7d, 0x1a, - 0x0c, 0xf4, 0x91, 0x7c, 0x0a, 0x19, 0x5c, 0xcd, 0x17, 0xe3, 0x8c, 0x2e, 0x7d, 0x05, 0x56, 0xca, - 0x49, 0x50, 0xe5, 0xef, 0x33, 0xc8, 0x46, 0xfb, 0x8b, 0x5c, 0x4a, 0xee, 0xb3, 0xf8, 0xda, 0xfa, - 0x59, 0x38, 0xba, 0x78, 0x5d, 0x23, 0x3b, 0x00, 0x8b, 0xb9, 0x22, 0x1b, 0x89, 0x2a, 0x2e, 0x6f, - 0xa9, 0x4a, 0xe5, 0x3c, 0x4a, 0xbd, 0x7f, 0x17, 0x8a, 0x4b, 0x65, 0x25, 0x49, 0xd5, 0xc4, 0xf0, - 0x54, 0xae, 0x9c, 0xcb, 0x45, 0x76, 0xda, 0x5d, 0x58, 0xc3, 0xef, 0x6e, 0x39, 0x15, 0x51, 0x32, - 0x6e, 0x43, 0x91, 0xb2, 0xa9, 0x27, 0x18, 0xe2, 0x64, 0x1e, 0xfe, 0xf2, 0xe7, 0x79, 0xe5, 0xd2, - 0x19, 0x54, 0x7d, 0xc6, 0xa7, 0xb6, 0x3f, 0x7e, 0xf6, 0x77, 0x35, 0xf5, 0xec, 0x65, 0x55, 0x7b, - 0xfe, 0xb2, 0xaa, 0xfd, 0xf5, 0xb2, 0xaa, 0xfd, 0xfc, 0xaa, 0x9a, 0x7a, 0xfe, 0xaa, 0x9a, 0xfa, - 0xe3, 0x55, 0x35, 0xf5, 0x38, 0xa7, 0xfe, 0x93, 0x18, 0x64, 0xb1, 0x67, 0x6e, 0xfc, 0x13, 0x00, - 0x00, 0xff, 0xff, 0x73, 0x1f, 0x05, 0x4d, 0xb3, 0x0c, 0x00, 0x00, + // 1331 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0x4f, 0x6f, 0x13, 0x47, + 0x14, 0xf7, 0x7a, 0xbd, 0xfe, 0xf3, 0x9c, 0xb8, 0x66, 0x30, 0x61, 0x63, 0x24, 0xc7, 0x75, 0x55, + 0xc9, 0x42, 0xd4, 0xa6, 0x06, 0x21, 0xb5, 0xe2, 0x92, 0x04, 0x43, 0xa2, 0x12, 0x53, 0xc6, 0x09, + 0x69, 0xa9, 0x2a, 0x6b, 0x6d, 0x4f, 0xd6, 0x2b, 0xec, 0xdd, 0x65, 0x67, 0xb6, 0x89, 0xaf, 0xad, + 0x7a, 0xab, 0xaa, 0xaa, 0x1f, 0xa1, 0x9f, 0x86, 0x23, 0xc7, 0xaa, 0x07, 0xd4, 0xc2, 0xbd, 0x9f, + 0xa1, 0x9a, 0x3f, 0xbb, 0xf6, 0xa6, 0x21, 0x08, 0x91, 0x4b, 0x34, 0xef, 0xf7, 0x7b, 0xf3, 0xe6, + 0xfd, 0xcf, 0x1a, 0xae, 0x52, 0xe6, 0x05, 0xa4, 0x2d, 0xfe, 0xfa, 0xc3, 0x76, 0xe0, 0x8f, 0x5a, + 0x7e, 0xe0, 0x31, 0x0f, 0x65, 0xd9, 0xc4, 0x72, 0x3d, 0x5a, 0x5d, 0x4f, 0x2a, 0xb0, 0xb9, 0x4f, + 0xa8, 0x54, 0xa9, 0x56, 0x6c, 0xcf, 0xf6, 0xc4, 0xb1, 0xcd, 0x4f, 0x0a, 0xad, 0x27, 0x2f, 0xf8, + 0x81, 0x37, 0x3b, 0x75, 0x4f, 0x99, 0x9c, 0x5a, 0x43, 0x32, 0x3d, 0x4d, 0xd9, 0x9e, 0x67, 0x4f, + 0x49, 0x5b, 0x48, 0xc3, 0xf0, 0xa8, 0x6d, 0xb9, 0x73, 0x49, 0x35, 0x3e, 0x82, 0xd5, 0xc3, 0xc0, + 0x61, 0x04, 0x13, 0xea, 0x7b, 0x2e, 0x25, 0x8d, 0x9f, 0x34, 0x58, 0x51, 0xc8, 0xf3, 0x90, 0x50, + 0x86, 0x36, 0x01, 0x98, 0x33, 0x23, 0x94, 0x04, 0x0e, 0xa1, 0xa6, 0x56, 0xd7, 0x9b, 0xc5, 0xce, + 0x35, 0x7e, 0x7b, 0x46, 0xd8, 0x84, 0x84, 0x74, 0x30, 0xf2, 0xfc, 0x79, 0x6b, 0xdf, 0x99, 0x91, + 0xbe, 0x50, 0xd9, 0xca, 0xbc, 0x78, 0xb5, 0x91, 0xc2, 0x4b, 0x97, 0xd0, 0x1a, 0x64, 0x19, 0x71, + 0x2d, 0x97, 0x99, 0xe9, 0xba, 0xd6, 0x2c, 0x60, 0x25, 0x21, 0x13, 0x72, 0x01, 0xf1, 0xa7, 0xce, + 0xc8, 0x32, 0xf5, 0xba, 0xd6, 0xd4, 0x71, 0x24, 0x36, 0x56, 0xa1, 0xb8, 0xeb, 0x1e, 0x79, 0xca, + 0x87, 0xc6, 0xef, 0x69, 0x58, 0x91, 0xb2, 0xf4, 0x12, 0x8d, 0x20, 0x2b, 0x02, 0x8d, 0x1c, 0x5a, + 0x6d, 0xc9, 0xc4, 0xb6, 0x1e, 0x72, 0x74, 0xeb, 0x2e, 0x77, 0xe1, 0xaf, 0x57, 0x1b, 0xb7, 0x6d, + 0x87, 0x4d, 0xc2, 0x61, 0x6b, 0xe4, 0xcd, 0xda, 0x52, 0xe1, 0x33, 0xc7, 0x53, 0xa7, 0xb6, 0xff, + 0xcc, 0x6e, 0x27, 0x72, 0xd6, 0x7a, 0x2a, 0x6e, 0x63, 0x65, 0x1a, 0xad, 0x43, 0x7e, 0xe6, 0xb8, + 0x03, 0x1e, 0x88, 0x70, 0x5c, 0xc7, 0xb9, 0x99, 0xe3, 0xf2, 0x48, 0x05, 0x65, 0x9d, 0x48, 0x4a, + 0xb9, 0x3e, 0xb3, 0x4e, 0x04, 0xd5, 0x86, 0x82, 0xb0, 0xba, 0x3f, 0xf7, 0x89, 0x99, 0xa9, 0x6b, + 0xcd, 0x52, 0xe7, 0x52, 0xe4, 0x5d, 0x3f, 0x22, 0xf0, 0x42, 0x07, 0xdd, 0x01, 0x10, 0x0f, 0x0e, + 0x28, 0x61, 0xd4, 0x34, 0x44, 0x3c, 0xf1, 0x0d, 0xe9, 0x52, 0x9f, 0x30, 0x95, 0xd6, 0xc2, 0x54, + 0xc9, 0xb4, 0xf1, 0x8b, 0x01, 0xab, 0x32, 0xe5, 0x51, 0xa9, 0x96, 0x1d, 0xd6, 0xde, 0xee, 0x70, + 0x3a, 0xe9, 0xf0, 0x1d, 0x4e, 0xb1, 0xd1, 0x84, 0x04, 0xd4, 0xd4, 0xc5, 0xeb, 0x95, 0x44, 0x36, + 0xf7, 0x24, 0xa9, 0x1c, 0x88, 0x75, 0x51, 0x07, 0xae, 0x70, 0x93, 0x01, 0xa1, 0xde, 0x34, 0x64, + 0x8e, 0xe7, 0x0e, 0x8e, 0x1d, 0x77, 0xec, 0x1d, 0x8b, 0xa0, 0x75, 0x7c, 0x79, 0x66, 0x9d, 0xe0, + 0x98, 0x3b, 0x14, 0x14, 0xba, 0x01, 0x60, 0xd9, 0x76, 0x40, 0x6c, 0x8b, 0x11, 0x19, 0x6b, 0xa9, + 0xb3, 0x12, 0xbd, 0xb6, 0x69, 0xdb, 0x01, 0x5e, 0xe2, 0xd1, 0x97, 0xb0, 0xee, 0x5b, 0x01, 0x73, + 0xac, 0x29, 0x7f, 0x45, 0x54, 0x7e, 0x30, 0x76, 0xa8, 0x35, 0x9c, 0x92, 0xb1, 0x99, 0xad, 0x6b, + 0xcd, 0x3c, 0xbe, 0xaa, 0x14, 0xa2, 0xce, 0xb8, 0xa7, 0x68, 0xf4, 0xdd, 0x19, 0x77, 0x29, 0x0b, + 0x2c, 0x46, 0xec, 0xb9, 0x99, 0x13, 0x65, 0xd9, 0x88, 0x1e, 0xfe, 0x3a, 0x69, 0xa3, 0xaf, 0xd4, + 0xfe, 0x67, 0x3c, 0x22, 0xd0, 0x06, 0x14, 0xe9, 0x33, 0xc7, 0x1f, 0x8c, 0x26, 0xa1, 0xfb, 0x8c, + 0x9a, 0x79, 0xe1, 0x0a, 0x70, 0x68, 0x5b, 0x20, 0xe8, 0x3a, 0x18, 0x13, 0xc7, 0x65, 0xd4, 0x2c, + 0xd4, 0x35, 0x91, 0x50, 0x39, 0x81, 0xad, 0x68, 0x02, 0x5b, 0x9b, 0xee, 0x1c, 0x4b, 0x15, 0x84, + 0x20, 0x43, 0x19, 0xf1, 0x4d, 0x10, 0x69, 0x13, 0x67, 0x54, 0x01, 0x23, 0xb0, 0x5c, 0x9b, 0x98, + 0x45, 0x01, 0x4a, 0x01, 0xdd, 0x82, 0xe2, 0xf3, 0x90, 0x04, 0xf3, 0x81, 0xb4, 0xbd, 0x22, 0x6c, + 0xa3, 0x28, 0x8a, 0xc7, 0x9c, 0xda, 0xe1, 0x0c, 0x86, 0xe7, 0xf1, 0x19, 0xdd, 0x04, 0xa0, 0x13, + 0x2b, 0x18, 0x0f, 0x1c, 0xf7, 0xc8, 0x33, 0x57, 0xc5, 0x9d, 0x45, 0x43, 0x72, 0x46, 0x4c, 0x56, + 0x81, 0x46, 0x47, 0x74, 0x1b, 0xd6, 0x8e, 0x1d, 0x36, 0xf1, 0x42, 0x36, 0x50, 0xf3, 0x38, 0x50, + 0xc3, 0x56, 0xaa, 0xeb, 0xcd, 0x02, 0xae, 0x28, 0x16, 0x4b, 0x52, 0x34, 0x09, 0x6d, 0xfc, 0xa1, + 0x01, 0x2c, 0x5c, 0x10, 0x29, 0x62, 0xc4, 0x1f, 0xcc, 0x9c, 0xe9, 0xd4, 0xa1, 0xaa, 0x1d, 0x81, + 0x43, 0x7b, 0x02, 0x41, 0x75, 0xc8, 0x1c, 0x85, 0xee, 0x48, 0x74, 0x63, 0x71, 0xd1, 0x04, 0xf7, + 0x43, 0x77, 0x84, 0x05, 0x83, 0x6e, 0x40, 0xde, 0x0e, 0xbc, 0xd0, 0x77, 0x5c, 0x5b, 0xf4, 0x54, + 0xb1, 0x53, 0x8e, 0xb4, 0x1e, 0x28, 0x1c, 0xc7, 0x1a, 0xe8, 0x93, 0x28, 0x65, 0x86, 0x50, 0x8d, + 0x37, 0x02, 0xe6, 0xa0, 0xca, 0x60, 0xe3, 0x18, 0x0a, 0x71, 0xc8, 0xc2, 0x45, 0x95, 0x99, 0x31, + 0x39, 0x89, 0x5d, 0x94, 0xfc, 0x98, 0x9c, 0xa0, 0x8f, 0x61, 0x85, 0x79, 0xcc, 0x9a, 0x0e, 0x04, + 0x46, 0xd5, 0xe0, 0x14, 0x05, 0x26, 0xcc, 0x50, 0x54, 0x82, 0xf4, 0x70, 0x2e, 0x56, 0x40, 0x1e, + 0xa7, 0x87, 0x73, 0xbe, 0xea, 0x54, 0xae, 0x32, 0x22, 0x57, 0x4a, 0x6a, 0x54, 0x21, 0xc3, 0x23, + 0xe3, 0xc5, 0x76, 0x2d, 0x35, 0x9e, 0x05, 0x2c, 0xce, 0x8d, 0x0e, 0xe4, 0xa3, 0x78, 0x94, 0x3d, + 0xed, 0x0c, 0x7b, 0x7a, 0xc2, 0xde, 0x06, 0x18, 0x22, 0x30, 0xae, 0x90, 0x48, 0xb1, 0x92, 0x1a, + 0xbf, 0x6a, 0x50, 0x8a, 0xb6, 0x83, 0x5a, 0x9a, 0x4d, 0xc8, 0xc6, 0x5b, 0x9c, 0xa7, 0xa8, 0x14, + 0x77, 0x81, 0x40, 0x77, 0x52, 0x58, 0xf1, 0xa8, 0x0a, 0xb9, 0x63, 0x2b, 0x70, 0x79, 0xe2, 0xc5, + 0xc6, 0xde, 0x49, 0xe1, 0x08, 0x40, 0x37, 0xa2, 0xd6, 0xd6, 0xdf, 0xde, 0xda, 0x3b, 0x29, 0xd5, + 0xdc, 0x5b, 0x79, 0xc8, 0x06, 0x84, 0x86, 0x53, 0xd6, 0xf8, 0x37, 0x0d, 0x97, 0x44, 0xab, 0xf4, + 0xac, 0xd9, 0x62, 0x65, 0x9d, 0x3b, 0xe2, 0xda, 0x07, 0x8c, 0x78, 0xfa, 0x03, 0x47, 0xbc, 0x02, + 0x06, 0x65, 0x56, 0xc0, 0xd4, 0x7a, 0x97, 0x02, 0x2a, 0x83, 0x4e, 0xdc, 0xb1, 0xda, 0x70, 0xfc, + 0xb8, 0x98, 0x74, 0xe3, 0xdd, 0x93, 0xbe, 0xbc, 0x69, 0xb3, 0xef, 0xb1, 0x69, 0xdf, 0x3e, 0x90, + 0xb9, 0x73, 0x06, 0x32, 0x00, 0xb4, 0x9c, 0x6f, 0xd5, 0x04, 0x15, 0x30, 0x78, 0xd3, 0xc9, 0x7f, + 0x9c, 0x05, 0x2c, 0x05, 0x54, 0x85, 0xbc, 0xaa, 0x2f, 0xef, 0x72, 0x4e, 0xc4, 0xf2, 0x22, 0x42, + 0xfd, 0x9d, 0x11, 0x36, 0x7e, 0xd6, 0xd5, 0xa3, 0x4f, 0xac, 0x69, 0xb8, 0xa8, 0x72, 0x05, 0x0c, + 0xe1, 0xb0, 0x6a, 0x7b, 0x29, 0x9c, 0x5f, 0xfb, 0xf4, 0x07, 0xd4, 0x5e, 0xbf, 0xa8, 0xda, 0x67, + 0xce, 0xa8, 0xbd, 0x71, 0x46, 0xed, 0xb3, 0xef, 0x57, 0xfb, 0xdc, 0x85, 0xd4, 0x3e, 0x7f, 0x4e, + 0xed, 0x43, 0xb8, 0x9c, 0x28, 0x83, 0x2a, 0xfe, 0x1a, 0x64, 0x7f, 0x10, 0x88, 0xaa, 0xbe, 0x92, + 0x2e, 0xaa, 0xfc, 0xd7, 0xbf, 0x87, 0x42, 0xfc, 0x89, 0x83, 0x8a, 0x90, 0x3b, 0xe8, 0x7d, 0xd5, + 0x7b, 0x74, 0xd8, 0x2b, 0xa7, 0x50, 0x01, 0x8c, 0xc7, 0x07, 0x5d, 0xfc, 0x6d, 0x59, 0x43, 0x79, + 0xc8, 0xe0, 0x83, 0x87, 0xdd, 0x72, 0x9a, 0x6b, 0xf4, 0x77, 0xef, 0x75, 0xb7, 0x37, 0x71, 0x59, + 0xe7, 0x1a, 0xfd, 0xfd, 0x47, 0xb8, 0x5b, 0xce, 0x70, 0x1c, 0x77, 0xb7, 0xbb, 0xbb, 0x4f, 0xba, + 0x65, 0x83, 0xe3, 0xf7, 0xba, 0x5b, 0x07, 0x0f, 0xca, 0xd9, 0xeb, 0x5b, 0x90, 0xe1, 0xdf, 0x08, + 0x28, 0x07, 0x3a, 0xde, 0x3c, 0x94, 0x56, 0xb7, 0x1f, 0x1d, 0xf4, 0xf6, 0xcb, 0x1a, 0xc7, 0xfa, + 0x07, 0x7b, 0xe5, 0x34, 0x3f, 0xec, 0xed, 0xf6, 0xca, 0xba, 0x38, 0x6c, 0x7e, 0x23, 0xcd, 0x09, + 0xad, 0x2e, 0x2e, 0x1b, 0x9d, 0x1f, 0xd3, 0x60, 0x08, 0x1f, 0xd1, 0xe7, 0x90, 0x11, 0xff, 0x06, + 0x2e, 0x47, 0x75, 0x58, 0xfa, 0xe2, 0xac, 0x56, 0x92, 0xa0, 0xca, 0xdf, 0x17, 0x90, 0x95, 0xbb, + 0x12, 0x5d, 0x49, 0xee, 0xce, 0xe8, 0xda, 0xda, 0x69, 0x58, 0x5e, 0xbc, 0xa9, 0xa1, 0x6d, 0x80, + 0xc5, 0x34, 0xa2, 0xf5, 0x44, 0xed, 0x97, 0x37, 0x62, 0xb5, 0x7a, 0x16, 0xa5, 0xde, 0xbf, 0x0f, + 0xc5, 0xa5, 0xb2, 0xa2, 0xa4, 0x6a, 0x62, 0xe4, 0xaa, 0xd7, 0xce, 0xe4, 0xa4, 0x9d, 0x4e, 0x0f, + 0x4a, 0xe2, 0x1b, 0x9f, 0xcf, 0x92, 0x4c, 0xc6, 0x5d, 0x28, 0x62, 0x32, 0xf3, 0x18, 0x11, 0x38, + 0x8a, 0xc3, 0x5f, 0xfe, 0x29, 0x50, 0xbd, 0x72, 0x0a, 0x55, 0x3f, 0x19, 0x52, 0x5b, 0x9f, 0xbe, + 0xf8, 0xa7, 0x96, 0x7a, 0xf1, 0xba, 0xa6, 0xbd, 0x7c, 0x5d, 0xd3, 0xfe, 0x7e, 0x5d, 0xd3, 0x7e, + 0x7b, 0x53, 0x4b, 0xbd, 0x7c, 0x53, 0x4b, 0xfd, 0xf9, 0xa6, 0x96, 0x7a, 0x9a, 0x53, 0xbf, 0x5a, + 0x86, 0x59, 0xd1, 0x33, 0xb7, 0xfe, 0x0b, 0x00, 0x00, 0xff, 0xff, 0xa0, 0x14, 0xa2, 0x0f, 0x1f, + 0x0d, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1885,6 +1890,15 @@ func (m *LabelNamesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.WithoutReplicaLabels) > 0 { + for iNdEx := len(m.WithoutReplicaLabels) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.WithoutReplicaLabels[iNdEx]) + copy(dAtA[i:], m.WithoutReplicaLabels[iNdEx]) + i = encodeVarintRpc(dAtA, i, uint64(len(m.WithoutReplicaLabels[iNdEx]))) + i-- + dAtA[i] = 0x3a + } + } if len(m.Matchers) > 0 { for iNdEx := len(m.Matchers) - 1; iNdEx >= 0; iNdEx-- { { @@ -2012,6 +2026,15 @@ func (m *LabelValuesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.WithoutReplicaLabels) > 0 { + for iNdEx := len(m.WithoutReplicaLabels) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.WithoutReplicaLabels[iNdEx]) + copy(dAtA[i:], m.WithoutReplicaLabels[iNdEx]) + i = encodeVarintRpc(dAtA, i, uint64(len(m.WithoutReplicaLabels[iNdEx]))) + i-- + dAtA[i] = 0x42 + } + } if len(m.Matchers) > 0 { for iNdEx := len(m.Matchers) - 1; iNdEx >= 0; iNdEx-- { { @@ -2436,6 +2459,12 @@ func (m *LabelNamesRequest) Size() (n int) { n += 1 + l + sovRpc(uint64(l)) } } + if len(m.WithoutReplicaLabels) > 0 { + for _, s := range m.WithoutReplicaLabels { + l = len(s) + n += 1 + l + sovRpc(uint64(l)) + } + } return n } @@ -2496,6 +2525,12 @@ func (m *LabelValuesRequest) Size() (n int) { n += 1 + l + sovRpc(uint64(l)) } } + if len(m.WithoutReplicaLabels) > 0 { + for _, s := range m.WithoutReplicaLabels { + l = len(s) + n += 1 + l + sovRpc(uint64(l)) + } + } return n } @@ -4285,6 +4320,38 @@ func (m *LabelNamesRequest) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WithoutReplicaLabels", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRpc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WithoutReplicaLabels = append(m.WithoutReplicaLabels, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRpc(dAtA[iNdEx:]) @@ -4664,6 +4731,38 @@ func (m *LabelValuesRequest) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WithoutReplicaLabels", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRpc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRpc + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRpc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WithoutReplicaLabels = append(m.WithoutReplicaLabels, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRpc(dAtA[iNdEx:]) diff --git a/pkg/store/storepb/rpc.proto b/pkg/store/storepb/rpc.proto index 9e5ebaa693..2a9e9e3eaf 100644 --- a/pkg/store/storepb/rpc.proto +++ b/pkg/store/storepb/rpc.proto @@ -232,6 +232,9 @@ message LabelNamesRequest { google.protobuf.Any hints = 5; repeated LabelMatcher matchers = 6 [(gogoproto.nullable) = false]; + + // same as in series request. + repeated string without_replica_labels = 7; } message LabelNamesResponse { @@ -262,6 +265,9 @@ message LabelValuesRequest { google.protobuf.Any hints = 6; repeated LabelMatcher matchers = 7 [(gogoproto.nullable) = false]; + + // same as in series request. + repeated string without_replica_labels = 8; } message LabelValuesResponse { diff --git a/pkg/store/tsdb.go b/pkg/store/tsdb.go index 68ad31547a..6985c716fa 100644 --- a/pkg/store/tsdb.go +++ b/pkg/store/tsdb.go @@ -307,10 +307,16 @@ func (s *TSDBStore) LabelNames(ctx context.Context, r *storepb.LabelNamesRequest if err != nil { return nil, status.Error(codes.Internal, err.Error()) } + extLsetToRemove := map[string]struct{}{} + for _, lbl := range r.WithoutReplicaLabels { + extLsetToRemove[lbl] = struct{}{} + } if len(res) > 0 { s.getExtLset().Range(func(l labels.Label) { - res = append(res, l.Name) + if _, ok := extLsetToRemove[l.Name]; !ok { + res = append(res, l.Name) + } }) sort.Strings(res) } @@ -335,6 +341,12 @@ func (s *TSDBStore) LabelValues(ctx context.Context, r *storepb.LabelValuesReque return nil, status.Error(codes.InvalidArgument, "label name parameter cannot be empty") } + for i := range r.WithoutReplicaLabels { + if r.Label == r.WithoutReplicaLabels[i] { + return &storepb.LabelValuesResponse{}, nil + } + } + match, matchers, err := matchesExternalLabels(r.Matchers, s.getExtLset()) if err != nil { return nil, status.Error(codes.InvalidArgument, err.Error())