diff --git a/.github/workflows/ci-e2e-grpc.yml b/.github/workflows/ci-e2e-grpc.yml index bc2af82f7f1..7e6bbd05832 100644 --- a/.github/workflows/ci-e2e-grpc.yml +++ b/.github/workflows/ci-e2e-grpc.yml @@ -38,10 +38,10 @@ jobs: run: | case ${{ matrix.version }} in v1) - SPAN_STORAGE_TYPE=memory make grpc-storage-integration-test + SAMPLING_STORAGE_TYPE=memory SPAN_STORAGE_TYPE=memory make grpc-storage-integration-test ;; v2) - STORAGE=grpc SPAN_STORAGE_TYPE=memory make jaeger-v2-storage-integration-test + SAMPLING_STORAGE_TYPE=memory STORAGE=grpc SPAN_STORAGE_TYPE=memory make jaeger-v2-storage-integration-test ;; esac diff --git a/cmd/remote-storage/app/server.go b/cmd/remote-storage/app/server.go index 546d5c0b16c..af19ec282e6 100644 --- a/cmd/remote-storage/app/server.go +++ b/cmd/remote-storage/app/server.go @@ -22,9 +22,14 @@ import ( "github.com/jaegertracing/jaeger/plugin/storage/grpc/shared" "github.com/jaegertracing/jaeger/storage" "github.com/jaegertracing/jaeger/storage/dependencystore" + "github.com/jaegertracing/jaeger/storage/samplingstore" "github.com/jaegertracing/jaeger/storage/spanstore" ) +const ( + DEFAULT_MAX_BUCKET_SIZE = 1 +) + // Server runs a gRPC server type Server struct { opts *Options @@ -36,8 +41,8 @@ type Server struct { } // NewServer creates and initializes Server. -func NewServer(options *Options, storageFactory storage.BaseFactory, tm *tenancy.Manager, telset telemetry.Settings) (*Server, error) { - handler, err := createGRPCHandler(storageFactory, telset.Logger) +func NewServer(options *Options, storageFactory storage.BaseFactory, tm *tenancy.Manager, telset telemetry.Settings, samplingStoreFactory storage.SamplingStoreFactory) (*Server, error) { + handler, err := createGRPCHandler(storageFactory, samplingStoreFactory, telset.Logger) if err != nil { return nil, err } @@ -54,7 +59,7 @@ func NewServer(options *Options, storageFactory storage.BaseFactory, tm *tenancy }, nil } -func createGRPCHandler(f storage.BaseFactory, logger *zap.Logger) (*shared.GRPCHandler, error) { +func createGRPCHandler(f storage.BaseFactory, samplingStoreFactory storage.SamplingStoreFactory, logger *zap.Logger) (*shared.GRPCHandler, error) { reader, err := f.CreateSpanReader() if err != nil { return nil, err @@ -67,12 +72,18 @@ func createGRPCHandler(f storage.BaseFactory, logger *zap.Logger) (*shared.GRPCH if err != nil { return nil, err } + // TODO: Update this to use bucket size from config + samplingStore, err := samplingStoreFactory.CreateSamplingStore(DEFAULT_MAX_BUCKET_SIZE) + if err != nil { + return nil, err + } impl := &shared.GRPCHandlerStorageImpl{ SpanReader: func() spanstore.Reader { return reader }, SpanWriter: func() spanstore.Writer { return writer }, DependencyReader: func() dependencystore.Reader { return depReader }, StreamingSpanWriter: func() spanstore.Writer { return nil }, + SamplingStore: func() samplingstore.Store { return samplingStore }, } // borrow code from Query service for archive storage diff --git a/cmd/remote-storage/app/server_test.go b/cmd/remote-storage/app/server_test.go index c9a78d31896..77cc400914e 100644 --- a/cmd/remote-storage/app/server_test.go +++ b/cmd/remote-storage/app/server_test.go @@ -41,12 +41,14 @@ func TestNewServer_CreateStorageErrors(t *testing.T) { factory.On("CreateSpanWriter").Return(nil, nil) factory.On("CreateDependencyReader").Return(nil, errors.New("no deps")).Once() factory.On("CreateDependencyReader").Return(nil, nil) + samplingStoreFactoryMocks := factoryMocks.NewSamplingStoreFactory(t) f := func() (*Server, error) { return NewServer( &Options{GRPCHostPort: ":0"}, factory, tenancy.NewManager(&tenancy.Options{}), telemetry.NoopSettings(), + samplingStoreFactoryMocks, ) } _, err := f() @@ -113,18 +115,21 @@ func TestNewServer_TLSConfigError(t *testing.T) { ReportStatus: telemetry.HCAdapter(healthcheck.New()), } storageMocks := newStorageMocks() + samplingStoreFactoryMocks := factoryMocks.NewSamplingStoreFactory(t) + _, err := NewServer( &Options{GRPCHostPort: ":8081", TLSGRPC: tlsCfg}, storageMocks.factory, tenancy.NewManager(&tenancy.Options{}), telset, + samplingStoreFactoryMocks, ) assert.ErrorContains(t, err, "invalid TLS config") } func TestCreateGRPCHandler(t *testing.T) { storageMocks := newStorageMocks() - h, err := createGRPCHandler(storageMocks.factory, zap.NewNop()) + h, err := createGRPCHandler(storageMocks.factory, nil, zap.NewNop()) require.NoError(t, err) storageMocks.writer.On("WriteSpan", mock.Anything, mock.Anything).Return(errors.New("writer error")) @@ -320,11 +325,15 @@ func TestServerGRPCTLS(t *testing.T) { Logger: flagsSvc.Logger, ReportStatus: telemetry.HCAdapter(flagsSvc.HC()), } + + samplingStoreFactoryMocks := factoryMocks.NewSamplingStoreFactory(t) + server, err := NewServer( serverOptions, storageMocks.factory, tm, telset, + samplingStoreFactoryMocks, ) require.NoError(t, err) require.NoError(t, server.Start()) @@ -369,11 +378,15 @@ func TestServerHandlesPortZero(t *testing.T) { Logger: flagsSvc.Logger, ReportStatus: telemetry.HCAdapter(flagsSvc.HC()), } + + samplingStoreFactoryMocks := factoryMocks.NewSamplingStoreFactory(t) + server, err := NewServer( &Options{GRPCHostPort: ":0"}, storageMocks.factory, tenancy.NewManager(&tenancy.Options{}), telset, + samplingStoreFactoryMocks, ) require.NoError(t, err) diff --git a/cmd/remote-storage/main.go b/cmd/remote-storage/main.go index 8f1ed50e9a7..d52b7df7270 100644 --- a/cmd/remote-storage/main.go +++ b/cmd/remote-storage/main.go @@ -74,10 +74,15 @@ func main() { logger.Fatal("Failed to init storage factory", zap.Error(err)) } + samplingStoreFactory, err := storageFactory.CreateSamplingStoreFactory() + if err != nil { + logger.Fatal("Failed to init sampling storage factory", zap.Error(err)) + } + tm := tenancy.NewManager(&opts.Tenancy) telset := baseTelset // copy telset.Metrics = metricsFactory - server, err := app.NewServer(opts, storageFactory, tm, telset) + server, err := app.NewServer(opts, storageFactory, tm, telset, samplingStoreFactory) if err != nil { logger.Fatal("Failed to create server", zap.Error(err)) } diff --git a/idl b/idl index de97430b579..a97152c66d8 160000 --- a/idl +++ b/idl @@ -1 +1 @@ -Subproject commit de97430b579cac669422048a0becc5db981b05ad +Subproject commit a97152c66d8f1562fcdcbbb85600d5f12c8aab9e diff --git a/jaeger-ui b/jaeger-ui index a0458053c53..6dbddd02cc4 160000 --- a/jaeger-ui +++ b/jaeger-ui @@ -1 +1 @@ -Subproject commit a0458053c53bb18ba36a42867c06b0803d8fafaf +Subproject commit 6dbddd02cc4ead13d3ab412aad90d5caa0a8907a diff --git a/plugin/storage/grpc/factory.go b/plugin/storage/grpc/factory.go index 28edfa6f2ae..ccaa35b3542 100644 --- a/plugin/storage/grpc/factory.go +++ b/plugin/storage/grpc/factory.go @@ -30,6 +30,7 @@ import ( "github.com/jaegertracing/jaeger/plugin/storage/grpc/shared" "github.com/jaegertracing/jaeger/storage" "github.com/jaegertracing/jaeger/storage/dependencystore" + "github.com/jaegertracing/jaeger/storage/samplingstore" "github.com/jaegertracing/jaeger/storage/spanstore" "github.com/jaegertracing/jaeger/storage/spanstore/spanstoremetrics" ) @@ -161,6 +162,7 @@ func (f *Factory) newRemoteStorage( Store: grpcClient, ArchiveStore: grpcClient, StreamingSpanWriter: grpcClient, + SamplingStore: grpcClient, }, Capabilities: grpcClient, }, nil @@ -230,6 +232,10 @@ func (f *Factory) CreateArchiveSpanWriter() (spanstore.Writer, error) { return f.services.ArchiveStore.ArchiveSpanWriter(), nil } +func (f *Factory) CreateSamplingStore() (samplingstore.Store, error) { + return f.services.SamplingStore.SamplingStore(), nil +} + // Close closes the resources held by the factory func (f *Factory) Close() error { var errs []error diff --git a/plugin/storage/grpc/proto/storage.proto b/plugin/storage/grpc/proto/storage.proto index 7491b665043..eea4139f836 100644 --- a/plugin/storage/grpc/proto/storage.proto +++ b/plugin/storage/grpc/proto/storage.proto @@ -148,6 +148,63 @@ message FindTraceIDsResponse { ]; } +message Throughput { + string Service = 1; + string Operation = 2; + int64 Count = 3; + repeated double Probabilities = 4; +} + +message InsertThroughputRequest { + repeated Throughput throughput = 1; +} + +message InsertThroughputResponse { +} + +message StringFloatMap { + map stringFloatMap = 1; +} + +message ServiceOperationProbabilities { + map serviceOperationProbabilities = 1; +} + +message ServiceOperationQPS { + map serviceOperationQPS = 1; +} + +message InsertProbabilitiesAndQPSRequest { + string hostname = 1; + ServiceOperationProbabilities probabilities = 2; + ServiceOperationQPS qps = 3; +} + +message InsertProbabilitiesAndQPSResponse { +} + +message GetThroughputRequest { + google.protobuf.Timestamp start_time = 1[ + (gogoproto.stdtime) = true, + (gogoproto.nullable) = false + ]; + google.protobuf.Timestamp end_time = 2 [ + (gogoproto.stdtime) = true, + (gogoproto.nullable) = false + ]; +} + +message GetThroughputResponse { + repeated Throughput throughput = 1; +} + +message GetLatestProbabilitiesRequest { +} + +message GetLatestProbabilitiesResponse { + ServiceOperationProbabilities serviceOperationProbabilities = 1; +} + service SpanWriterPlugin { // spanstore/Writer rpc WriteSpan(WriteSpanRequest) returns (WriteSpanResponse); @@ -182,6 +239,16 @@ service DependenciesReaderPlugin { rpc GetDependencies(GetDependenciesRequest) returns (GetDependenciesResponse); } +service SamplingStorePlugin{ + rpc InsertThroughput(InsertThroughputRequest) returns (InsertThroughputResponse); + + rpc InsertProbabilitiesAndQPS(InsertProbabilitiesAndQPSRequest) returns (InsertProbabilitiesAndQPSResponse); + + rpc GetThroughput(GetThroughputRequest) returns (GetThroughputResponse); + + rpc GetLatestProbabilities(GetLatestProbabilitiesRequest) returns (GetLatestProbabilitiesResponse); +} + // empty; extensible in the future message CapabilitiesRequest { diff --git a/plugin/storage/grpc/shared/grpc_client.go b/plugin/storage/grpc/shared/grpc_client.go index abe296b70e3..e66c2391607 100644 --- a/plugin/storage/grpc/shared/grpc_client.go +++ b/plugin/storage/grpc/shared/grpc_client.go @@ -14,10 +14,12 @@ import ( "google.golang.org/grpc/codes" "google.golang.org/grpc/status" + samplingStoreModel "github.com/jaegertracing/jaeger/cmd/collector/app/sampling/model" "github.com/jaegertracing/jaeger/model" _ "github.com/jaegertracing/jaeger/pkg/gogocodec" // force gogo codec registration "github.com/jaegertracing/jaeger/proto-gen/storage_v1" "github.com/jaegertracing/jaeger/storage/dependencystore" + "github.com/jaegertracing/jaeger/storage/samplingstore" "github.com/jaegertracing/jaeger/storage/spanstore" ) @@ -39,6 +41,7 @@ type GRPCClient struct { capabilitiesClient storage_v1.PluginCapabilitiesClient depsReaderClient storage_v1.DependenciesReaderPluginClient streamWriterClient storage_v1.StreamingSpanWriterPluginClient + samplingStoreClient storage_v1.SamplingStorePluginClient } func NewGRPCClient(tracedConn *grpc.ClientConn, untracedConn *grpc.ClientConn) *GRPCClient { @@ -50,6 +53,7 @@ func NewGRPCClient(tracedConn *grpc.ClientConn, untracedConn *grpc.ClientConn) * capabilitiesClient: storage_v1.NewPluginCapabilitiesClient(tracedConn), depsReaderClient: storage_v1.NewDependenciesReaderPluginClient(tracedConn), streamWriterClient: storage_v1.NewStreamingSpanWriterPluginClient(untracedConn), + samplingStoreClient: storage_v1.NewSamplingStorePluginClient(untracedConn), } } @@ -68,6 +72,10 @@ func (c *GRPCClient) SpanWriter() spanstore.Writer { return c } +func (c *GRPCClient) SamplingStore() samplingstore.Store { + return c +} + func (c *GRPCClient) StreamingSpanWriter() spanstore.Writer { return newStreamingSpanWriter(c.streamWriterClient) } @@ -266,3 +274,62 @@ func readTrace(stream storage_v1.SpanReaderPlugin_GetTraceClient) (*model.Trace, return &trace, nil } + +func (c *GRPCClient) InsertThroughput(throughputs []*samplingStoreModel.Throughput) error { + ctx := context.Background() + storageV1Throughput, err := samplingStoreThroughputsToStorageV1Throughputs(throughputs) + if err != nil { + return err + } + + _, err = c.samplingStoreClient.InsertThroughput(ctx, &storage_v1.InsertThroughputRequest{ + Throughput: storageV1Throughput, + }) + if err != nil { + return fmt.Errorf("plugin error: %w", err) + } + + return nil +} + +func (c *GRPCClient) InsertProbabilitiesAndQPS(hostname string, probabilities samplingStoreModel.ServiceOperationProbabilities, qps samplingStoreModel.ServiceOperationQPS) error { + ctx := context.Background() + + _, err := c.samplingStoreClient.InsertProbabilitiesAndQPS(ctx, &storage_v1.InsertProbabilitiesAndQPSRequest{ + Hostname: hostname, + Probabilities: &storage_v1.ServiceOperationProbabilities{ + ServiceOperationProbabilities: sSFloatMapToStorageV1SSFloatMap(probabilities), + }, + Qps: &storage_v1.ServiceOperationQPS{ + ServiceOperationQPS: sSFloatMapToStorageV1SSFloatMap(qps), + }, + }) + if err != nil { + return fmt.Errorf("plugin error: %w", err) + } + + return nil +} + +func (c *GRPCClient) GetThroughput(start, end time.Time) ([]*samplingStoreModel.Throughput, error) { + ctx := context.Background() + resp, err := c.samplingStoreClient.GetThroughput(ctx, &storage_v1.GetThroughputRequest{ + StartTime: start, + EndTime: end, + }) + if err != nil { + return nil, fmt.Errorf("plugin error: %w", err) + } + + return storageV1ThroughputsToSamplingStoreThroughputs(resp.Throughput), nil +} + +func (c *GRPCClient) GetLatestProbabilities() (samplingStoreModel.ServiceOperationProbabilities, error) { + ctx := context.Background() + resp, err := c.samplingStoreClient.GetLatestProbabilities(ctx, &storage_v1.GetLatestProbabilitiesRequest{}) + if err != nil { + return nil, fmt.Errorf("plugin error: %w", err) + } + + return storageV1SSFloatMapToSSFloatMap(resp.ServiceOperationProbabilities.ServiceOperationProbabilities), nil +} diff --git a/plugin/storage/grpc/shared/grpc_client_test.go b/plugin/storage/grpc/shared/grpc_client_test.go index a8bb88fcf34..408c8edfed3 100644 --- a/plugin/storage/grpc/shared/grpc_client_test.go +++ b/plugin/storage/grpc/shared/grpc_client_test.go @@ -68,6 +68,7 @@ type grpcClientTest struct { capabilities *grpcMocks.PluginCapabilitiesClient depsReader *grpcMocks.DependenciesReaderPluginClient streamWriter *grpcMocks.StreamingSpanWriterPluginClient + samplingStore *grpcMocks.SamplingStorePluginClient } func withGRPCClient(fn func(r *grpcClientTest)) { @@ -78,6 +79,7 @@ func withGRPCClient(fn func(r *grpcClientTest)) { depReader := new(grpcMocks.DependenciesReaderPluginClient) streamWriter := new(grpcMocks.StreamingSpanWriterPluginClient) capabilities := new(grpcMocks.PluginCapabilitiesClient) + samplingStore := new(grpcMocks.SamplingStorePluginClient) r := &grpcClientTest{ client: &GRPCClient{ @@ -88,6 +90,7 @@ func withGRPCClient(fn func(r *grpcClientTest)) { capabilitiesClient: capabilities, depsReaderClient: depReader, streamWriterClient: streamWriter, + samplingStoreClient: samplingStore, }, spanReader: spanReader, spanWriter: spanWriter, @@ -96,6 +99,7 @@ func withGRPCClient(fn func(r *grpcClientTest)) { depsReader: depReader, capabilities: capabilities, streamWriter: streamWriter, + samplingStore: samplingStore, } fn(r) } @@ -112,6 +116,7 @@ func TestNewGRPCClient(t *testing.T) { assert.Implements(t, (*storage_v1.PluginCapabilitiesClient)(nil), client.capabilitiesClient) assert.Implements(t, (*storage_v1.DependenciesReaderPluginClient)(nil), client.depsReaderClient) assert.Implements(t, (*storage_v1.StreamingSpanWriterPluginClient)(nil), client.streamWriterClient) + assert.Implements(t, (*storage_v1.SamplingStorePluginClient)(nil), client.streamWriterClient) } func TestGRPCClientGetServices(t *testing.T) { diff --git a/plugin/storage/grpc/shared/grpc_handler.go b/plugin/storage/grpc/shared/grpc_handler.go index 564a625ebf0..91fac2c9341 100644 --- a/plugin/storage/grpc/shared/grpc_handler.go +++ b/plugin/storage/grpc/shared/grpc_handler.go @@ -19,6 +19,7 @@ import ( _ "github.com/jaegertracing/jaeger/pkg/gogocodec" // force gogo codec registration "github.com/jaegertracing/jaeger/proto-gen/storage_v1" "github.com/jaegertracing/jaeger/storage/dependencystore" + "github.com/jaegertracing/jaeger/storage/samplingstore" "github.com/jaegertracing/jaeger/storage/spanstore" ) @@ -42,6 +43,8 @@ type GRPCHandlerStorageImpl struct { ArchiveSpanWriter func() spanstore.Writer StreamingSpanWriter func() spanstore.Writer + + SamplingStore func() samplingstore.Store } // NewGRPCHandler creates a handler given individual storage implementations. @@ -83,6 +86,7 @@ func (s *GRPCHandler) Register(ss *grpc.Server, hs *health.Server) error { storage_v1.RegisterPluginCapabilitiesServer(ss, s) storage_v1.RegisterDependenciesReaderPluginServer(ss, s) storage_v1.RegisterStreamingSpanWriterPluginServer(ss, s) + storage_v1.RegisterSamplingStorePluginServer(ss, s) hs.SetServingStatus("jaeger.storage.v1.SpanReaderPlugin", grpc_health_v1.HealthCheckResponse_SERVING) hs.SetServingStatus("jaeger.storage.v1.SpanWriterPlugin", grpc_health_v1.HealthCheckResponse_SERVING) @@ -91,6 +95,7 @@ func (s *GRPCHandler) Register(ss *grpc.Server, hs *health.Server) error { hs.SetServingStatus("jaeger.storage.v1.PluginCapabilities", grpc_health_v1.HealthCheckResponse_SERVING) hs.SetServingStatus("jaeger.storage.v1.DependenciesReaderPlugin", grpc_health_v1.HealthCheckResponse_SERVING) hs.SetServingStatus("jaeger.storage.v1.StreamingSpanWriterPlugin", grpc_health_v1.HealthCheckResponse_SERVING) + hs.SetServingStatus("jaeger.storage.v1.SamplingStorePlugin", grpc_health_v1.HealthCheckResponse_SERVING) grpc_health_v1.RegisterHealthServer(ss, hs) return nil @@ -303,3 +308,46 @@ func (s *GRPCHandler) WriteArchiveSpan(ctx context.Context, r *storage_v1.WriteS } return &storage_v1.WriteSpanResponse{}, nil } + +func (s *GRPCHandler) InsertThroughput(_ context.Context, r *storage_v1.InsertThroughputRequest) (*storage_v1.InsertThroughputResponse, error) { + err := s.impl.SamplingStore().InsertThroughput(storageV1ThroughputsToSamplingStoreThroughputs(r.Throughput)) + if err != nil { + return nil, err + } + return &storage_v1.InsertThroughputResponse{}, nil +} + +func (s *GRPCHandler) InsertProbabilitiesAndQPS(_ context.Context, r *storage_v1.InsertProbabilitiesAndQPSRequest) (*storage_v1.InsertProbabilitiesAndQPSResponse, error) { + err := s.impl.SamplingStore().InsertProbabilitiesAndQPS(r.Hostname, storageV1SSFloatMapToSSFloatMap(r.Probabilities.ServiceOperationProbabilities), storageV1SSFloatMapToSSFloatMap(r.Qps.ServiceOperationQPS)) + if err != nil { + return nil, err + } + return &storage_v1.InsertProbabilitiesAndQPSResponse{}, nil +} + +func (s *GRPCHandler) GetThroughput(_ context.Context, r *storage_v1.GetThroughputRequest) (*storage_v1.GetThroughputResponse, error) { + throughput, err := s.impl.SamplingStore().GetThroughput(r.StartTime, r.EndTime) + if err != nil { + return nil, err + } + storageV1Throughput, err := samplingStoreThroughputsToStorageV1Throughputs(throughput) + if err != nil { + return nil, err + } + + return &storage_v1.GetThroughputResponse{ + Throughput: storageV1Throughput, + }, nil +} + +func (s *GRPCHandler) GetLatestProbabilities(context.Context, *storage_v1.GetLatestProbabilitiesRequest) (*storage_v1.GetLatestProbabilitiesResponse, error) { + probabilities, err := s.impl.SamplingStore().GetLatestProbabilities() + if err != nil { + return nil, err + } + return &storage_v1.GetLatestProbabilitiesResponse{ + ServiceOperationProbabilities: &storage_v1.ServiceOperationProbabilities{ + ServiceOperationProbabilities: sSFloatMapToStorageV1SSFloatMap(probabilities), + }, + }, nil +} diff --git a/plugin/storage/grpc/shared/interface.go b/plugin/storage/grpc/shared/interface.go index 9abc2f75dce..60d4011743b 100644 --- a/plugin/storage/grpc/shared/interface.go +++ b/plugin/storage/grpc/shared/interface.go @@ -5,6 +5,7 @@ package shared import ( "github.com/jaegertracing/jaeger/storage/dependencystore" + "github.com/jaegertracing/jaeger/storage/samplingstore" "github.com/jaegertracing/jaeger/storage/spanstore" ) @@ -26,6 +27,10 @@ type StreamingSpanWriterPlugin interface { StreamingSpanWriter() spanstore.Writer } +type SamplingStorePlugin interface { + SamplingStore() samplingstore.Store +} + // PluginCapabilities allow expose plugin its capabilities. type PluginCapabilities interface { Capabilities() (*Capabilities, error) @@ -43,4 +48,5 @@ type PluginServices struct { Store StoragePlugin ArchiveStore ArchiveStoragePlugin StreamingSpanWriter StreamingSpanWriterPlugin + SamplingStore SamplingStorePlugin } diff --git a/plugin/storage/grpc/shared/sampling_store.go b/plugin/storage/grpc/shared/sampling_store.go new file mode 100644 index 00000000000..3ed853c263b --- /dev/null +++ b/plugin/storage/grpc/shared/sampling_store.go @@ -0,0 +1,91 @@ +// Copyright (c) 2024 The Jaeger Authors. +// SPDX-License-Identifier: Apache-2.0 + +package shared + +import ( + "strconv" + + samplingStoreModel "github.com/jaegertracing/jaeger/cmd/collector/app/sampling/model" + "github.com/jaegertracing/jaeger/proto-gen/storage_v1" +) + +func stringSetTofloat64Array(asSet map[string]struct{}) ([]float64, error) { + asArray := []float64{} + for k := range asSet { + floatK, err := strconv.ParseFloat(k, 64) + if err != nil { + return nil, err + } + asArray = append(asArray, floatK) + } + return asArray, nil +} + +func samplingStoreThroughputsToStorageV1Throughputs(throughputs []*samplingStoreModel.Throughput) ([]*storage_v1.Throughput, error) { + storageV1Throughput := []*storage_v1.Throughput{} + for _, throughput := range throughputs { + probsAsArray, err := stringSetTofloat64Array(throughput.Probabilities) + if err != nil { + return nil, err + } + + storageV1Throughput = append(storageV1Throughput, &storage_v1.Throughput{ + Service: throughput.Service, + Operation: throughput.Operation, + Count: throughput.Count, + Probabilities: probsAsArray, + }) + } + + return storageV1Throughput, nil +} + +func float64ArrayToStringSet(asArray []float64) map[string]struct{} { + asSet := make(map[string]struct{}) + for _, prob := range asArray { + asSet[strconv.FormatFloat(prob, 'E', -1, 64)] = struct{}{} + } + return asSet +} + +func storageV1ThroughputsToSamplingStoreThroughputs(thoughputs []*storage_v1.Throughput) []*samplingStoreModel.Throughput { + resThroughput := []*samplingStoreModel.Throughput{} + + for _, throughput := range thoughputs { + resThroughput = append(resThroughput, &samplingStoreModel.Throughput{ + Service: throughput.Service, + Operation: throughput.Operation, + Count: throughput.Count, + Probabilities: float64ArrayToStringSet(throughput.Probabilities), + }) + } + + return resThroughput +} + +func stringFloatMapToV1StringFloatMap(in map[string]float64) *storage_v1.StringFloatMap { + return &storage_v1.StringFloatMap{ + StringFloatMap: in, + } +} + +func sSFloatMapToStorageV1SSFloatMap(in map[string]map[string]float64) map[string]*storage_v1.StringFloatMap { + res := make(map[string]*storage_v1.StringFloatMap) + for k, v := range in { + res[k] = stringFloatMapToV1StringFloatMap(v) + } + return res +} + +func storageV1StringFloatMapToStringFloatMap(in *storage_v1.StringFloatMap) map[string]float64 { + return in.StringFloatMap +} + +func storageV1SSFloatMapToSSFloatMap(in map[string]*storage_v1.StringFloatMap) map[string]map[string]float64 { + res := make(map[string]map[string]float64) + for k, v := range in { + res[k] = storageV1StringFloatMapToStringFloatMap(v) + } + return res +} diff --git a/plugin/storage/integration/grpc_test.go b/plugin/storage/integration/grpc_test.go index 77e273cf826..8e7e949d125 100644 --- a/plugin/storage/integration/grpc_test.go +++ b/plugin/storage/integration/grpc_test.go @@ -43,6 +43,8 @@ func (s *GRPCStorageIntegrationTestSuite) initialize(t *testing.T) { require.NoError(t, err) s.ArchiveSpanWriter, err = f.CreateArchiveSpanWriter() require.NoError(t, err) + s.SamplingStore, err = f.CreateSamplingStore() + require.NoError(t, err) // TODO DependencyWriter is not implemented in grpc store diff --git a/plugin/storage/integration/remote_memory_storage.go b/plugin/storage/integration/remote_memory_storage.go index 74f813fa2b9..a02c8ac8674 100644 --- a/plugin/storage/integration/remote_memory_storage.go +++ b/plugin/storage/integration/remote_memory_storage.go @@ -43,6 +43,9 @@ func StartNewRemoteMemoryStorage(t *testing.T) *RemoteMemoryStorage { storageFactory, err := storage.NewFactory(storage.FactoryConfigFromEnvAndCLI(os.Args, os.Stderr)) require.NoError(t, err) + samplingStoreFactory, err := storageFactory.CreateSamplingStoreFactory() + require.NoError(t, err) + v, _ := config.Viperize(storageFactory.AddFlags) storageFactory.InitFromViper(v, logger) require.NoError(t, storageFactory.Initialize(metrics.NullFactory, logger)) @@ -51,7 +54,7 @@ func StartNewRemoteMemoryStorage(t *testing.T) *RemoteMemoryStorage { telset := telemetry.NoopSettings() telset.Logger = logger telset.ReportStatus = telemetry.HCAdapter(healthcheck.New()) - server, err := app.NewServer(opts, storageFactory, tm, telset) + server, err := app.NewServer(opts, storageFactory, tm, telset, samplingStoreFactory) require.NoError(t, err) require.NoError(t, server.Start()) diff --git a/proto-gen/api_v2/query.pb.go b/proto-gen/api_v2/query.pb.go index f9bbee7313f..c4898c6c876 100644 --- a/proto-gen/api_v2/query.pb.go +++ b/proto-gen/api_v2/query.pb.go @@ -37,12 +37,12 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type GetTraceRequest struct { TraceID github_com_jaegertracing_jaeger_model.TraceID `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3,customtype=github.com/jaegertracing/jaeger/model.TraceID" json:"trace_id"` // Optional. The start time to search trace ID. - StartTime time.Time `protobuf:"bytes,2,opt,name=start_time,json=startTime,proto3,stdtime" json:"start_time"` + StartTime *time.Time `protobuf:"bytes,2,opt,name=start_time,json=startTime,proto3,stdtime" json:"start_time,omitempty"` // Optional. The end time to search trace ID. - EndTime time.Time `protobuf:"bytes,3,opt,name=end_time,json=endTime,proto3,stdtime" json:"end_time"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + EndTime *time.Time `protobuf:"bytes,3,opt,name=end_time,json=endTime,proto3,stdtime" json:"end_time,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *GetTraceRequest) Reset() { *m = GetTraceRequest{} } @@ -78,18 +78,18 @@ func (m *GetTraceRequest) XXX_DiscardUnknown() { var xxx_messageInfo_GetTraceRequest proto.InternalMessageInfo -func (m *GetTraceRequest) GetStartTime() time.Time { +func (m *GetTraceRequest) GetStartTime() *time.Time { if m != nil { return m.StartTime } - return time.Time{} + return nil } -func (m *GetTraceRequest) GetEndTime() time.Time { +func (m *GetTraceRequest) GetEndTime() *time.Time { if m != nil { return m.EndTime } - return time.Time{} + return nil } type SpansResponseChunk struct { @@ -142,12 +142,12 @@ func (m *SpansResponseChunk) GetSpans() []model.Span { type ArchiveTraceRequest struct { TraceID github_com_jaegertracing_jaeger_model.TraceID `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3,customtype=github.com/jaegertracing/jaeger/model.TraceID" json:"trace_id"` // Optional. The start time to search trace ID. - StartTime time.Time `protobuf:"bytes,2,opt,name=start_time,json=startTime,proto3,stdtime" json:"start_time"` + StartTime *time.Time `protobuf:"bytes,2,opt,name=start_time,json=startTime,proto3,stdtime" json:"start_time,omitempty"` // Optional. The end time to search trace ID. - EndTime time.Time `protobuf:"bytes,3,opt,name=end_time,json=endTime,proto3,stdtime" json:"end_time"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + EndTime *time.Time `protobuf:"bytes,3,opt,name=end_time,json=endTime,proto3,stdtime" json:"end_time,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *ArchiveTraceRequest) Reset() { *m = ArchiveTraceRequest{} } @@ -183,18 +183,18 @@ func (m *ArchiveTraceRequest) XXX_DiscardUnknown() { var xxx_messageInfo_ArchiveTraceRequest proto.InternalMessageInfo -func (m *ArchiveTraceRequest) GetStartTime() time.Time { +func (m *ArchiveTraceRequest) GetStartTime() *time.Time { if m != nil { return m.StartTime } - return time.Time{} + return nil } -func (m *ArchiveTraceRequest) GetEndTime() time.Time { +func (m *ArchiveTraceRequest) GetEndTime() *time.Time { if m != nil { return m.EndTime } - return time.Time{} + return nil } type ArchiveTraceResponse struct { @@ -771,68 +771,69 @@ func init() { func init() { proto.RegisterFile("query.proto", fileDescriptor_5c6ac9b241082464) } var fileDescriptor_5c6ac9b241082464 = []byte{ - // 971 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x56, 0x4f, 0x6f, 0x1b, 0x45, - 0x14, 0x67, 0x9d, 0x38, 0xb6, 0xdf, 0xda, 0x2d, 0x7d, 0x76, 0xda, 0x65, 0x0b, 0xb6, 0xb3, 0xa1, - 0x55, 0x84, 0x94, 0xdd, 0x62, 0x0e, 0x94, 0x0a, 0x09, 0x9a, 0xa6, 0xb5, 0x0a, 0xb4, 0xc0, 0x36, - 0x27, 0x38, 0x58, 0x13, 0xef, 0xb0, 0x5e, 0x1c, 0xcf, 0xba, 0xbb, 0xe3, 0x10, 0x0b, 0x71, 0xe1, - 0x13, 0x20, 0x71, 0xe1, 0xc4, 0x95, 0x13, 0xdf, 0xa3, 0x47, 0x24, 0x6e, 0x1c, 0x02, 0x8a, 0xf8, - 0x08, 0x1c, 0x38, 0xa2, 0xf9, 0xb3, 0x8e, 0xbd, 0x8e, 0x42, 0x1b, 0x8e, 0x9c, 0xbc, 0xf3, 0xe6, - 0xbd, 0xdf, 0xfb, 0xfb, 0x7b, 0x63, 0x30, 0x9f, 0x4e, 0x68, 0x32, 0x75, 0xc7, 0x49, 0xcc, 0x63, - 0xac, 0x7d, 0x49, 0x68, 0x48, 0x13, 0x97, 0x8c, 0xa3, 0xde, 0x61, 0xc7, 0x36, 0x47, 0x71, 0x40, - 0x0f, 0xd4, 0x9d, 0xdd, 0x08, 0xe3, 0x30, 0x96, 0x9f, 0x9e, 0xf8, 0xd2, 0xd2, 0x57, 0xc3, 0x38, - 0x0e, 0x0f, 0xa8, 0x47, 0xc6, 0x91, 0x47, 0x18, 0x8b, 0x39, 0xe1, 0x51, 0xcc, 0x52, 0x7d, 0xdb, - 0xd2, 0xb7, 0xf2, 0xb4, 0x3f, 0xf9, 0xc2, 0xe3, 0xd1, 0x88, 0xa6, 0x9c, 0x8c, 0xc6, 0x5a, 0xa1, - 0x99, 0x57, 0x08, 0x26, 0x89, 0x44, 0x50, 0xf7, 0xce, 0x5f, 0x06, 0x5c, 0xee, 0x52, 0xbe, 0x97, - 0x90, 0x3e, 0xf5, 0xe9, 0xd3, 0x09, 0x4d, 0x39, 0x7e, 0x0e, 0x65, 0x2e, 0xce, 0xbd, 0x28, 0xb0, - 0x8c, 0xb6, 0xb1, 0x55, 0xdd, 0x79, 0xff, 0xd9, 0x71, 0xeb, 0xa5, 0xdf, 0x8e, 0x5b, 0xdb, 0x61, - 0xc4, 0x07, 0x93, 0x7d, 0xb7, 0x1f, 0x8f, 0x3c, 0x95, 0x89, 0x50, 0x8c, 0x58, 0xa8, 0x4f, 0x9e, - 0xca, 0x47, 0xa2, 0x3d, 0xdc, 0x3d, 0x39, 0x6e, 0x95, 0xf4, 0xa7, 0x5f, 0x92, 0x88, 0x0f, 0x03, - 0xbc, 0x07, 0x90, 0x72, 0x92, 0xf0, 0x9e, 0x88, 0xd4, 0x2a, 0xb4, 0x8d, 0x2d, 0xb3, 0x63, 0xbb, - 0x2a, 0x4a, 0x37, 0x8b, 0xd2, 0xdd, 0xcb, 0xd2, 0xd8, 0x29, 0x0b, 0xd7, 0xdf, 0xfd, 0xde, 0x32, - 0xfc, 0x8a, 0xb4, 0x13, 0x37, 0xf8, 0x1e, 0x94, 0x29, 0x0b, 0x14, 0xc4, 0xca, 0x0b, 0x40, 0x94, - 0x28, 0x0b, 0x84, 0xdc, 0xb9, 0x0f, 0xf8, 0x64, 0x4c, 0x58, 0xea, 0xd3, 0x74, 0x1c, 0xb3, 0x94, - 0xde, 0x1b, 0x4c, 0xd8, 0x10, 0x3d, 0x28, 0xa6, 0x42, 0x6a, 0x19, 0xed, 0x95, 0x2d, 0xb3, 0x53, - 0x77, 0x17, 0xba, 0xe5, 0x0a, 0x8b, 0x9d, 0x55, 0x01, 0xe6, 0x2b, 0x3d, 0xe7, 0x6f, 0x03, 0xea, - 0x77, 0x93, 0xfe, 0x20, 0x3a, 0xa4, 0xff, 0xb7, 0x0a, 0x5e, 0x85, 0xc6, 0x62, 0xe6, 0xaa, 0x90, - 0xce, 0x4f, 0xab, 0xd0, 0x90, 0x92, 0x4f, 0xc5, 0xd8, 0x7f, 0x42, 0x12, 0x32, 0xa2, 0x9c, 0x26, - 0x29, 0x6e, 0x40, 0x35, 0xa5, 0xc9, 0x61, 0xd4, 0xa7, 0x3d, 0x46, 0x46, 0x54, 0xd6, 0xa5, 0xe2, - 0x9b, 0x5a, 0xf6, 0x98, 0x8c, 0x28, 0xde, 0x80, 0x4b, 0xf1, 0x98, 0xaa, 0xf9, 0x54, 0x4a, 0x05, - 0xa9, 0x54, 0x9b, 0x49, 0xa5, 0xda, 0x5d, 0x58, 0xe5, 0x24, 0x4c, 0xad, 0x15, 0xd9, 0xa5, 0xed, - 0x5c, 0x97, 0xce, 0x72, 0xee, 0xee, 0x91, 0x30, 0xbd, 0xcf, 0x78, 0x32, 0xf5, 0xa5, 0x29, 0x7e, - 0x00, 0x97, 0x4e, 0x6b, 0xd8, 0x1b, 0x45, 0xcc, 0x5a, 0x7d, 0x81, 0x22, 0x54, 0x67, 0x75, 0x7c, - 0x14, 0xb1, 0x3c, 0x16, 0x39, 0xb2, 0x8a, 0x17, 0xc3, 0x22, 0x47, 0xf8, 0x00, 0xaa, 0x19, 0x41, - 0x65, 0x54, 0x6b, 0x12, 0xe9, 0x95, 0x25, 0xa4, 0x5d, 0xad, 0xa4, 0x80, 0x7e, 0x10, 0x40, 0x66, - 0x66, 0x28, 0x62, 0x5a, 0xc0, 0x21, 0x47, 0x56, 0xe9, 0x22, 0x38, 0xe4, 0x48, 0x35, 0x8d, 0x24, - 0xfd, 0x41, 0x2f, 0xa0, 0x63, 0x3e, 0xb0, 0xca, 0x6d, 0x63, 0xab, 0x28, 0x9a, 0x26, 0x64, 0xbb, - 0x42, 0x64, 0xbf, 0x0d, 0x95, 0x59, 0x75, 0xf1, 0x65, 0x58, 0x19, 0xd2, 0xa9, 0xee, 0xad, 0xf8, - 0xc4, 0x06, 0x14, 0x0f, 0xc9, 0xc1, 0x24, 0x6b, 0xa5, 0x3a, 0xdc, 0x29, 0xdc, 0x36, 0x9c, 0xc7, - 0x70, 0xe5, 0x41, 0xc4, 0x02, 0xd9, 0xaf, 0x34, 0x63, 0xce, 0x3b, 0x50, 0x94, 0xfb, 0x52, 0x42, - 0x98, 0x9d, 0xcd, 0xe7, 0x68, 0xae, 0xaf, 0x2c, 0x9c, 0x06, 0x60, 0x97, 0xf2, 0x27, 0x6a, 0x9e, - 0x32, 0x40, 0xe7, 0x4d, 0xa8, 0x2f, 0x48, 0xd5, 0x98, 0xa2, 0x0d, 0x65, 0x3d, 0x79, 0x8a, 0xed, - 0x15, 0x7f, 0x76, 0x76, 0x1e, 0x41, 0xa3, 0x4b, 0xf9, 0xc7, 0xd9, 0xcc, 0xcd, 0x62, 0xb3, 0xa0, - 0xa4, 0x75, 0x74, 0x82, 0xd9, 0x11, 0xaf, 0x43, 0x45, 0x2c, 0x84, 0xde, 0x30, 0x62, 0x81, 0x4e, - 0xb4, 0x2c, 0x04, 0x1f, 0x46, 0x2c, 0x70, 0xde, 0x85, 0xca, 0x0c, 0x0b, 0x11, 0x56, 0xe7, 0xa6, - 0x5f, 0x7e, 0x9f, 0x6f, 0x3d, 0x85, 0xf5, 0x5c, 0x30, 0x3a, 0x83, 0x9b, 0x73, 0x64, 0x11, 0xb4, - 0xc8, 0xf2, 0xc8, 0x49, 0xf1, 0x36, 0xc0, 0x4c, 0x92, 0x5a, 0x05, 0xc9, 0x19, 0x2b, 0x57, 0xd6, - 0x19, 0xbc, 0x3f, 0xa7, 0xeb, 0xfc, 0x68, 0xc0, 0xd5, 0x2e, 0xe5, 0xbb, 0x74, 0x4c, 0x59, 0x40, - 0x59, 0x3f, 0x3a, 0x6d, 0xd3, 0xe2, 0x0e, 0x32, 0xfe, 0xfb, 0x0e, 0x2a, 0x5c, 0x64, 0x07, 0xed, - 0xc3, 0xb5, 0xa5, 0xf8, 0x74, 0x75, 0xba, 0x50, 0x0d, 0xe6, 0xe4, 0x7a, 0xa3, 0xbf, 0x96, 0xcb, - 0x7b, 0x66, 0x3a, 0xfd, 0x28, 0x62, 0x43, 0xbd, 0xdb, 0x17, 0x0c, 0x3b, 0x3f, 0x17, 0xa1, 0x2a, - 0x07, 0x4e, 0x8f, 0x10, 0x0e, 0xa1, 0x9c, 0x3d, 0x98, 0xd8, 0xcc, 0xe1, 0xe5, 0x5e, 0x52, 0x7b, - 0xe3, 0x8c, 0x17, 0x64, 0xf1, 0xcd, 0x71, 0xec, 0x6f, 0x7f, 0xfd, 0xf3, 0xfb, 0x42, 0x03, 0xd1, - 0x93, 0xfb, 0x3d, 0xf5, 0xbe, 0xce, 0x5e, 0x8e, 0x6f, 0x6e, 0x19, 0xc8, 0xa1, 0x3a, 0xbf, 0x65, - 0xd1, 0xc9, 0x01, 0x9e, 0xf1, 0xf8, 0xd8, 0x9b, 0xe7, 0xea, 0xe8, 0x35, 0x7d, 0x5d, 0xba, 0x5d, - 0x77, 0xea, 0x1e, 0x51, 0xd7, 0x73, 0x7e, 0x31, 0x04, 0x38, 0x65, 0x26, 0xb6, 0x73, 0x78, 0x4b, - 0xa4, 0x7d, 0x9e, 0x34, 0x51, 0xfa, 0xab, 0x3a, 0x25, 0x4f, 0xed, 0x8e, 0x3b, 0xc6, 0x1b, 0xb7, - 0x0c, 0x0c, 0xc1, 0x9c, 0x23, 0x27, 0x6e, 0x2c, 0x97, 0x33, 0x47, 0x67, 0xdb, 0x39, 0x4f, 0x45, - 0xe7, 0x76, 0x45, 0xfa, 0x32, 0xb1, 0xe2, 0x65, 0x94, 0xc6, 0x18, 0x6a, 0x0b, 0x2c, 0xc2, 0xcd, - 0x65, 0x9c, 0x25, 0xc2, 0xdb, 0xaf, 0x9f, 0xaf, 0xa4, 0xdd, 0xd5, 0xa5, 0xbb, 0x1a, 0x9a, 0xde, - 0x29, 0x77, 0xf0, 0x2b, 0xf9, 0xb7, 0x6a, 0x7e, 0x34, 0xf1, 0xc6, 0x32, 0xda, 0x19, 0xd4, 0xb2, - 0x6f, 0xfe, 0x9b, 0x9a, 0x76, 0xbb, 0x2e, 0xdd, 0x5e, 0xc6, 0x9a, 0x37, 0x3f, 0xaf, 0x3b, 0xdb, - 0xcf, 0x4e, 0x9a, 0xc6, 0x2f, 0x27, 0x4d, 0xe3, 0x8f, 0x93, 0xa6, 0x01, 0xd7, 0xa2, 0xd8, 0x5d, - 0xf8, 0x9b, 0xa1, 0x51, 0x3f, 0x5b, 0x53, 0xbf, 0xfb, 0x6b, 0x92, 0x69, 0x6f, 0xfd, 0x13, 0x00, - 0x00, 0xff, 0xff, 0x66, 0xd6, 0x53, 0xfb, 0xa6, 0x0a, 0x00, 0x00, + // 983 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x56, 0x4f, 0x73, 0xdb, 0x44, + 0x14, 0x47, 0x8e, 0x1d, 0xdb, 0x4f, 0x76, 0x4b, 0xd7, 0x4e, 0x2b, 0x54, 0xb0, 0x1d, 0x85, 0x76, + 0x32, 0xcc, 0x44, 0x2a, 0xe6, 0x40, 0x29, 0xcc, 0x94, 0xa6, 0x69, 0x3d, 0x05, 0x5a, 0x40, 0xcd, + 0x09, 0x0e, 0x9e, 0x8d, 0xb5, 0xc8, 0xc2, 0xf1, 0xca, 0x95, 0xd6, 0x21, 0x1e, 0x86, 0x0b, 0x9f, + 0x80, 0x19, 0x2e, 0x9c, 0xb8, 0x72, 0xe2, 0x7b, 0xf4, 0xc8, 0x0c, 0x37, 0x0e, 0x81, 0xc9, 0x70, + 0xe4, 0xc0, 0x47, 0x60, 0xf6, 0x8f, 0x14, 0x49, 0xce, 0xa4, 0x69, 0xae, 0x9c, 0xac, 0x7d, 0xfb, + 0xde, 0xef, 0xfd, 0xfd, 0xbd, 0x35, 0xe8, 0xcf, 0xe6, 0x24, 0x5a, 0xd8, 0xb3, 0x28, 0x64, 0x21, + 0x6a, 0x7e, 0x8d, 0x89, 0x4f, 0x22, 0x1b, 0xcf, 0x82, 0xe1, 0x41, 0xdf, 0xd4, 0xa7, 0xa1, 0x47, + 0xf6, 0xe5, 0x9d, 0xd9, 0xf6, 0x43, 0x3f, 0x14, 0x9f, 0x0e, 0xff, 0x52, 0xd2, 0xd7, 0xfd, 0x30, + 0xf4, 0xf7, 0x89, 0x83, 0x67, 0x81, 0x83, 0x29, 0x0d, 0x19, 0x66, 0x41, 0x48, 0x63, 0x75, 0xdb, + 0x55, 0xb7, 0xe2, 0xb4, 0x37, 0xff, 0xca, 0x61, 0xc1, 0x94, 0xc4, 0x0c, 0x4f, 0x67, 0x4a, 0xa1, + 0x53, 0x54, 0xf0, 0xe6, 0x91, 0x40, 0x90, 0xf7, 0xd6, 0x3f, 0x1a, 0x5c, 0x1e, 0x10, 0xb6, 0x1b, + 0xe1, 0x11, 0x71, 0xc9, 0xb3, 0x39, 0x89, 0x19, 0xfa, 0x12, 0x6a, 0x8c, 0x9f, 0x87, 0x81, 0x67, + 0x68, 0x3d, 0x6d, 0xb3, 0xb1, 0xfd, 0xe1, 0xf3, 0xa3, 0xee, 0x2b, 0x7f, 0x1c, 0x75, 0xb7, 0xfc, + 0x80, 0x8d, 0xe7, 0x7b, 0xf6, 0x28, 0x9c, 0x3a, 0x32, 0x13, 0xae, 0x18, 0x50, 0x5f, 0x9d, 0x1c, + 0x99, 0x8f, 0x40, 0x7b, 0xb4, 0x73, 0x7c, 0xd4, 0xad, 0xaa, 0x4f, 0xb7, 0x2a, 0x10, 0x1f, 0x79, + 0xe8, 0x2e, 0x40, 0xcc, 0x70, 0xc4, 0x86, 0x3c, 0x52, 0xa3, 0xd4, 0xd3, 0x36, 0xf5, 0xbe, 0x69, + 0xcb, 0x28, 0xed, 0x24, 0x4a, 0x7b, 0x37, 0x49, 0x63, 0xbb, 0xfc, 0xc3, 0x9f, 0x5d, 0xcd, 0xad, + 0x0b, 0x1b, 0x2e, 0x45, 0xef, 0x43, 0x8d, 0x50, 0x4f, 0x9a, 0xaf, 0x9c, 0xd3, 0xbc, 0x4a, 0xa8, + 0xc7, 0x65, 0xd6, 0x03, 0x40, 0x4f, 0x67, 0x98, 0xc6, 0x2e, 0x89, 0x67, 0x21, 0x8d, 0xc9, 0xfd, + 0xf1, 0x9c, 0x4e, 0x90, 0x03, 0x95, 0x98, 0x4b, 0x0d, 0xad, 0xb7, 0xb2, 0xa9, 0xf7, 0x5b, 0x76, + 0xae, 0x4b, 0x36, 0xb7, 0xd8, 0x2e, 0xf3, 0x12, 0xb8, 0x52, 0xcf, 0xfa, 0x57, 0x83, 0xd6, 0xbd, + 0x68, 0x34, 0x0e, 0x0e, 0xc8, 0xff, 0xa5, 0x72, 0x57, 0xa1, 0x9d, 0xcf, 0x58, 0x16, 0xd0, 0xfa, + 0xa5, 0x0c, 0x6d, 0x21, 0xf9, 0x9c, 0x8f, 0xf9, 0x67, 0x38, 0xc2, 0x53, 0xc2, 0x48, 0x14, 0xa3, + 0x75, 0x68, 0xc4, 0x24, 0x3a, 0x08, 0x46, 0x64, 0x48, 0xf1, 0x94, 0x88, 0x7a, 0xd4, 0x5d, 0x5d, + 0xc9, 0x9e, 0xe0, 0x29, 0x41, 0x37, 0xe0, 0x52, 0x38, 0x23, 0x72, 0x1e, 0xa5, 0x52, 0x49, 0x28, + 0x35, 0x53, 0xa9, 0x50, 0xbb, 0x07, 0x65, 0x86, 0xfd, 0xd8, 0x58, 0x11, 0xdd, 0xd9, 0x2a, 0x74, + 0xe7, 0x34, 0xe7, 0xf6, 0x2e, 0xf6, 0xe3, 0x07, 0x94, 0x45, 0x0b, 0x57, 0x98, 0xa2, 0x8f, 0xe0, + 0xd2, 0x49, 0xed, 0x86, 0xd3, 0x80, 0x1a, 0xe5, 0x17, 0x16, 0xa0, 0xc6, 0x5b, 0x27, 0x8a, 0xd0, + 0x48, 0x6b, 0xf8, 0x38, 0xa0, 0x45, 0x2c, 0x7c, 0x68, 0x54, 0x2e, 0x86, 0x85, 0x0f, 0xd1, 0x43, + 0x68, 0x24, 0x84, 0x14, 0x51, 0xad, 0x0a, 0xa4, 0xd7, 0x96, 0x90, 0x76, 0x94, 0x92, 0x04, 0xfa, + 0x89, 0x03, 0xe9, 0x89, 0x21, 0x8f, 0x29, 0x87, 0x83, 0x0f, 0x8d, 0xea, 0x45, 0x70, 0xf0, 0xa1, + 0x6c, 0x1a, 0x8e, 0x46, 0xe3, 0xa1, 0x47, 0x66, 0x6c, 0x6c, 0xd4, 0x7a, 0xda, 0x66, 0x85, 0x37, + 0x8d, 0xcb, 0x76, 0xb8, 0xc8, 0x7c, 0x17, 0xea, 0x69, 0x75, 0xd1, 0xab, 0xb0, 0x32, 0x21, 0x0b, + 0xd5, 0x5b, 0xfe, 0x89, 0xda, 0x50, 0x39, 0xc0, 0xfb, 0xf3, 0xa4, 0x95, 0xf2, 0x70, 0xa7, 0x74, + 0x5b, 0xb3, 0x9e, 0xc0, 0x95, 0x87, 0x01, 0xf5, 0x44, 0xbf, 0xe2, 0x84, 0x31, 0xef, 0x41, 0x45, + 0xec, 0x47, 0x01, 0xa1, 0xf7, 0x37, 0xce, 0xd1, 0x5c, 0x57, 0x5a, 0x58, 0x6d, 0x40, 0x03, 0xc2, + 0x9e, 0xca, 0x79, 0x4a, 0x00, 0xad, 0xb7, 0xa1, 0x95, 0x93, 0xca, 0x31, 0x45, 0x26, 0xd4, 0xd4, + 0xe4, 0x49, 0x96, 0xd7, 0xdd, 0xf4, 0x6c, 0x3d, 0x86, 0xf6, 0x80, 0xb0, 0x4f, 0x93, 0x99, 0x4b, + 0x63, 0x33, 0xa0, 0xaa, 0x74, 0x54, 0x82, 0xc9, 0x11, 0x5d, 0x87, 0x3a, 0x5f, 0x04, 0xc3, 0x49, + 0x40, 0x3d, 0x95, 0x68, 0x8d, 0x0b, 0x3e, 0x0e, 0xa8, 0x67, 0x7d, 0x00, 0xf5, 0x14, 0x0b, 0x21, + 0x28, 0x67, 0xa6, 0x5f, 0x7c, 0x9f, 0x6d, 0xbd, 0x80, 0xb5, 0x42, 0x30, 0x2a, 0x83, 0x9b, 0x19, + 0xb2, 0x70, 0x5a, 0x24, 0x79, 0x14, 0xa4, 0xe8, 0x36, 0x40, 0x2a, 0x89, 0x8d, 0x92, 0xe0, 0x8c, + 0x51, 0x28, 0x6b, 0x0a, 0xef, 0x66, 0x74, 0xad, 0x9f, 0x35, 0xb8, 0x3a, 0x20, 0x6c, 0x87, 0xcc, + 0x08, 0xf5, 0x08, 0x1d, 0x05, 0x27, 0x6d, 0xba, 0x9f, 0xdb, 0x3d, 0xda, 0x4b, 0xcc, 0x7b, 0x66, + 0xff, 0xdc, 0xcd, 0xec, 0x9f, 0xd2, 0x4b, 0x40, 0xa4, 0x3b, 0x68, 0x0f, 0xae, 0x2d, 0xc5, 0xa7, + 0xaa, 0x33, 0x80, 0x86, 0x97, 0x91, 0xab, 0x4d, 0xfe, 0x46, 0x21, 0xef, 0xd4, 0x74, 0xf1, 0x49, + 0x40, 0x27, 0x6a, 0xa7, 0xe7, 0x0c, 0xfb, 0xbf, 0x56, 0xa0, 0x21, 0x06, 0x4e, 0x8d, 0x10, 0x9a, + 0x40, 0x2d, 0x79, 0x20, 0x51, 0xa7, 0x80, 0x57, 0x78, 0x39, 0xcd, 0xf5, 0x53, 0x5e, 0x8e, 0xfc, + 0x5b, 0x63, 0x99, 0xdf, 0xff, 0xfe, 0xf7, 0x8f, 0xa5, 0x36, 0x42, 0x8e, 0xd8, 0xeb, 0xb1, 0xf3, + 0x6d, 0xf2, 0x62, 0x7c, 0x77, 0x4b, 0x43, 0x0c, 0x1a, 0xd9, 0x2d, 0x8b, 0xac, 0x02, 0xe0, 0x29, + 0x8f, 0x8e, 0xb9, 0x71, 0xa6, 0x8e, 0x5a, 0xd3, 0xd7, 0x85, 0xdb, 0x35, 0xab, 0xe5, 0x60, 0x79, + 0x9d, 0xf1, 0x8b, 0x7c, 0x80, 0x13, 0x66, 0xa2, 0x5e, 0x01, 0x6f, 0x89, 0xb4, 0xe7, 0x49, 0x13, + 0x09, 0x7f, 0x0d, 0xab, 0xea, 0xc8, 0xdd, 0x71, 0x47, 0x7b, 0xeb, 0x96, 0x86, 0x7c, 0xd0, 0x33, + 0xe4, 0x44, 0xeb, 0xcb, 0xe5, 0x2c, 0xd0, 0xd9, 0xb4, 0xce, 0x52, 0x51, 0xb9, 0x5d, 0x11, 0xbe, + 0x74, 0x54, 0x77, 0x12, 0x4a, 0xa3, 0x10, 0x9a, 0x39, 0x16, 0xa1, 0x8d, 0x65, 0x9c, 0x25, 0xc2, + 0x9b, 0x6f, 0x9e, 0xad, 0xa4, 0xdc, 0xb5, 0x84, 0xbb, 0x26, 0xd2, 0x9d, 0x13, 0xee, 0xa0, 0x6f, + 0xc4, 0xdf, 0xa8, 0xec, 0x68, 0xa2, 0x1b, 0xcb, 0x68, 0xa7, 0x50, 0xcb, 0xbc, 0xf9, 0x22, 0x35, + 0xe5, 0x76, 0x4d, 0xb8, 0xbd, 0x8c, 0x9a, 0x4e, 0x76, 0x5e, 0xb7, 0xb7, 0x9e, 0x1f, 0x77, 0xb4, + 0xdf, 0x8e, 0x3b, 0xda, 0x5f, 0xc7, 0x1d, 0x0d, 0xae, 0x05, 0xa1, 0x9d, 0xfb, 0x7b, 0xa1, 0x50, + 0xbf, 0x58, 0x95, 0xbf, 0x7b, 0xab, 0x82, 0x69, 0xef, 0xfc, 0x17, 0x00, 0x00, 0xff, 0xff, 0xe1, + 0x8b, 0x00, 0xa9, 0x96, 0x0a, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1174,22 +1175,26 @@ func (m *GetTraceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime):]) - if err1 != nil { - return 0, err1 + if m.EndTime != nil { + n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.EndTime):]) + if err1 != nil { + return 0, err1 + } + i -= n1 + i = encodeVarintQuery(dAtA, i, uint64(n1)) + i-- + dAtA[i] = 0x1a } - i -= n1 - i = encodeVarintQuery(dAtA, i, uint64(n1)) - i-- - dAtA[i] = 0x1a - n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime):]) - if err2 != nil { - return 0, err2 + if m.StartTime != nil { + n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.StartTime):]) + if err2 != nil { + return 0, err2 + } + i -= n2 + i = encodeVarintQuery(dAtA, i, uint64(n2)) + i-- + dAtA[i] = 0x12 } - i -= n2 - i = encodeVarintQuery(dAtA, i, uint64(n2)) - i-- - dAtA[i] = 0x12 { size := m.TraceID.Size() i -= size @@ -1268,22 +1273,26 @@ func (m *ArchiveTraceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - n3, err3 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime):]) - if err3 != nil { - return 0, err3 + if m.EndTime != nil { + n3, err3 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.EndTime):]) + if err3 != nil { + return 0, err3 + } + i -= n3 + i = encodeVarintQuery(dAtA, i, uint64(n3)) + i-- + dAtA[i] = 0x1a } - i -= n3 - i = encodeVarintQuery(dAtA, i, uint64(n3)) - i-- - dAtA[i] = 0x1a - n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime):]) - if err4 != nil { - return 0, err4 + if m.StartTime != nil { + n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.StartTime):]) + if err4 != nil { + return 0, err4 + } + i -= n4 + i = encodeVarintQuery(dAtA, i, uint64(n4)) + i-- + dAtA[i] = 0x12 } - i -= n4 - i = encodeVarintQuery(dAtA, i, uint64(n4)) - i-- - dAtA[i] = 0x12 { size := m.TraceID.Size() i -= size @@ -1758,10 +1767,14 @@ func (m *GetTraceRequest) Size() (n int) { _ = l l = m.TraceID.Size() n += 1 + l + sovQuery(uint64(l)) - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime) - n += 1 + l + sovQuery(uint64(l)) - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime) - n += 1 + l + sovQuery(uint64(l)) + if m.StartTime != nil { + l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.StartTime) + n += 1 + l + sovQuery(uint64(l)) + } + if m.EndTime != nil { + l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.EndTime) + n += 1 + l + sovQuery(uint64(l)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -1794,10 +1807,14 @@ func (m *ArchiveTraceRequest) Size() (n int) { _ = l l = m.TraceID.Size() n += 1 + l + sovQuery(uint64(l)) - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime) - n += 1 + l + sovQuery(uint64(l)) - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime) - n += 1 + l + sovQuery(uint64(l)) + if m.StartTime != nil { + l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.StartTime) + n += 1 + l + sovQuery(uint64(l)) + } + if m.EndTime != nil { + l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.EndTime) + n += 1 + l + sovQuery(uint64(l)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -2096,7 +2113,10 @@ func (m *GetTraceRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StartTime, dAtA[iNdEx:postIndex]); err != nil { + if m.StartTime == nil { + m.StartTime = new(time.Time) + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.StartTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -2129,7 +2149,10 @@ func (m *GetTraceRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.EndTime, dAtA[iNdEx:postIndex]); err != nil { + if m.EndTime == nil { + m.EndTime = new(time.Time) + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.EndTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -2331,7 +2354,10 @@ func (m *ArchiveTraceRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StartTime, dAtA[iNdEx:postIndex]); err != nil { + if m.StartTime == nil { + m.StartTime = new(time.Time) + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.StartTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -2364,7 +2390,10 @@ func (m *ArchiveTraceRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.EndTime, dAtA[iNdEx:postIndex]); err != nil { + if m.EndTime == nil { + m.EndTime = new(time.Time) + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.EndTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex diff --git a/proto-gen/storage_v1/mocks/SamplingStorePluginClient.go b/proto-gen/storage_v1/mocks/SamplingStorePluginClient.go new file mode 100644 index 00000000000..e5c981c53d4 --- /dev/null +++ b/proto-gen/storage_v1/mocks/SamplingStorePluginClient.go @@ -0,0 +1,185 @@ +// Copyright (c) The Jaeger Authors. +// SPDX-License-Identifier: Apache-2.0 +// +// Run 'make generate-mocks' to regenerate. + +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + grpc "google.golang.org/grpc" + + mock "github.com/stretchr/testify/mock" + + storage_v1 "github.com/jaegertracing/jaeger/proto-gen/storage_v1" +) + +// SamplingStorePluginClient is an autogenerated mock type for the SamplingStorePluginClient type +type SamplingStorePluginClient struct { + mock.Mock +} + +// GetLatestProbabilities provides a mock function with given fields: ctx, in, opts +func (_m *SamplingStorePluginClient) GetLatestProbabilities(ctx context.Context, in *storage_v1.GetLatestProbabilitiesRequest, opts ...grpc.CallOption) (*storage_v1.GetLatestProbabilitiesResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetLatestProbabilities") + } + + var r0 *storage_v1.GetLatestProbabilitiesResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetLatestProbabilitiesRequest, ...grpc.CallOption) (*storage_v1.GetLatestProbabilitiesResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetLatestProbabilitiesRequest, ...grpc.CallOption) *storage_v1.GetLatestProbabilitiesResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storage_v1.GetLatestProbabilitiesResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.GetLatestProbabilitiesRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// GetThroughput provides a mock function with given fields: ctx, in, opts +func (_m *SamplingStorePluginClient) GetThroughput(ctx context.Context, in *storage_v1.GetThroughputRequest, opts ...grpc.CallOption) (*storage_v1.GetThroughputResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetThroughput") + } + + var r0 *storage_v1.GetThroughputResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetThroughputRequest, ...grpc.CallOption) (*storage_v1.GetThroughputResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetThroughputRequest, ...grpc.CallOption) *storage_v1.GetThroughputResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storage_v1.GetThroughputResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.GetThroughputRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// InsertProbabilitiesAndQPS provides a mock function with given fields: ctx, in, opts +func (_m *SamplingStorePluginClient) InsertProbabilitiesAndQPS(ctx context.Context, in *storage_v1.InsertProbabilitiesAndQPSRequest, opts ...grpc.CallOption) (*storage_v1.InsertProbabilitiesAndQPSResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for InsertProbabilitiesAndQPS") + } + + var r0 *storage_v1.InsertProbabilitiesAndQPSResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.InsertProbabilitiesAndQPSRequest, ...grpc.CallOption) (*storage_v1.InsertProbabilitiesAndQPSResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.InsertProbabilitiesAndQPSRequest, ...grpc.CallOption) *storage_v1.InsertProbabilitiesAndQPSResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storage_v1.InsertProbabilitiesAndQPSResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.InsertProbabilitiesAndQPSRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// InsertThroughput provides a mock function with given fields: ctx, in, opts +func (_m *SamplingStorePluginClient) InsertThroughput(ctx context.Context, in *storage_v1.InsertThroughputRequest, opts ...grpc.CallOption) (*storage_v1.InsertThroughputResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for InsertThroughput") + } + + var r0 *storage_v1.InsertThroughputResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.InsertThroughputRequest, ...grpc.CallOption) (*storage_v1.InsertThroughputResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.InsertThroughputRequest, ...grpc.CallOption) *storage_v1.InsertThroughputResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storage_v1.InsertThroughputResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.InsertThroughputRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// NewSamplingStorePluginClient creates a new instance of SamplingStorePluginClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewSamplingStorePluginClient(t interface { + mock.TestingT + Cleanup(func()) +}) *SamplingStorePluginClient { + mock := &SamplingStorePluginClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/proto-gen/storage_v1/mocks/SamplingStorePluginServer.go b/proto-gen/storage_v1/mocks/SamplingStorePluginServer.go new file mode 100644 index 00000000000..f14736f3415 --- /dev/null +++ b/proto-gen/storage_v1/mocks/SamplingStorePluginServer.go @@ -0,0 +1,154 @@ +// Copyright (c) The Jaeger Authors. +// SPDX-License-Identifier: Apache-2.0 +// +// Run 'make generate-mocks' to regenerate. + +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + storage_v1 "github.com/jaegertracing/jaeger/proto-gen/storage_v1" + mock "github.com/stretchr/testify/mock" +) + +// SamplingStorePluginServer is an autogenerated mock type for the SamplingStorePluginServer type +type SamplingStorePluginServer struct { + mock.Mock +} + +// GetLatestProbabilities provides a mock function with given fields: _a0, _a1 +func (_m *SamplingStorePluginServer) GetLatestProbabilities(_a0 context.Context, _a1 *storage_v1.GetLatestProbabilitiesRequest) (*storage_v1.GetLatestProbabilitiesResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for GetLatestProbabilities") + } + + var r0 *storage_v1.GetLatestProbabilitiesResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetLatestProbabilitiesRequest) (*storage_v1.GetLatestProbabilitiesResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetLatestProbabilitiesRequest) *storage_v1.GetLatestProbabilitiesResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storage_v1.GetLatestProbabilitiesResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.GetLatestProbabilitiesRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// GetThroughput provides a mock function with given fields: _a0, _a1 +func (_m *SamplingStorePluginServer) GetThroughput(_a0 context.Context, _a1 *storage_v1.GetThroughputRequest) (*storage_v1.GetThroughputResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for GetThroughput") + } + + var r0 *storage_v1.GetThroughputResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetThroughputRequest) (*storage_v1.GetThroughputResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.GetThroughputRequest) *storage_v1.GetThroughputResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storage_v1.GetThroughputResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.GetThroughputRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// InsertProbabilitiesAndQPS provides a mock function with given fields: _a0, _a1 +func (_m *SamplingStorePluginServer) InsertProbabilitiesAndQPS(_a0 context.Context, _a1 *storage_v1.InsertProbabilitiesAndQPSRequest) (*storage_v1.InsertProbabilitiesAndQPSResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for InsertProbabilitiesAndQPS") + } + + var r0 *storage_v1.InsertProbabilitiesAndQPSResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.InsertProbabilitiesAndQPSRequest) (*storage_v1.InsertProbabilitiesAndQPSResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.InsertProbabilitiesAndQPSRequest) *storage_v1.InsertProbabilitiesAndQPSResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storage_v1.InsertProbabilitiesAndQPSResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.InsertProbabilitiesAndQPSRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// InsertThroughput provides a mock function with given fields: _a0, _a1 +func (_m *SamplingStorePluginServer) InsertThroughput(_a0 context.Context, _a1 *storage_v1.InsertThroughputRequest) (*storage_v1.InsertThroughputResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for InsertThroughput") + } + + var r0 *storage_v1.InsertThroughputResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.InsertThroughputRequest) (*storage_v1.InsertThroughputResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *storage_v1.InsertThroughputRequest) *storage_v1.InsertThroughputResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storage_v1.InsertThroughputResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *storage_v1.InsertThroughputRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// NewSamplingStorePluginServer creates a new instance of SamplingStorePluginServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewSamplingStorePluginServer(t interface { + mock.TestingT + Cleanup(func()) +}) *SamplingStorePluginServer { + mock := &SamplingStorePluginServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/proto-gen/storage_v1/storage.pb.go b/proto-gen/storage_v1/storage.pb.go index 72e11ee49ce..e429a7c630f 100644 --- a/proto-gen/storage_v1/storage.pb.go +++ b/proto-gen/storage_v1/storage.pb.go @@ -5,6 +5,7 @@ package storage_v1 import ( context "context" + encoding_binary "encoding/binary" fmt "fmt" _ "github.com/gogo/protobuf/gogoproto" proto "github.com/gogo/protobuf/proto" @@ -893,25 +894,28 @@ func (m *FindTraceIDsResponse) XXX_DiscardUnknown() { var xxx_messageInfo_FindTraceIDsResponse proto.InternalMessageInfo -// empty; extensible in the future -type CapabilitiesRequest struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` +type Throughput struct { + Service string `protobuf:"bytes,1,opt,name=Service,proto3" json:"Service,omitempty"` + Operation string `protobuf:"bytes,2,opt,name=Operation,proto3" json:"Operation,omitempty"` + Count int64 `protobuf:"varint,3,opt,name=Count,proto3" json:"Count,omitempty"` + Probabilities []float64 `protobuf:"fixed64,4,rep,packed,name=Probabilities,proto3" json:"Probabilities,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (m *CapabilitiesRequest) Reset() { *m = CapabilitiesRequest{} } -func (m *CapabilitiesRequest) String() string { return proto.CompactTextString(m) } -func (*CapabilitiesRequest) ProtoMessage() {} -func (*CapabilitiesRequest) Descriptor() ([]byte, []int) { +func (m *Throughput) Reset() { *m = Throughput{} } +func (m *Throughput) String() string { return proto.CompactTextString(m) } +func (*Throughput) ProtoMessage() {} +func (*Throughput) Descriptor() ([]byte, []int) { return fileDescriptor_0d2c4ccf1453ffdb, []int{17} } -func (m *CapabilitiesRequest) XXX_Unmarshal(b []byte) error { +func (m *Throughput) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *CapabilitiesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *Throughput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_CapabilitiesRequest.Marshal(b, m, deterministic) + return xxx_messageInfo_Throughput.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -921,39 +925,65 @@ func (m *CapabilitiesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } -func (m *CapabilitiesRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_CapabilitiesRequest.Merge(m, src) +func (m *Throughput) XXX_Merge(src proto.Message) { + xxx_messageInfo_Throughput.Merge(m, src) } -func (m *CapabilitiesRequest) XXX_Size() int { +func (m *Throughput) XXX_Size() int { return m.Size() } -func (m *CapabilitiesRequest) XXX_DiscardUnknown() { - xxx_messageInfo_CapabilitiesRequest.DiscardUnknown(m) +func (m *Throughput) XXX_DiscardUnknown() { + xxx_messageInfo_Throughput.DiscardUnknown(m) } -var xxx_messageInfo_CapabilitiesRequest proto.InternalMessageInfo +var xxx_messageInfo_Throughput proto.InternalMessageInfo -type CapabilitiesResponse struct { - ArchiveSpanReader bool `protobuf:"varint,1,opt,name=archiveSpanReader,proto3" json:"archiveSpanReader,omitempty"` - ArchiveSpanWriter bool `protobuf:"varint,2,opt,name=archiveSpanWriter,proto3" json:"archiveSpanWriter,omitempty"` - StreamingSpanWriter bool `protobuf:"varint,3,opt,name=streamingSpanWriter,proto3" json:"streamingSpanWriter,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` +func (m *Throughput) GetService() string { + if m != nil { + return m.Service + } + return "" } -func (m *CapabilitiesResponse) Reset() { *m = CapabilitiesResponse{} } -func (m *CapabilitiesResponse) String() string { return proto.CompactTextString(m) } -func (*CapabilitiesResponse) ProtoMessage() {} -func (*CapabilitiesResponse) Descriptor() ([]byte, []int) { +func (m *Throughput) GetOperation() string { + if m != nil { + return m.Operation + } + return "" +} + +func (m *Throughput) GetCount() int64 { + if m != nil { + return m.Count + } + return 0 +} + +func (m *Throughput) GetProbabilities() []float64 { + if m != nil { + return m.Probabilities + } + return nil +} + +type InsertThroughputRequest struct { + Throughput []*Throughput `protobuf:"bytes,1,rep,name=throughput,proto3" json:"throughput,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *InsertThroughputRequest) Reset() { *m = InsertThroughputRequest{} } +func (m *InsertThroughputRequest) String() string { return proto.CompactTextString(m) } +func (*InsertThroughputRequest) ProtoMessage() {} +func (*InsertThroughputRequest) Descriptor() ([]byte, []int) { return fileDescriptor_0d2c4ccf1453ffdb, []int{18} } -func (m *CapabilitiesResponse) XXX_Unmarshal(b []byte) error { +func (m *InsertThroughputRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *CapabilitiesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *InsertThroughputRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_CapabilitiesResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_InsertThroughputRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -963,732 +993,990 @@ func (m *CapabilitiesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte return b[:n], nil } } -func (m *CapabilitiesResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_CapabilitiesResponse.Merge(m, src) +func (m *InsertThroughputRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_InsertThroughputRequest.Merge(m, src) } -func (m *CapabilitiesResponse) XXX_Size() int { +func (m *InsertThroughputRequest) XXX_Size() int { return m.Size() } -func (m *CapabilitiesResponse) XXX_DiscardUnknown() { - xxx_messageInfo_CapabilitiesResponse.DiscardUnknown(m) +func (m *InsertThroughputRequest) XXX_DiscardUnknown() { + xxx_messageInfo_InsertThroughputRequest.DiscardUnknown(m) } -var xxx_messageInfo_CapabilitiesResponse proto.InternalMessageInfo +var xxx_messageInfo_InsertThroughputRequest proto.InternalMessageInfo -func (m *CapabilitiesResponse) GetArchiveSpanReader() bool { +func (m *InsertThroughputRequest) GetThroughput() []*Throughput { if m != nil { - return m.ArchiveSpanReader + return m.Throughput } - return false + return nil } -func (m *CapabilitiesResponse) GetArchiveSpanWriter() bool { - if m != nil { - return m.ArchiveSpanWriter - } - return false +type InsertThroughputResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (m *CapabilitiesResponse) GetStreamingSpanWriter() bool { - if m != nil { - return m.StreamingSpanWriter +func (m *InsertThroughputResponse) Reset() { *m = InsertThroughputResponse{} } +func (m *InsertThroughputResponse) String() string { return proto.CompactTextString(m) } +func (*InsertThroughputResponse) ProtoMessage() {} +func (*InsertThroughputResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{19} +} +func (m *InsertThroughputResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *InsertThroughputResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_InsertThroughputResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return false } - -func init() { - proto.RegisterType((*GetDependenciesRequest)(nil), "jaeger.storage.v1.GetDependenciesRequest") - proto.RegisterType((*GetDependenciesResponse)(nil), "jaeger.storage.v1.GetDependenciesResponse") - proto.RegisterType((*WriteSpanRequest)(nil), "jaeger.storage.v1.WriteSpanRequest") - proto.RegisterType((*WriteSpanResponse)(nil), "jaeger.storage.v1.WriteSpanResponse") - proto.RegisterType((*CloseWriterRequest)(nil), "jaeger.storage.v1.CloseWriterRequest") - proto.RegisterType((*CloseWriterResponse)(nil), "jaeger.storage.v1.CloseWriterResponse") - proto.RegisterType((*GetTraceRequest)(nil), "jaeger.storage.v1.GetTraceRequest") - proto.RegisterType((*GetServicesRequest)(nil), "jaeger.storage.v1.GetServicesRequest") - proto.RegisterType((*GetServicesResponse)(nil), "jaeger.storage.v1.GetServicesResponse") - proto.RegisterType((*GetOperationsRequest)(nil), "jaeger.storage.v1.GetOperationsRequest") - proto.RegisterType((*Operation)(nil), "jaeger.storage.v1.Operation") - proto.RegisterType((*GetOperationsResponse)(nil), "jaeger.storage.v1.GetOperationsResponse") - proto.RegisterType((*TraceQueryParameters)(nil), "jaeger.storage.v1.TraceQueryParameters") - proto.RegisterMapType((map[string]string)(nil), "jaeger.storage.v1.TraceQueryParameters.TagsEntry") - proto.RegisterType((*FindTracesRequest)(nil), "jaeger.storage.v1.FindTracesRequest") - proto.RegisterType((*SpansResponseChunk)(nil), "jaeger.storage.v1.SpansResponseChunk") - proto.RegisterType((*FindTraceIDsRequest)(nil), "jaeger.storage.v1.FindTraceIDsRequest") - proto.RegisterType((*FindTraceIDsResponse)(nil), "jaeger.storage.v1.FindTraceIDsResponse") - proto.RegisterType((*CapabilitiesRequest)(nil), "jaeger.storage.v1.CapabilitiesRequest") - proto.RegisterType((*CapabilitiesResponse)(nil), "jaeger.storage.v1.CapabilitiesResponse") +func (m *InsertThroughputResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_InsertThroughputResponse.Merge(m, src) +} +func (m *InsertThroughputResponse) XXX_Size() int { + return m.Size() +} +func (m *InsertThroughputResponse) XXX_DiscardUnknown() { + xxx_messageInfo_InsertThroughputResponse.DiscardUnknown(m) } -func init() { proto.RegisterFile("storage.proto", fileDescriptor_0d2c4ccf1453ffdb) } +var xxx_messageInfo_InsertThroughputResponse proto.InternalMessageInfo -var fileDescriptor_0d2c4ccf1453ffdb = []byte{ - // 1128 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0x4f, 0x73, 0xdb, 0x44, - 0x14, 0x47, 0xb1, 0xdd, 0xd8, 0xcf, 0x4e, 0x9b, 0xac, 0x5d, 0xaa, 0x0a, 0x9a, 0x04, 0x41, 0x93, - 0xc0, 0x80, 0xdc, 0x98, 0x03, 0x0c, 0x94, 0x81, 0xe6, 0x4f, 0x33, 0x01, 0x0a, 0x45, 0xc9, 0xb4, - 0x33, 0x14, 0xe2, 0x59, 0x47, 0x8b, 0x22, 0x62, 0xad, 0x5c, 0x69, 0xe5, 0x49, 0x86, 0xe1, 0xc6, - 0x07, 0xe0, 0xc8, 0x89, 0x13, 0x33, 0x7c, 0x0f, 0x4e, 0x3d, 0x72, 0xe6, 0x10, 0x98, 0x5c, 0xb9, - 0xf2, 0x01, 0x18, 0xed, 0xae, 0x14, 0xfd, 0x9b, 0x24, 0x4d, 0x73, 0xf3, 0xbe, 0xf7, 0xdb, 0xdf, - 0xfb, 0xbb, 0xef, 0xc9, 0x30, 0x15, 0x30, 0xcf, 0xc7, 0x36, 0x31, 0x46, 0xbe, 0xc7, 0x3c, 0x34, - 0xf3, 0x3d, 0x26, 0x36, 0xf1, 0x8d, 0x58, 0x3a, 0x5e, 0xd6, 0x3a, 0xb6, 0x67, 0x7b, 0x5c, 0xdb, - 0x8d, 0x7e, 0x09, 0xa0, 0x36, 0x67, 0x7b, 0x9e, 0x3d, 0x24, 0x5d, 0x7e, 0x1a, 0x84, 0xdf, 0x75, - 0x99, 0xe3, 0x92, 0x80, 0x61, 0x77, 0x24, 0x01, 0xb3, 0x79, 0x80, 0x15, 0xfa, 0x98, 0x39, 0x1e, - 0x95, 0xfa, 0xa6, 0xeb, 0x59, 0x64, 0x28, 0x0e, 0xfa, 0xaf, 0x0a, 0xbc, 0xbc, 0x41, 0xd8, 0x1a, - 0x19, 0x11, 0x6a, 0x11, 0xba, 0xeb, 0x90, 0xc0, 0x24, 0x4f, 0x43, 0x12, 0x30, 0xb4, 0x0a, 0x10, - 0x30, 0xec, 0xb3, 0x7e, 0x64, 0x40, 0x55, 0xe6, 0x95, 0xa5, 0x66, 0x4f, 0x33, 0x04, 0xb9, 0x11, - 0x93, 0x1b, 0xdb, 0xb1, 0xf5, 0x95, 0xfa, 0xb3, 0xa3, 0xb9, 0x97, 0x7e, 0xfe, 0x7b, 0x4e, 0x31, - 0x1b, 0xfc, 0x5e, 0xa4, 0x41, 0x1f, 0x43, 0x9d, 0x50, 0x4b, 0x50, 0x4c, 0x3c, 0x07, 0xc5, 0x24, - 0xa1, 0x56, 0x24, 0xd7, 0x07, 0x70, 0xa3, 0xe0, 0x5f, 0x30, 0xf2, 0x68, 0x40, 0xd0, 0x06, 0xb4, - 0xac, 0x94, 0x5c, 0x55, 0xe6, 0x2b, 0x4b, 0xcd, 0xde, 0x2d, 0x43, 0x66, 0x12, 0x8f, 0x9c, 0xfe, - 0xb8, 0x67, 0x24, 0x57, 0x0f, 0x3f, 0x77, 0xe8, 0xfe, 0x4a, 0x35, 0x32, 0x61, 0x66, 0x2e, 0xea, - 0x1f, 0xc2, 0xf4, 0x63, 0xdf, 0x61, 0x64, 0x6b, 0x84, 0x69, 0x1c, 0xfd, 0x22, 0x54, 0x83, 0x11, - 0xa6, 0x32, 0xee, 0x76, 0x8e, 0x94, 0x23, 0x39, 0x40, 0x6f, 0xc3, 0x4c, 0xea, 0xb2, 0x70, 0x4d, - 0xef, 0x00, 0x5a, 0x1d, 0x7a, 0x01, 0xe1, 0x1a, 0x5f, 0x72, 0xea, 0xd7, 0xa1, 0x9d, 0x91, 0x4a, - 0xf0, 0x7f, 0x0a, 0x5c, 0xdb, 0x20, 0x6c, 0xdb, 0xc7, 0xbb, 0x24, 0x36, 0xff, 0x04, 0xea, 0x2c, - 0x3a, 0xf7, 0x1d, 0x8b, 0xbb, 0xd0, 0x5a, 0xf9, 0x24, 0x72, 0xfc, 0xaf, 0xa3, 0xb9, 0x77, 0x6c, - 0x87, 0xed, 0x85, 0x03, 0x63, 0xd7, 0x73, 0xbb, 0xc2, 0xa9, 0x08, 0xe8, 0x50, 0x5b, 0x9e, 0xba, - 0xa2, 0xbc, 0x9c, 0x6d, 0x73, 0xed, 0xf8, 0x68, 0x6e, 0x52, 0xfe, 0x34, 0x27, 0x39, 0xe3, 0xa6, - 0x95, 0xab, 0xec, 0xc4, 0x8b, 0x57, 0xb6, 0x72, 0x91, 0xca, 0x76, 0x00, 0x6d, 0x10, 0xb6, 0x45, - 0xfc, 0xb1, 0xb3, 0x9b, 0x74, 0x9d, 0xbe, 0x0c, 0xed, 0x8c, 0x54, 0xd6, 0x5a, 0x83, 0x7a, 0x20, - 0x65, 0xbc, 0xce, 0x0d, 0x33, 0x39, 0xeb, 0x0f, 0xa0, 0xb3, 0x41, 0xd8, 0x97, 0x23, 0x22, 0xda, - 0x3c, 0x69, 0x60, 0x15, 0x26, 0x25, 0x86, 0xa7, 0xb0, 0x61, 0xc6, 0x47, 0xf4, 0x0a, 0x34, 0xa2, - 0xda, 0xf5, 0xf7, 0x1d, 0x6a, 0xf1, 0xf8, 0x23, 0xba, 0x11, 0xa6, 0x9f, 0x39, 0xd4, 0xd2, 0xef, - 0x42, 0x23, 0xe1, 0x42, 0x08, 0xaa, 0x14, 0xbb, 0x31, 0x01, 0xff, 0x7d, 0xfa, 0xed, 0x1f, 0xe1, - 0x7a, 0xce, 0x19, 0x19, 0xc1, 0x02, 0x5c, 0xf5, 0x62, 0xe9, 0x17, 0xd8, 0x4d, 0xe2, 0xc8, 0x49, - 0xd1, 0x5d, 0x80, 0x44, 0x12, 0xa8, 0x13, 0xbc, 0xa7, 0x5f, 0x35, 0x0a, 0xd3, 0xc1, 0x48, 0x4c, - 0x98, 0x29, 0xbc, 0xfe, 0x7b, 0x15, 0x3a, 0xbc, 0xde, 0x5f, 0x85, 0xc4, 0x3f, 0x7c, 0x88, 0x7d, - 0xec, 0x12, 0x46, 0xfc, 0x00, 0xbd, 0x06, 0x2d, 0x19, 0x7d, 0x3f, 0x15, 0x50, 0x53, 0xca, 0x22, - 0xd3, 0xe8, 0x76, 0xca, 0x43, 0x01, 0x12, 0xc1, 0x4d, 0x65, 0x3c, 0x44, 0xeb, 0x50, 0x65, 0xd8, - 0x0e, 0xd4, 0x0a, 0x77, 0x6d, 0xb9, 0xc4, 0xb5, 0x32, 0x07, 0x8c, 0x6d, 0x6c, 0x07, 0xeb, 0x94, - 0xf9, 0x87, 0x26, 0xbf, 0x8e, 0x3e, 0x85, 0xab, 0x27, 0x4d, 0xd8, 0x77, 0x1d, 0xaa, 0x56, 0x9f, - 0xa3, 0x8b, 0x5a, 0x49, 0x23, 0x3e, 0x70, 0x68, 0x9e, 0x0b, 0x1f, 0xa8, 0xb5, 0x8b, 0x71, 0xe1, - 0x03, 0x74, 0x1f, 0x5a, 0xf1, 0xc0, 0xe4, 0x5e, 0x5d, 0xe1, 0x4c, 0x37, 0x0b, 0x4c, 0x6b, 0x12, - 0x24, 0x88, 0x7e, 0x89, 0x88, 0x9a, 0xf1, 0xc5, 0xc8, 0xa7, 0x0c, 0x0f, 0x3e, 0x50, 0x27, 0x2f, - 0xc2, 0x83, 0x0f, 0xd0, 0x2d, 0x00, 0x1a, 0xba, 0x7d, 0xfe, 0x76, 0x03, 0xb5, 0x3e, 0xaf, 0x2c, - 0xd5, 0xcc, 0x06, 0x0d, 0x5d, 0x9e, 0xe4, 0x40, 0x7b, 0x0f, 0x1a, 0x49, 0x66, 0xd1, 0x34, 0x54, - 0xf6, 0xc9, 0xa1, 0xac, 0x6d, 0xf4, 0x13, 0x75, 0xa0, 0x36, 0xc6, 0xc3, 0x30, 0x2e, 0xa5, 0x38, - 0x7c, 0x30, 0xf1, 0xbe, 0xa2, 0x9b, 0x30, 0x73, 0xdf, 0xa1, 0x96, 0xa0, 0x89, 0x9f, 0xcc, 0x47, - 0x50, 0x7b, 0x1a, 0xd5, 0x4d, 0x8e, 0xbd, 0xc5, 0x73, 0x16, 0xd7, 0x14, 0xb7, 0xf4, 0x75, 0x40, - 0xd1, 0x18, 0x4c, 0x9a, 0x7e, 0x75, 0x2f, 0xa4, 0xfb, 0xa8, 0x0b, 0xb5, 0xe8, 0x79, 0xc4, 0x03, - 0xba, 0x6c, 0x96, 0xca, 0xb1, 0x2c, 0x70, 0xfa, 0x36, 0xb4, 0x13, 0xd7, 0x36, 0xd7, 0x2e, 0xcb, - 0xb9, 0x31, 0x74, 0xb2, 0xac, 0xf2, 0x61, 0xee, 0x40, 0x23, 0x1e, 0xb5, 0xc2, 0xc5, 0xd6, 0xca, - 0xbd, 0x8b, 0xce, 0xda, 0x7a, 0xc2, 0x5e, 0x97, 0xc3, 0x36, 0xe0, 0x53, 0x1f, 0x8f, 0xf0, 0xc0, - 0x19, 0x3a, 0xec, 0x64, 0xbd, 0xea, 0xbf, 0x29, 0xd0, 0xc9, 0xca, 0xa5, 0x3f, 0x6f, 0xc3, 0x0c, - 0xf6, 0x77, 0xf7, 0x9c, 0xb1, 0x5c, 0x29, 0xd8, 0x22, 0x3e, 0x0f, 0xb9, 0x6e, 0x16, 0x15, 0x39, - 0xb4, 0xd8, 0x2c, 0xbc, 0xd8, 0x59, 0xb4, 0x50, 0xa0, 0x3b, 0xd0, 0x0e, 0x98, 0x4f, 0xb0, 0xeb, - 0x50, 0x3b, 0x85, 0xaf, 0x70, 0x7c, 0x99, 0xaa, 0xf7, 0x87, 0x02, 0xd3, 0x27, 0xc7, 0x87, 0xc3, - 0xd0, 0x76, 0x28, 0x7a, 0x04, 0x8d, 0x64, 0xe7, 0xa1, 0xd7, 0x4b, 0xea, 0x90, 0x5f, 0xa7, 0xda, - 0x1b, 0xa7, 0x83, 0x64, 0xe8, 0x8f, 0xa0, 0xc6, 0x17, 0x24, 0xba, 0x5d, 0x02, 0x2f, 0x2e, 0x54, - 0x6d, 0xe1, 0x2c, 0x98, 0xe0, 0xed, 0xfd, 0x00, 0x37, 0xb7, 0x8a, 0xb1, 0xc9, 0x60, 0x76, 0xe0, - 0x5a, 0xe2, 0x89, 0x40, 0x5d, 0x62, 0x48, 0x4b, 0x4a, 0xef, 0xdf, 0x8a, 0xc8, 0xa0, 0x28, 0x98, - 0x34, 0xfa, 0x18, 0xea, 0xf1, 0xca, 0x47, 0x7a, 0x09, 0x51, 0xee, 0x7b, 0x40, 0x2b, 0x4b, 0x48, - 0xf1, 0xa9, 0xdd, 0x51, 0xd0, 0x37, 0xd0, 0x4c, 0xed, 0xcf, 0xd2, 0x44, 0x16, 0xb7, 0x6e, 0x69, - 0x22, 0xcb, 0xd6, 0xf0, 0x00, 0xa6, 0x32, 0xdb, 0x0d, 0x2d, 0x96, 0x5f, 0x2c, 0x2c, 0x63, 0x6d, - 0xe9, 0x6c, 0xa0, 0xb4, 0xf1, 0x04, 0xe0, 0x64, 0x30, 0xa1, 0xb2, 0x2c, 0x17, 0xe6, 0xd6, 0xf9, - 0xd3, 0xd3, 0x87, 0x56, 0x7a, 0x08, 0xa0, 0x85, 0xd3, 0xe8, 0x4f, 0x66, 0x8f, 0xb6, 0x78, 0x26, - 0x4e, 0xb6, 0xda, 0x01, 0xdc, 0xb8, 0x97, 0x7f, 0x76, 0xb2, 0xe6, 0xdf, 0xca, 0xcf, 0xcc, 0x94, - 0xfe, 0x12, 0x3b, 0xad, 0x77, 0x98, 0xb1, 0x9c, 0xe9, 0xb6, 0x1d, 0xfe, 0x81, 0x29, 0xb5, 0x97, - 0xdf, 0x74, 0xbd, 0x9f, 0x14, 0x50, 0xb3, 0x9f, 0xe8, 0x29, 0xe3, 0x7b, 0xdc, 0x78, 0x5a, 0x8d, - 0xde, 0x2c, 0x37, 0x5e, 0xf2, 0x2f, 0x44, 0x7b, 0xeb, 0x3c, 0x50, 0x99, 0x81, 0x10, 0x90, 0xb0, - 0x99, 0x9e, 0xab, 0x51, 0xc9, 0x33, 0xe7, 0xd2, 0xa1, 0x51, 0x1c, 0xd0, 0xa5, 0x25, 0x2f, 0x1b, - 0xd8, 0x2b, 0xea, 0xb3, 0xe3, 0x59, 0xe5, 0xcf, 0xe3, 0x59, 0xe5, 0x9f, 0xe3, 0x59, 0xe5, 0x6b, - 0x90, 0xf0, 0xfe, 0x78, 0x79, 0x70, 0x85, 0x6f, 0xf9, 0x77, 0xff, 0x0f, 0x00, 0x00, 0xff, 0xff, - 0x4d, 0x42, 0xc0, 0x41, 0xec, 0x0d, 0x00, 0x00, +type StringFloatMap struct { + StringFloatMap map[string]float64 `protobuf:"bytes,1,rep,name=stringFloatMap,proto3" json:"stringFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -// Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +func (m *StringFloatMap) Reset() { *m = StringFloatMap{} } +func (m *StringFloatMap) String() string { return proto.CompactTextString(m) } +func (*StringFloatMap) ProtoMessage() {} +func (*StringFloatMap) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{20} +} +func (m *StringFloatMap) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StringFloatMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StringFloatMap.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *StringFloatMap) XXX_Merge(src proto.Message) { + xxx_messageInfo_StringFloatMap.Merge(m, src) +} +func (m *StringFloatMap) XXX_Size() int { + return m.Size() +} +func (m *StringFloatMap) XXX_DiscardUnknown() { + xxx_messageInfo_StringFloatMap.DiscardUnknown(m) +} -// 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 +var xxx_messageInfo_StringFloatMap proto.InternalMessageInfo -// SpanWriterPluginClient is the client API for SpanWriterPlugin service. -// -// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. -type SpanWriterPluginClient interface { - // spanstore/Writer - WriteSpan(ctx context.Context, in *WriteSpanRequest, opts ...grpc.CallOption) (*WriteSpanResponse, error) - Close(ctx context.Context, in *CloseWriterRequest, opts ...grpc.CallOption) (*CloseWriterResponse, error) +func (m *StringFloatMap) GetStringFloatMap() map[string]float64 { + if m != nil { + return m.StringFloatMap + } + return nil } -type spanWriterPluginClient struct { - cc *grpc.ClientConn +type ServiceOperationProbabilities struct { + ServiceOperationProbabilities map[string]*StringFloatMap `protobuf:"bytes,1,rep,name=serviceOperationProbabilities,proto3" json:"serviceOperationProbabilities,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func NewSpanWriterPluginClient(cc *grpc.ClientConn) SpanWriterPluginClient { - return &spanWriterPluginClient{cc} +func (m *ServiceOperationProbabilities) Reset() { *m = ServiceOperationProbabilities{} } +func (m *ServiceOperationProbabilities) String() string { return proto.CompactTextString(m) } +func (*ServiceOperationProbabilities) ProtoMessage() {} +func (*ServiceOperationProbabilities) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{21} } - -func (c *spanWriterPluginClient) WriteSpan(ctx context.Context, in *WriteSpanRequest, opts ...grpc.CallOption) (*WriteSpanResponse, error) { - out := new(WriteSpanResponse) - err := c.cc.Invoke(ctx, "/jaeger.storage.v1.SpanWriterPlugin/WriteSpan", in, out, opts...) - if err != nil { - return nil, err +func (m *ServiceOperationProbabilities) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ServiceOperationProbabilities) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ServiceOperationProbabilities.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *ServiceOperationProbabilities) XXX_Merge(src proto.Message) { + xxx_messageInfo_ServiceOperationProbabilities.Merge(m, src) +} +func (m *ServiceOperationProbabilities) XXX_Size() int { + return m.Size() +} +func (m *ServiceOperationProbabilities) XXX_DiscardUnknown() { + xxx_messageInfo_ServiceOperationProbabilities.DiscardUnknown(m) } -func (c *spanWriterPluginClient) Close(ctx context.Context, in *CloseWriterRequest, opts ...grpc.CallOption) (*CloseWriterResponse, error) { - out := new(CloseWriterResponse) - err := c.cc.Invoke(ctx, "/jaeger.storage.v1.SpanWriterPlugin/Close", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_ServiceOperationProbabilities proto.InternalMessageInfo + +func (m *ServiceOperationProbabilities) GetServiceOperationProbabilities() map[string]*StringFloatMap { + if m != nil { + return m.ServiceOperationProbabilities } - return out, nil + return nil } -// SpanWriterPluginServer is the server API for SpanWriterPlugin service. -type SpanWriterPluginServer interface { - // spanstore/Writer - WriteSpan(context.Context, *WriteSpanRequest) (*WriteSpanResponse, error) - Close(context.Context, *CloseWriterRequest) (*CloseWriterResponse, error) +type ServiceOperationQPS struct { + ServiceOperationQPS map[string]*StringFloatMap `protobuf:"bytes,1,rep,name=serviceOperationQPS,proto3" json:"serviceOperationQPS,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -// UnimplementedSpanWriterPluginServer can be embedded to have forward compatible implementations. -type UnimplementedSpanWriterPluginServer struct { +func (m *ServiceOperationQPS) Reset() { *m = ServiceOperationQPS{} } +func (m *ServiceOperationQPS) String() string { return proto.CompactTextString(m) } +func (*ServiceOperationQPS) ProtoMessage() {} +func (*ServiceOperationQPS) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{22} } - -func (*UnimplementedSpanWriterPluginServer) WriteSpan(ctx context.Context, req *WriteSpanRequest) (*WriteSpanResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method WriteSpan not implemented") +func (m *ServiceOperationQPS) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } -func (*UnimplementedSpanWriterPluginServer) Close(ctx context.Context, req *CloseWriterRequest) (*CloseWriterResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method Close not implemented") +func (m *ServiceOperationQPS) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ServiceOperationQPS.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } } - -func RegisterSpanWriterPluginServer(s *grpc.Server, srv SpanWriterPluginServer) { - s.RegisterService(&_SpanWriterPlugin_serviceDesc, srv) +func (m *ServiceOperationQPS) XXX_Merge(src proto.Message) { + xxx_messageInfo_ServiceOperationQPS.Merge(m, src) +} +func (m *ServiceOperationQPS) XXX_Size() int { + return m.Size() +} +func (m *ServiceOperationQPS) XXX_DiscardUnknown() { + xxx_messageInfo_ServiceOperationQPS.DiscardUnknown(m) } -func _SpanWriterPlugin_WriteSpan_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(WriteSpanRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(SpanWriterPluginServer).WriteSpan(ctx, in) +var xxx_messageInfo_ServiceOperationQPS proto.InternalMessageInfo + +func (m *ServiceOperationQPS) GetServiceOperationQPS() map[string]*StringFloatMap { + if m != nil { + return m.ServiceOperationQPS } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/jaeger.storage.v1.SpanWriterPlugin/WriteSpan", + return nil +} + +type InsertProbabilitiesAndQPSRequest struct { + Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"` + Probabilities *ServiceOperationProbabilities `protobuf:"bytes,2,opt,name=probabilities,proto3" json:"probabilities,omitempty"` + Qps *ServiceOperationQPS `protobuf:"bytes,3,opt,name=qps,proto3" json:"qps,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *InsertProbabilitiesAndQPSRequest) Reset() { *m = InsertProbabilitiesAndQPSRequest{} } +func (m *InsertProbabilitiesAndQPSRequest) String() string { return proto.CompactTextString(m) } +func (*InsertProbabilitiesAndQPSRequest) ProtoMessage() {} +func (*InsertProbabilitiesAndQPSRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{23} +} +func (m *InsertProbabilitiesAndQPSRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *InsertProbabilitiesAndQPSRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_InsertProbabilitiesAndQPSRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(SpanWriterPluginServer).WriteSpan(ctx, req.(*WriteSpanRequest)) +} +func (m *InsertProbabilitiesAndQPSRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_InsertProbabilitiesAndQPSRequest.Merge(m, src) +} +func (m *InsertProbabilitiesAndQPSRequest) XXX_Size() int { + return m.Size() +} +func (m *InsertProbabilitiesAndQPSRequest) XXX_DiscardUnknown() { + xxx_messageInfo_InsertProbabilitiesAndQPSRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_InsertProbabilitiesAndQPSRequest proto.InternalMessageInfo + +func (m *InsertProbabilitiesAndQPSRequest) GetHostname() string { + if m != nil { + return m.Hostname } - return interceptor(ctx, in, info, handler) + return "" } -func _SpanWriterPlugin_Close_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(CloseWriterRequest) - if err := dec(in); err != nil { - return nil, err +func (m *InsertProbabilitiesAndQPSRequest) GetProbabilities() *ServiceOperationProbabilities { + if m != nil { + return m.Probabilities } - if interceptor == nil { - return srv.(SpanWriterPluginServer).Close(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/jaeger.storage.v1.SpanWriterPlugin/Close", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(SpanWriterPluginServer).Close(ctx, req.(*CloseWriterRequest)) - } - return interceptor(ctx, in, info, handler) + return nil } -var _SpanWriterPlugin_serviceDesc = grpc.ServiceDesc{ - ServiceName: "jaeger.storage.v1.SpanWriterPlugin", - HandlerType: (*SpanWriterPluginServer)(nil), - Methods: []grpc.MethodDesc{ - { - MethodName: "WriteSpan", - Handler: _SpanWriterPlugin_WriteSpan_Handler, - }, - { - MethodName: "Close", - Handler: _SpanWriterPlugin_Close_Handler, - }, - }, - Streams: []grpc.StreamDesc{}, - Metadata: "storage.proto", +func (m *InsertProbabilitiesAndQPSRequest) GetQps() *ServiceOperationQPS { + if m != nil { + return m.Qps + } + return nil } -// StreamingSpanWriterPluginClient is the client API for StreamingSpanWriterPlugin service. -// -// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. -type StreamingSpanWriterPluginClient interface { - WriteSpanStream(ctx context.Context, opts ...grpc.CallOption) (StreamingSpanWriterPlugin_WriteSpanStreamClient, error) +type InsertProbabilitiesAndQPSResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -type streamingSpanWriterPluginClient struct { - cc *grpc.ClientConn +func (m *InsertProbabilitiesAndQPSResponse) Reset() { *m = InsertProbabilitiesAndQPSResponse{} } +func (m *InsertProbabilitiesAndQPSResponse) String() string { return proto.CompactTextString(m) } +func (*InsertProbabilitiesAndQPSResponse) ProtoMessage() {} +func (*InsertProbabilitiesAndQPSResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{24} } - -func NewStreamingSpanWriterPluginClient(cc *grpc.ClientConn) StreamingSpanWriterPluginClient { - return &streamingSpanWriterPluginClient{cc} +func (m *InsertProbabilitiesAndQPSResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } - -func (c *streamingSpanWriterPluginClient) WriteSpanStream(ctx context.Context, opts ...grpc.CallOption) (StreamingSpanWriterPlugin_WriteSpanStreamClient, error) { - stream, err := c.cc.NewStream(ctx, &_StreamingSpanWriterPlugin_serviceDesc.Streams[0], "/jaeger.storage.v1.StreamingSpanWriterPlugin/WriteSpanStream", opts...) - if err != nil { - return nil, err +func (m *InsertProbabilitiesAndQPSResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_InsertProbabilitiesAndQPSResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - x := &streamingSpanWriterPluginWriteSpanStreamClient{stream} - return x, nil } - -type StreamingSpanWriterPlugin_WriteSpanStreamClient interface { - Send(*WriteSpanRequest) error - CloseAndRecv() (*WriteSpanResponse, error) - grpc.ClientStream +func (m *InsertProbabilitiesAndQPSResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_InsertProbabilitiesAndQPSResponse.Merge(m, src) } - -type streamingSpanWriterPluginWriteSpanStreamClient struct { - grpc.ClientStream +func (m *InsertProbabilitiesAndQPSResponse) XXX_Size() int { + return m.Size() } - -func (x *streamingSpanWriterPluginWriteSpanStreamClient) Send(m *WriteSpanRequest) error { - return x.ClientStream.SendMsg(m) +func (m *InsertProbabilitiesAndQPSResponse) XXX_DiscardUnknown() { + xxx_messageInfo_InsertProbabilitiesAndQPSResponse.DiscardUnknown(m) } -func (x *streamingSpanWriterPluginWriteSpanStreamClient) CloseAndRecv() (*WriteSpanResponse, error) { - if err := x.ClientStream.CloseSend(); err != nil { - return nil, err - } - m := new(WriteSpanResponse) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +var xxx_messageInfo_InsertProbabilitiesAndQPSResponse proto.InternalMessageInfo -// StreamingSpanWriterPluginServer is the server API for StreamingSpanWriterPlugin service. -type StreamingSpanWriterPluginServer interface { - WriteSpanStream(StreamingSpanWriterPlugin_WriteSpanStreamServer) error +type GetThroughputRequest struct { + StartTime time.Time `protobuf:"bytes,1,opt,name=start_time,json=startTime,proto3,stdtime" json:"start_time"` + EndTime time.Time `protobuf:"bytes,2,opt,name=end_time,json=endTime,proto3,stdtime" json:"end_time"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -// UnimplementedStreamingSpanWriterPluginServer can be embedded to have forward compatible implementations. -type UnimplementedStreamingSpanWriterPluginServer struct { +func (m *GetThroughputRequest) Reset() { *m = GetThroughputRequest{} } +func (m *GetThroughputRequest) String() string { return proto.CompactTextString(m) } +func (*GetThroughputRequest) ProtoMessage() {} +func (*GetThroughputRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{25} } - -func (*UnimplementedStreamingSpanWriterPluginServer) WriteSpanStream(srv StreamingSpanWriterPlugin_WriteSpanStreamServer) error { - return status.Errorf(codes.Unimplemented, "method WriteSpanStream not implemented") +func (m *GetThroughputRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } - -func RegisterStreamingSpanWriterPluginServer(s *grpc.Server, srv StreamingSpanWriterPluginServer) { - s.RegisterService(&_StreamingSpanWriterPlugin_serviceDesc, srv) +func (m *GetThroughputRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetThroughputRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } } - -func _StreamingSpanWriterPlugin_WriteSpanStream_Handler(srv interface{}, stream grpc.ServerStream) error { - return srv.(StreamingSpanWriterPluginServer).WriteSpanStream(&streamingSpanWriterPluginWriteSpanStreamServer{stream}) +func (m *GetThroughputRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetThroughputRequest.Merge(m, src) } - -type StreamingSpanWriterPlugin_WriteSpanStreamServer interface { - SendAndClose(*WriteSpanResponse) error - Recv() (*WriteSpanRequest, error) - grpc.ServerStream +func (m *GetThroughputRequest) XXX_Size() int { + return m.Size() } - -type streamingSpanWriterPluginWriteSpanStreamServer struct { - grpc.ServerStream +func (m *GetThroughputRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetThroughputRequest.DiscardUnknown(m) } -func (x *streamingSpanWriterPluginWriteSpanStreamServer) SendAndClose(m *WriteSpanResponse) error { - return x.ServerStream.SendMsg(m) -} +var xxx_messageInfo_GetThroughputRequest proto.InternalMessageInfo -func (x *streamingSpanWriterPluginWriteSpanStreamServer) Recv() (*WriteSpanRequest, error) { - m := new(WriteSpanRequest) - if err := x.ServerStream.RecvMsg(m); err != nil { - return nil, err +func (m *GetThroughputRequest) GetStartTime() time.Time { + if m != nil { + return m.StartTime } - return m, nil + return time.Time{} } -var _StreamingSpanWriterPlugin_serviceDesc = grpc.ServiceDesc{ - ServiceName: "jaeger.storage.v1.StreamingSpanWriterPlugin", - HandlerType: (*StreamingSpanWriterPluginServer)(nil), - Methods: []grpc.MethodDesc{}, - Streams: []grpc.StreamDesc{ - { - StreamName: "WriteSpanStream", - Handler: _StreamingSpanWriterPlugin_WriteSpanStream_Handler, - ClientStreams: true, - }, - }, - Metadata: "storage.proto", +func (m *GetThroughputRequest) GetEndTime() time.Time { + if m != nil { + return m.EndTime + } + return time.Time{} } -// SpanReaderPluginClient is the client API for SpanReaderPlugin service. -// -// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. -type SpanReaderPluginClient interface { - // spanstore/Reader - GetTrace(ctx context.Context, in *GetTraceRequest, opts ...grpc.CallOption) (SpanReaderPlugin_GetTraceClient, error) - GetServices(ctx context.Context, in *GetServicesRequest, opts ...grpc.CallOption) (*GetServicesResponse, error) - GetOperations(ctx context.Context, in *GetOperationsRequest, opts ...grpc.CallOption) (*GetOperationsResponse, error) - FindTraces(ctx context.Context, in *FindTracesRequest, opts ...grpc.CallOption) (SpanReaderPlugin_FindTracesClient, error) - FindTraceIDs(ctx context.Context, in *FindTraceIDsRequest, opts ...grpc.CallOption) (*FindTraceIDsResponse, error) +type GetThroughputResponse struct { + Throughput []*Throughput `protobuf:"bytes,1,rep,name=throughput,proto3" json:"throughput,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -type spanReaderPluginClient struct { - cc *grpc.ClientConn +func (m *GetThroughputResponse) Reset() { *m = GetThroughputResponse{} } +func (m *GetThroughputResponse) String() string { return proto.CompactTextString(m) } +func (*GetThroughputResponse) ProtoMessage() {} +func (*GetThroughputResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{26} } - -func NewSpanReaderPluginClient(cc *grpc.ClientConn) SpanReaderPluginClient { - return &spanReaderPluginClient{cc} +func (m *GetThroughputResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } - -func (c *spanReaderPluginClient) GetTrace(ctx context.Context, in *GetTraceRequest, opts ...grpc.CallOption) (SpanReaderPlugin_GetTraceClient, error) { - stream, err := c.cc.NewStream(ctx, &_SpanReaderPlugin_serviceDesc.Streams[0], "/jaeger.storage.v1.SpanReaderPlugin/GetTrace", opts...) - if err != nil { - return nil, err - } - x := &spanReaderPluginGetTraceClient{stream} - if err := x.ClientStream.SendMsg(in); err != nil { - return nil, err - } - if err := x.ClientStream.CloseSend(); err != nil { - return nil, err +func (m *GetThroughputResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetThroughputResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return x, nil } - -type SpanReaderPlugin_GetTraceClient interface { - Recv() (*SpansResponseChunk, error) - grpc.ClientStream +func (m *GetThroughputResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetThroughputResponse.Merge(m, src) } - -type spanReaderPluginGetTraceClient struct { - grpc.ClientStream +func (m *GetThroughputResponse) XXX_Size() int { + return m.Size() } - -func (x *spanReaderPluginGetTraceClient) Recv() (*SpansResponseChunk, error) { - m := new(SpansResponseChunk) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil +func (m *GetThroughputResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetThroughputResponse.DiscardUnknown(m) } -func (c *spanReaderPluginClient) GetServices(ctx context.Context, in *GetServicesRequest, opts ...grpc.CallOption) (*GetServicesResponse, error) { - out := new(GetServicesResponse) - err := c.cc.Invoke(ctx, "/jaeger.storage.v1.SpanReaderPlugin/GetServices", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_GetThroughputResponse proto.InternalMessageInfo + +func (m *GetThroughputResponse) GetThroughput() []*Throughput { + if m != nil { + return m.Throughput } - return out, nil + return nil } -func (c *spanReaderPluginClient) GetOperations(ctx context.Context, in *GetOperationsRequest, opts ...grpc.CallOption) (*GetOperationsResponse, error) { - out := new(GetOperationsResponse) - err := c.cc.Invoke(ctx, "/jaeger.storage.v1.SpanReaderPlugin/GetOperations", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +type GetLatestProbabilitiesRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (c *spanReaderPluginClient) FindTraces(ctx context.Context, in *FindTracesRequest, opts ...grpc.CallOption) (SpanReaderPlugin_FindTracesClient, error) { - stream, err := c.cc.NewStream(ctx, &_SpanReaderPlugin_serviceDesc.Streams[1], "/jaeger.storage.v1.SpanReaderPlugin/FindTraces", opts...) - if err != nil { - return nil, err - } - x := &spanReaderPluginFindTracesClient{stream} - if err := x.ClientStream.SendMsg(in); err != nil { - return nil, err - } - if err := x.ClientStream.CloseSend(); err != nil { - return nil, err +func (m *GetLatestProbabilitiesRequest) Reset() { *m = GetLatestProbabilitiesRequest{} } +func (m *GetLatestProbabilitiesRequest) String() string { return proto.CompactTextString(m) } +func (*GetLatestProbabilitiesRequest) ProtoMessage() {} +func (*GetLatestProbabilitiesRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{27} +} +func (m *GetLatestProbabilitiesRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetLatestProbabilitiesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetLatestProbabilitiesRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return x, nil } - -type SpanReaderPlugin_FindTracesClient interface { - Recv() (*SpansResponseChunk, error) - grpc.ClientStream +func (m *GetLatestProbabilitiesRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetLatestProbabilitiesRequest.Merge(m, src) } - -type spanReaderPluginFindTracesClient struct { - grpc.ClientStream +func (m *GetLatestProbabilitiesRequest) XXX_Size() int { + return m.Size() +} +func (m *GetLatestProbabilitiesRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetLatestProbabilitiesRequest.DiscardUnknown(m) } -func (x *spanReaderPluginFindTracesClient) Recv() (*SpansResponseChunk, error) { - m := new(SpansResponseChunk) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil +var xxx_messageInfo_GetLatestProbabilitiesRequest proto.InternalMessageInfo + +type GetLatestProbabilitiesResponse struct { + ServiceOperationProbabilities *ServiceOperationProbabilities `protobuf:"bytes,1,opt,name=serviceOperationProbabilities,proto3" json:"serviceOperationProbabilities,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (c *spanReaderPluginClient) FindTraceIDs(ctx context.Context, in *FindTraceIDsRequest, opts ...grpc.CallOption) (*FindTraceIDsResponse, error) { - out := new(FindTraceIDsResponse) - err := c.cc.Invoke(ctx, "/jaeger.storage.v1.SpanReaderPlugin/FindTraceIDs", in, out, opts...) - if err != nil { - return nil, err +func (m *GetLatestProbabilitiesResponse) Reset() { *m = GetLatestProbabilitiesResponse{} } +func (m *GetLatestProbabilitiesResponse) String() string { return proto.CompactTextString(m) } +func (*GetLatestProbabilitiesResponse) ProtoMessage() {} +func (*GetLatestProbabilitiesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{28} +} +func (m *GetLatestProbabilitiesResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetLatestProbabilitiesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetLatestProbabilitiesResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *GetLatestProbabilitiesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetLatestProbabilitiesResponse.Merge(m, src) +} +func (m *GetLatestProbabilitiesResponse) XXX_Size() int { + return m.Size() +} +func (m *GetLatestProbabilitiesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetLatestProbabilitiesResponse.DiscardUnknown(m) } -// SpanReaderPluginServer is the server API for SpanReaderPlugin service. -type SpanReaderPluginServer interface { - // spanstore/Reader - GetTrace(*GetTraceRequest, SpanReaderPlugin_GetTraceServer) error - GetServices(context.Context, *GetServicesRequest) (*GetServicesResponse, error) - GetOperations(context.Context, *GetOperationsRequest) (*GetOperationsResponse, error) - FindTraces(*FindTracesRequest, SpanReaderPlugin_FindTracesServer) error - FindTraceIDs(context.Context, *FindTraceIDsRequest) (*FindTraceIDsResponse, error) +var xxx_messageInfo_GetLatestProbabilitiesResponse proto.InternalMessageInfo + +func (m *GetLatestProbabilitiesResponse) GetServiceOperationProbabilities() *ServiceOperationProbabilities { + if m != nil { + return m.ServiceOperationProbabilities + } + return nil } -// UnimplementedSpanReaderPluginServer can be embedded to have forward compatible implementations. -type UnimplementedSpanReaderPluginServer struct { +// empty; extensible in the future +type CapabilitiesRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (*UnimplementedSpanReaderPluginServer) GetTrace(req *GetTraceRequest, srv SpanReaderPlugin_GetTraceServer) error { - return status.Errorf(codes.Unimplemented, "method GetTrace not implemented") +func (m *CapabilitiesRequest) Reset() { *m = CapabilitiesRequest{} } +func (m *CapabilitiesRequest) String() string { return proto.CompactTextString(m) } +func (*CapabilitiesRequest) ProtoMessage() {} +func (*CapabilitiesRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{29} } -func (*UnimplementedSpanReaderPluginServer) GetServices(ctx context.Context, req *GetServicesRequest) (*GetServicesResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetServices not implemented") +func (m *CapabilitiesRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } -func (*UnimplementedSpanReaderPluginServer) GetOperations(ctx context.Context, req *GetOperationsRequest) (*GetOperationsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetOperations not implemented") +func (m *CapabilitiesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CapabilitiesRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } } -func (*UnimplementedSpanReaderPluginServer) FindTraces(req *FindTracesRequest, srv SpanReaderPlugin_FindTracesServer) error { - return status.Errorf(codes.Unimplemented, "method FindTraces not implemented") +func (m *CapabilitiesRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_CapabilitiesRequest.Merge(m, src) } -func (*UnimplementedSpanReaderPluginServer) FindTraceIDs(ctx context.Context, req *FindTraceIDsRequest) (*FindTraceIDsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method FindTraceIDs not implemented") +func (m *CapabilitiesRequest) XXX_Size() int { + return m.Size() +} +func (m *CapabilitiesRequest) XXX_DiscardUnknown() { + xxx_messageInfo_CapabilitiesRequest.DiscardUnknown(m) } -func RegisterSpanReaderPluginServer(s *grpc.Server, srv SpanReaderPluginServer) { - s.RegisterService(&_SpanReaderPlugin_serviceDesc, srv) +var xxx_messageInfo_CapabilitiesRequest proto.InternalMessageInfo + +type CapabilitiesResponse struct { + ArchiveSpanReader bool `protobuf:"varint,1,opt,name=archiveSpanReader,proto3" json:"archiveSpanReader,omitempty"` + ArchiveSpanWriter bool `protobuf:"varint,2,opt,name=archiveSpanWriter,proto3" json:"archiveSpanWriter,omitempty"` + StreamingSpanWriter bool `protobuf:"varint,3,opt,name=streamingSpanWriter,proto3" json:"streamingSpanWriter,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func _SpanReaderPlugin_GetTrace_Handler(srv interface{}, stream grpc.ServerStream) error { - m := new(GetTraceRequest) - if err := stream.RecvMsg(m); err != nil { - return err +func (m *CapabilitiesResponse) Reset() { *m = CapabilitiesResponse{} } +func (m *CapabilitiesResponse) String() string { return proto.CompactTextString(m) } +func (*CapabilitiesResponse) ProtoMessage() {} +func (*CapabilitiesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{30} +} +func (m *CapabilitiesResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CapabilitiesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CapabilitiesResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return srv.(SpanReaderPluginServer).GetTrace(m, &spanReaderPluginGetTraceServer{stream}) +} +func (m *CapabilitiesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_CapabilitiesResponse.Merge(m, src) +} +func (m *CapabilitiesResponse) XXX_Size() int { + return m.Size() +} +func (m *CapabilitiesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_CapabilitiesResponse.DiscardUnknown(m) } -type SpanReaderPlugin_GetTraceServer interface { - Send(*SpansResponseChunk) error - grpc.ServerStream +var xxx_messageInfo_CapabilitiesResponse proto.InternalMessageInfo + +func (m *CapabilitiesResponse) GetArchiveSpanReader() bool { + if m != nil { + return m.ArchiveSpanReader + } + return false } -type spanReaderPluginGetTraceServer struct { - grpc.ServerStream +func (m *CapabilitiesResponse) GetArchiveSpanWriter() bool { + if m != nil { + return m.ArchiveSpanWriter + } + return false } -func (x *spanReaderPluginGetTraceServer) Send(m *SpansResponseChunk) error { - return x.ServerStream.SendMsg(m) +func (m *CapabilitiesResponse) GetStreamingSpanWriter() bool { + if m != nil { + return m.StreamingSpanWriter + } + return false } -func _SpanReaderPlugin_GetServices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetServicesRequest) +func init() { + proto.RegisterType((*GetDependenciesRequest)(nil), "jaeger.storage.v1.GetDependenciesRequest") + proto.RegisterType((*GetDependenciesResponse)(nil), "jaeger.storage.v1.GetDependenciesResponse") + proto.RegisterType((*WriteSpanRequest)(nil), "jaeger.storage.v1.WriteSpanRequest") + proto.RegisterType((*WriteSpanResponse)(nil), "jaeger.storage.v1.WriteSpanResponse") + proto.RegisterType((*CloseWriterRequest)(nil), "jaeger.storage.v1.CloseWriterRequest") + proto.RegisterType((*CloseWriterResponse)(nil), "jaeger.storage.v1.CloseWriterResponse") + proto.RegisterType((*GetTraceRequest)(nil), "jaeger.storage.v1.GetTraceRequest") + proto.RegisterType((*GetServicesRequest)(nil), "jaeger.storage.v1.GetServicesRequest") + proto.RegisterType((*GetServicesResponse)(nil), "jaeger.storage.v1.GetServicesResponse") + proto.RegisterType((*GetOperationsRequest)(nil), "jaeger.storage.v1.GetOperationsRequest") + proto.RegisterType((*Operation)(nil), "jaeger.storage.v1.Operation") + proto.RegisterType((*GetOperationsResponse)(nil), "jaeger.storage.v1.GetOperationsResponse") + proto.RegisterType((*TraceQueryParameters)(nil), "jaeger.storage.v1.TraceQueryParameters") + proto.RegisterMapType((map[string]string)(nil), "jaeger.storage.v1.TraceQueryParameters.TagsEntry") + proto.RegisterType((*FindTracesRequest)(nil), "jaeger.storage.v1.FindTracesRequest") + proto.RegisterType((*SpansResponseChunk)(nil), "jaeger.storage.v1.SpansResponseChunk") + proto.RegisterType((*FindTraceIDsRequest)(nil), "jaeger.storage.v1.FindTraceIDsRequest") + proto.RegisterType((*FindTraceIDsResponse)(nil), "jaeger.storage.v1.FindTraceIDsResponse") + proto.RegisterType((*Throughput)(nil), "jaeger.storage.v1.Throughput") + proto.RegisterType((*InsertThroughputRequest)(nil), "jaeger.storage.v1.InsertThroughputRequest") + proto.RegisterType((*InsertThroughputResponse)(nil), "jaeger.storage.v1.InsertThroughputResponse") + proto.RegisterType((*StringFloatMap)(nil), "jaeger.storage.v1.StringFloatMap") + proto.RegisterMapType((map[string]float64)(nil), "jaeger.storage.v1.StringFloatMap.StringFloatMapEntry") + proto.RegisterType((*ServiceOperationProbabilities)(nil), "jaeger.storage.v1.ServiceOperationProbabilities") + proto.RegisterMapType((map[string]*StringFloatMap)(nil), "jaeger.storage.v1.ServiceOperationProbabilities.ServiceOperationProbabilitiesEntry") + proto.RegisterType((*ServiceOperationQPS)(nil), "jaeger.storage.v1.ServiceOperationQPS") + proto.RegisterMapType((map[string]*StringFloatMap)(nil), "jaeger.storage.v1.ServiceOperationQPS.ServiceOperationQPSEntry") + proto.RegisterType((*InsertProbabilitiesAndQPSRequest)(nil), "jaeger.storage.v1.InsertProbabilitiesAndQPSRequest") + proto.RegisterType((*InsertProbabilitiesAndQPSResponse)(nil), "jaeger.storage.v1.InsertProbabilitiesAndQPSResponse") + proto.RegisterType((*GetThroughputRequest)(nil), "jaeger.storage.v1.GetThroughputRequest") + proto.RegisterType((*GetThroughputResponse)(nil), "jaeger.storage.v1.GetThroughputResponse") + proto.RegisterType((*GetLatestProbabilitiesRequest)(nil), "jaeger.storage.v1.GetLatestProbabilitiesRequest") + proto.RegisterType((*GetLatestProbabilitiesResponse)(nil), "jaeger.storage.v1.GetLatestProbabilitiesResponse") + proto.RegisterType((*CapabilitiesRequest)(nil), "jaeger.storage.v1.CapabilitiesRequest") + proto.RegisterType((*CapabilitiesResponse)(nil), "jaeger.storage.v1.CapabilitiesResponse") +} + +func init() { proto.RegisterFile("storage.proto", fileDescriptor_0d2c4ccf1453ffdb) } + +var fileDescriptor_0d2c4ccf1453ffdb = []byte{ + // 1561 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcf, 0x6f, 0x1b, 0xc5, + 0x17, 0xff, 0x6e, 0x9c, 0x34, 0xf6, 0x4b, 0xd2, 0x26, 0x63, 0xf7, 0x5b, 0x77, 0x69, 0x7e, 0x74, + 0xdb, 0x26, 0xe1, 0x97, 0x93, 0xb8, 0xa0, 0x56, 0x50, 0x54, 0xf2, 0xa3, 0x8d, 0x02, 0x2d, 0x24, + 0xeb, 0x28, 0x45, 0x94, 0xd6, 0x9a, 0xc4, 0xc3, 0x7a, 0x89, 0xbd, 0xbb, 0xd9, 0x9d, 0xb5, 0x12, + 0xa1, 0x4a, 0x1c, 0x10, 0x67, 0x8e, 0x45, 0x42, 0x9c, 0x90, 0xb8, 0x22, 0xfe, 0x04, 0x4e, 0x3d, + 0xf6, 0xcc, 0xa1, 0xa0, 0x5c, 0x91, 0xb8, 0xc0, 0x1f, 0x80, 0x76, 0x66, 0x76, 0xbd, 0xbf, 0x6c, + 0x27, 0x69, 0x0e, 0xdc, 0x76, 0xde, 0xbc, 0xf7, 0x79, 0x3f, 0xe7, 0xcd, 0xbc, 0x85, 0x11, 0x87, + 0x9a, 0x36, 0xd6, 0x48, 0xc9, 0xb2, 0x4d, 0x6a, 0xa2, 0xb1, 0x2f, 0x30, 0xd1, 0x88, 0x5d, 0xf2, + 0xa9, 0xad, 0x05, 0xb9, 0xa0, 0x99, 0x9a, 0xc9, 0x76, 0xe7, 0xbc, 0x2f, 0xce, 0x28, 0x4f, 0x6a, + 0xa6, 0xa9, 0x35, 0xc8, 0x1c, 0x5b, 0x6d, 0xbb, 0x9f, 0xcf, 0x51, 0xbd, 0x49, 0x1c, 0x8a, 0x9b, + 0x96, 0x60, 0x98, 0x88, 0x33, 0xd4, 0x5c, 0x1b, 0x53, 0xdd, 0x34, 0xc4, 0xfe, 0x50, 0xd3, 0xac, + 0x91, 0x06, 0x5f, 0x28, 0x3f, 0x48, 0xf0, 0xff, 0x55, 0x42, 0x57, 0x88, 0x45, 0x8c, 0x1a, 0x31, + 0x76, 0x74, 0xe2, 0xa8, 0x64, 0xcf, 0x25, 0x0e, 0x45, 0xcb, 0x00, 0x0e, 0xc5, 0x36, 0xad, 0x7a, + 0x0a, 0x8a, 0xd2, 0x94, 0x34, 0x3b, 0x54, 0x96, 0x4b, 0x1c, 0xbc, 0xe4, 0x83, 0x97, 0x36, 0x7d, + 0xed, 0x4b, 0xd9, 0x67, 0x2f, 0x26, 0xff, 0xf7, 0xed, 0xef, 0x93, 0x92, 0x9a, 0x63, 0x72, 0xde, + 0x0e, 0xba, 0x0d, 0x59, 0x62, 0xd4, 0x38, 0x44, 0xdf, 0x31, 0x20, 0x06, 0x89, 0x51, 0xf3, 0xe8, + 0xca, 0x36, 0x5c, 0x48, 0xd8, 0xe7, 0x58, 0xa6, 0xe1, 0x10, 0xb4, 0x0a, 0xc3, 0xb5, 0x10, 0xbd, + 0x28, 0x4d, 0x65, 0x66, 0x87, 0xca, 0xe3, 0x25, 0x11, 0x49, 0x6c, 0xe9, 0xd5, 0x56, 0xb9, 0x14, + 0x88, 0x1e, 0xdc, 0xd3, 0x8d, 0xdd, 0xa5, 0x7e, 0x4f, 0x85, 0x1a, 0x11, 0x54, 0xde, 0x85, 0xd1, + 0x07, 0xb6, 0x4e, 0x49, 0xc5, 0xc2, 0x86, 0xef, 0xfd, 0x0c, 0xf4, 0x3b, 0x16, 0x36, 0x84, 0xdf, + 0xf9, 0x18, 0x28, 0xe3, 0x64, 0x0c, 0x4a, 0x1e, 0xc6, 0x42, 0xc2, 0xdc, 0x34, 0xa5, 0x00, 0x68, + 0xb9, 0x61, 0x3a, 0x84, 0xed, 0xd8, 0x02, 0x53, 0x39, 0x0f, 0xf9, 0x08, 0x55, 0x30, 0xff, 0x23, + 0xc1, 0xb9, 0x55, 0x42, 0x37, 0x6d, 0xbc, 0x43, 0x7c, 0xf5, 0x0f, 0x21, 0x4b, 0xbd, 0x75, 0x55, + 0xaf, 0x31, 0x13, 0x86, 0x97, 0xde, 0xf7, 0x0c, 0xff, 0xed, 0xc5, 0xe4, 0x9b, 0x9a, 0x4e, 0xeb, + 0xee, 0x76, 0x69, 0xc7, 0x6c, 0xce, 0x71, 0xa3, 0x3c, 0x46, 0xdd, 0xd0, 0xc4, 0x6a, 0x8e, 0xa7, + 0x97, 0xa1, 0xad, 0xad, 0x1c, 0xbe, 0x98, 0x1c, 0x14, 0x9f, 0xea, 0x20, 0x43, 0x5c, 0xab, 0xc5, + 0x32, 0xdb, 0xf7, 0xf2, 0x99, 0xcd, 0x9c, 0x24, 0xb3, 0x05, 0x40, 0xab, 0x84, 0x56, 0x88, 0xdd, + 0xd2, 0x77, 0x82, 0xaa, 0x53, 0x16, 0x20, 0x1f, 0xa1, 0x8a, 0x5c, 0xcb, 0x90, 0x75, 0x04, 0x8d, + 0xe5, 0x39, 0xa7, 0x06, 0x6b, 0xe5, 0x3e, 0x14, 0x56, 0x09, 0xfd, 0xd8, 0x22, 0xbc, 0xcc, 0x83, + 0x02, 0x2e, 0xc2, 0xa0, 0xe0, 0x61, 0x21, 0xcc, 0xa9, 0xfe, 0x12, 0xbd, 0x02, 0x39, 0x2f, 0x77, + 0xd5, 0x5d, 0xdd, 0xa8, 0x31, 0xff, 0x3d, 0x38, 0x0b, 0x1b, 0x1f, 0xea, 0x46, 0x4d, 0xb9, 0x05, + 0xb9, 0x00, 0x0b, 0x21, 0xe8, 0x37, 0x70, 0xd3, 0x07, 0x60, 0xdf, 0xdd, 0xa5, 0x9f, 0xc0, 0xf9, + 0x98, 0x31, 0xc2, 0x83, 0x69, 0x38, 0x6b, 0xfa, 0xd4, 0x8f, 0x70, 0x33, 0xf0, 0x23, 0x46, 0x45, + 0xb7, 0x00, 0x02, 0x8a, 0x53, 0xec, 0x63, 0x35, 0x7d, 0xa9, 0x94, 0xe8, 0x0e, 0xa5, 0x40, 0x85, + 0x1a, 0xe2, 0x57, 0x7e, 0xea, 0x87, 0x02, 0xcb, 0xf7, 0x86, 0x4b, 0xec, 0x83, 0x75, 0x6c, 0xe3, + 0x26, 0xa1, 0xc4, 0x76, 0xd0, 0x65, 0x18, 0x16, 0xde, 0x57, 0x43, 0x0e, 0x0d, 0x09, 0x9a, 0xa7, + 0x1a, 0x5d, 0x0b, 0x59, 0xc8, 0x99, 0xb8, 0x73, 0x23, 0x11, 0x0b, 0xd1, 0x1d, 0xe8, 0xa7, 0x58, + 0x73, 0x8a, 0x19, 0x66, 0xda, 0x42, 0x8a, 0x69, 0x69, 0x06, 0x94, 0x36, 0xb1, 0xe6, 0xdc, 0x31, + 0xa8, 0x7d, 0xa0, 0x32, 0x71, 0xf4, 0x01, 0x9c, 0x6d, 0x17, 0x61, 0xb5, 0xa9, 0x1b, 0xc5, 0xfe, + 0x63, 0x54, 0xd1, 0x70, 0x50, 0x88, 0xf7, 0x75, 0x23, 0x8e, 0x85, 0xf7, 0x8b, 0x03, 0x27, 0xc3, + 0xc2, 0xfb, 0xe8, 0x2e, 0x0c, 0xfb, 0x0d, 0x93, 0x59, 0x75, 0x86, 0x21, 0x5d, 0x4c, 0x20, 0xad, + 0x08, 0x26, 0x0e, 0xf4, 0xd4, 0x03, 0x1a, 0xf2, 0x05, 0x3d, 0x9b, 0x22, 0x38, 0x78, 0xbf, 0x38, + 0x78, 0x12, 0x1c, 0xbc, 0x8f, 0xc6, 0x01, 0x0c, 0xb7, 0x59, 0x65, 0x67, 0xd7, 0x29, 0x66, 0xa7, + 0xa4, 0xd9, 0x01, 0x35, 0x67, 0xb8, 0x4d, 0x16, 0x64, 0x47, 0xbe, 0x01, 0xb9, 0x20, 0xb2, 0x68, + 0x14, 0x32, 0xbb, 0xe4, 0x40, 0xe4, 0xd6, 0xfb, 0x44, 0x05, 0x18, 0x68, 0xe1, 0x86, 0xeb, 0xa7, + 0x92, 0x2f, 0xde, 0xe9, 0xbb, 0x29, 0x29, 0x2a, 0x8c, 0xdd, 0xd5, 0x8d, 0x1a, 0x87, 0xf1, 0x8f, + 0xcc, 0x7b, 0x30, 0xb0, 0xe7, 0xe5, 0x4d, 0xb4, 0xbd, 0x99, 0x23, 0x26, 0x57, 0xe5, 0x52, 0xca, + 0x1d, 0x40, 0x5e, 0x1b, 0x0c, 0x8a, 0x7e, 0xb9, 0xee, 0x1a, 0xbb, 0x68, 0x0e, 0x06, 0xbc, 0xe3, + 0xe1, 0x37, 0xe8, 0xb4, 0x5e, 0x2a, 0xda, 0x32, 0xe7, 0x53, 0x36, 0x21, 0x1f, 0x98, 0xb6, 0xb6, + 0x72, 0x5a, 0xc6, 0xb5, 0xa0, 0x10, 0x45, 0x15, 0x07, 0xf3, 0x31, 0xe4, 0xfc, 0x56, 0xcb, 0x4d, + 0x1c, 0x5e, 0x5a, 0x3c, 0x69, 0xaf, 0xcd, 0x06, 0xe8, 0x59, 0xd1, 0x6c, 0x1d, 0xe5, 0x2b, 0x09, + 0x60, 0xb3, 0x6e, 0x9b, 0xae, 0x56, 0xb7, 0x5c, 0xd6, 0x95, 0x2a, 0xd1, 0xae, 0x24, 0x96, 0xe8, + 0x52, 0xa8, 0xf1, 0x88, 0x7c, 0x85, 0x3a, 0x51, 0x01, 0x06, 0x96, 0x4d, 0xd7, 0xa0, 0xac, 0xd9, + 0x66, 0x54, 0xbe, 0x40, 0x57, 0x61, 0x64, 0xdd, 0x36, 0xb7, 0xf1, 0xb6, 0xde, 0xd0, 0xa9, 0x77, + 0x09, 0xf6, 0x4f, 0x65, 0x66, 0x25, 0x35, 0x4a, 0x54, 0x3e, 0x81, 0x0b, 0x6b, 0x86, 0x43, 0x6c, + 0xda, 0xb6, 0xa3, 0x1d, 0x54, 0xa0, 0x01, 0x31, 0x7e, 0x85, 0x86, 0x23, 0xdb, 0x96, 0x0c, 0x09, + 0x28, 0x32, 0x14, 0x93, 0xc8, 0xe2, 0x5e, 0xfb, 0x45, 0x82, 0xb3, 0x15, 0x6a, 0xeb, 0x86, 0x76, + 0xb7, 0x61, 0x62, 0x7a, 0x1f, 0x5b, 0xe8, 0x91, 0x77, 0x50, 0xc3, 0x14, 0xa1, 0xf1, 0xed, 0x14, + 0x8d, 0x51, 0xd1, 0xd8, 0x92, 0x77, 0x92, 0x18, 0x98, 0xbc, 0x08, 0xf9, 0x14, 0xb6, 0x5e, 0xc7, + 0x42, 0x0a, 0x1f, 0x8b, 0x9f, 0xfb, 0x60, 0x5c, 0x24, 0x24, 0x88, 0x7d, 0x24, 0x98, 0xe8, 0x3b, + 0x09, 0xc6, 0x9d, 0x6e, 0x1c, 0xc2, 0xa7, 0x4a, 0x9a, 0x4f, 0xdd, 0xe4, 0xba, 0xef, 0x72, 0x8f, + 0xbb, 0x6b, 0x96, 0x1d, 0x50, 0x7a, 0x83, 0xa4, 0xc4, 0xe3, 0x46, 0x38, 0x1e, 0x43, 0xe5, 0xcb, + 0x3d, 0xd3, 0x11, 0x0e, 0xd9, 0xdf, 0x12, 0xe4, 0xe3, 0x5a, 0x37, 0xd6, 0x2b, 0x68, 0x0f, 0xf2, + 0x4e, 0x92, 0x2c, 0xa2, 0x73, 0xfb, 0x08, 0xd1, 0xd9, 0x58, 0xaf, 0xa4, 0xd1, 0x78, 0x24, 0xd2, + 0xb0, 0x65, 0x1d, 0x8a, 0x9d, 0x04, 0x4e, 0xdb, 0xeb, 0xe7, 0x12, 0x4c, 0xf1, 0xd2, 0x8f, 0x44, + 0x78, 0xd1, 0xa8, 0x6d, 0xac, 0x57, 0xfc, 0xd3, 0x25, 0x43, 0xb6, 0x6e, 0x3a, 0x34, 0x74, 0xe3, + 0x06, 0x6b, 0xb4, 0x05, 0x23, 0x56, 0xa4, 0x6c, 0xb8, 0x15, 0xf3, 0xc7, 0x2d, 0x1b, 0x35, 0x0a, + 0x83, 0x6e, 0x42, 0x66, 0xcf, 0x72, 0xc4, 0x9b, 0x6c, 0xfa, 0x68, 0x61, 0x56, 0x3d, 0x11, 0xe5, + 0x0a, 0x5c, 0xee, 0xe2, 0x91, 0x38, 0xd5, 0xdf, 0x4b, 0xec, 0xb9, 0x95, 0xec, 0x24, 0xff, 0x8d, + 0x79, 0x61, 0x8b, 0xbd, 0xbf, 0x92, 0xdd, 0xe8, 0x65, 0x1b, 0xdd, 0x24, 0x8c, 0xaf, 0x12, 0x7a, + 0x0f, 0x53, 0xe2, 0x44, 0xc3, 0xe3, 0x3f, 0x5c, 0x9f, 0x4a, 0x30, 0xd1, 0x89, 0x43, 0x98, 0xd0, + 0xea, 0xdd, 0x38, 0x4e, 0x56, 0x01, 0xdd, 0x61, 0xd9, 0xdc, 0x81, 0xad, 0x84, 0xc5, 0x3f, 0x4a, + 0x50, 0x88, 0xd2, 0x85, 0x9d, 0x6f, 0xc0, 0x18, 0xb6, 0x77, 0xea, 0x7a, 0x4b, 0x0c, 0x35, 0xb8, + 0x46, 0x6c, 0x66, 0x5b, 0x56, 0x4d, 0x6e, 0xc4, 0xb8, 0xf9, 0x6c, 0xc3, 0x72, 0x17, 0xe5, 0xe6, + 0x1b, 0x68, 0x1e, 0xf2, 0x0e, 0xb5, 0x09, 0x6e, 0xea, 0x86, 0x16, 0xe2, 0xcf, 0x30, 0xfe, 0xb4, + 0xad, 0xf2, 0xaf, 0x12, 0x8c, 0xb6, 0x97, 0xeb, 0x0d, 0x57, 0xd3, 0x0d, 0xb4, 0x05, 0xb9, 0x60, + 0xea, 0x42, 0x57, 0x52, 0x02, 0x16, 0x1f, 0xe8, 0xe4, 0xab, 0xdd, 0x99, 0x84, 0xeb, 0x5b, 0x30, + 0xc0, 0x46, 0x34, 0x74, 0x2d, 0x85, 0x3d, 0x39, 0xd2, 0xc9, 0xd3, 0xbd, 0xd8, 0x38, 0x6e, 0xf9, + 0x4b, 0xb8, 0x58, 0x49, 0xfa, 0x26, 0x9c, 0x79, 0x0c, 0xe7, 0x02, 0x4b, 0x38, 0xd7, 0x29, 0xba, + 0x34, 0x2b, 0x95, 0xff, 0xcc, 0xf0, 0x08, 0xf2, 0x84, 0x09, 0xa5, 0x0f, 0x20, 0xeb, 0x0f, 0x9d, + 0x48, 0x49, 0x01, 0x8a, 0x4d, 0xa4, 0x72, 0x5a, 0x40, 0x92, 0x8f, 0xbd, 0x79, 0x09, 0x7d, 0x06, + 0x43, 0xa1, 0x09, 0x2e, 0x35, 0x90, 0xc9, 0xb9, 0x2f, 0x35, 0x90, 0x69, 0x83, 0xe0, 0x36, 0x8c, + 0x44, 0xe6, 0x2b, 0x34, 0x93, 0x2e, 0x98, 0x18, 0x07, 0xe5, 0xd9, 0xde, 0x8c, 0x42, 0xc7, 0x43, + 0x80, 0xf6, 0xd3, 0x18, 0xa5, 0x45, 0x39, 0xf1, 0x72, 0x3e, 0x7a, 0x78, 0xaa, 0x30, 0x1c, 0x7e, + 0x86, 0xa2, 0xe9, 0x6e, 0xf0, 0xed, 0xd7, 0xaf, 0x3c, 0xd3, 0x93, 0x4f, 0x94, 0xda, 0x3e, 0x5c, + 0x58, 0x8c, 0x1f, 0x3b, 0x91, 0xf3, 0x47, 0xe2, 0x47, 0x47, 0x68, 0xff, 0x14, 0x2b, 0xad, 0x7c, + 0x10, 0xd1, 0x1c, 0xa9, 0xb6, 0xc7, 0xec, 0x17, 0x87, 0xd8, 0x3d, 0xfd, 0xa2, 0x2b, 0x7f, 0x2d, + 0x41, 0x31, 0xfa, 0x93, 0x28, 0xa4, 0xbc, 0xce, 0x94, 0x87, 0xb7, 0xd1, 0xab, 0xe9, 0xca, 0x53, + 0xfe, 0x83, 0xc9, 0xaf, 0x1d, 0x85, 0x55, 0x44, 0xe0, 0xaf, 0x0c, 0xe4, 0x2b, 0xb8, 0x69, 0x35, + 0xbc, 0x63, 0x4e, 0x4d, 0x9b, 0x08, 0x0b, 0x76, 0x61, 0x34, 0xfe, 0x4c, 0x46, 0x69, 0xb8, 0x1d, + 0x5e, 0xe9, 0xf2, 0xeb, 0x47, 0xe2, 0x15, 0xe5, 0xfb, 0x8d, 0x04, 0x17, 0x3b, 0xde, 0xe3, 0xe8, + 0x7a, 0x47, 0xa8, 0xce, 0xef, 0x18, 0xf9, 0xad, 0xe3, 0x09, 0x45, 0xce, 0x6a, 0xc8, 0xe5, 0x0e, + 0x67, 0x35, 0xe9, 0xef, 0x6c, 0x6f, 0x46, 0xa1, 0xe3, 0x09, 0xfb, 0x7f, 0x99, 0x72, 0xeb, 0xa2, + 0xf9, 0x74, 0x8c, 0xce, 0x57, 0xb8, 0xbc, 0x70, 0x0c, 0x09, 0x91, 0x70, 0x17, 0x10, 0x4f, 0x71, + 0xf8, 0x22, 0xf5, 0xce, 0x78, 0x64, 0x9d, 0x7a, 0x4b, 0x24, 0x6f, 0xe4, 0xd4, 0x33, 0x9e, 0x76, + 0x43, 0x2f, 0x15, 0x9f, 0x1d, 0x4e, 0x48, 0xcf, 0x0f, 0x27, 0xa4, 0x3f, 0x0e, 0x27, 0xa4, 0x4f, + 0x41, 0xb0, 0x57, 0x5b, 0x0b, 0xdb, 0x67, 0xd8, 0x33, 0xe9, 0xfa, 0xbf, 0x01, 0x00, 0x00, 0xff, + 0xff, 0x96, 0xfe, 0xee, 0x48, 0x5f, 0x16, 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 + +// SpanWriterPluginClient is the client API for SpanWriterPlugin service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type SpanWriterPluginClient interface { + // spanstore/Writer + WriteSpan(ctx context.Context, in *WriteSpanRequest, opts ...grpc.CallOption) (*WriteSpanResponse, error) + Close(ctx context.Context, in *CloseWriterRequest, opts ...grpc.CallOption) (*CloseWriterResponse, error) +} + +type spanWriterPluginClient struct { + cc *grpc.ClientConn +} + +func NewSpanWriterPluginClient(cc *grpc.ClientConn) SpanWriterPluginClient { + return &spanWriterPluginClient{cc} +} + +func (c *spanWriterPluginClient) WriteSpan(ctx context.Context, in *WriteSpanRequest, opts ...grpc.CallOption) (*WriteSpanResponse, error) { + out := new(WriteSpanResponse) + err := c.cc.Invoke(ctx, "/jaeger.storage.v1.SpanWriterPlugin/WriteSpan", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *spanWriterPluginClient) Close(ctx context.Context, in *CloseWriterRequest, opts ...grpc.CallOption) (*CloseWriterResponse, error) { + out := new(CloseWriterResponse) + err := c.cc.Invoke(ctx, "/jaeger.storage.v1.SpanWriterPlugin/Close", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// SpanWriterPluginServer is the server API for SpanWriterPlugin service. +type SpanWriterPluginServer interface { + // spanstore/Writer + WriteSpan(context.Context, *WriteSpanRequest) (*WriteSpanResponse, error) + Close(context.Context, *CloseWriterRequest) (*CloseWriterResponse, error) +} + +// UnimplementedSpanWriterPluginServer can be embedded to have forward compatible implementations. +type UnimplementedSpanWriterPluginServer struct { +} + +func (*UnimplementedSpanWriterPluginServer) WriteSpan(ctx context.Context, req *WriteSpanRequest) (*WriteSpanResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method WriteSpan not implemented") +} +func (*UnimplementedSpanWriterPluginServer) Close(ctx context.Context, req *CloseWriterRequest) (*CloseWriterResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Close not implemented") +} + +func RegisterSpanWriterPluginServer(s *grpc.Server, srv SpanWriterPluginServer) { + s.RegisterService(&_SpanWriterPlugin_serviceDesc, srv) +} + +func _SpanWriterPlugin_WriteSpan_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(WriteSpanRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(SpanReaderPluginServer).GetServices(ctx, in) + return srv.(SpanWriterPluginServer).WriteSpan(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/jaeger.storage.v1.SpanReaderPlugin/GetServices", + FullMethod: "/jaeger.storage.v1.SpanWriterPlugin/WriteSpan", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(SpanReaderPluginServer).GetServices(ctx, req.(*GetServicesRequest)) + return srv.(SpanWriterPluginServer).WriteSpan(ctx, req.(*WriteSpanRequest)) } return interceptor(ctx, in, info, handler) } -func _SpanReaderPlugin_GetOperations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetOperationsRequest) +func _SpanWriterPlugin_Close_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CloseWriterRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(SpanReaderPluginServer).GetOperations(ctx, in) + return srv.(SpanWriterPluginServer).Close(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/jaeger.storage.v1.SpanReaderPlugin/GetOperations", + FullMethod: "/jaeger.storage.v1.SpanWriterPlugin/Close", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(SpanReaderPluginServer).GetOperations(ctx, req.(*GetOperationsRequest)) + return srv.(SpanWriterPluginServer).Close(ctx, req.(*CloseWriterRequest)) } return interceptor(ctx, in, info, handler) } -func _SpanReaderPlugin_FindTraces_Handler(srv interface{}, stream grpc.ServerStream) error { - m := new(FindTracesRequest) - if err := stream.RecvMsg(m); err != nil { - return err - } - return srv.(SpanReaderPluginServer).FindTraces(m, &spanReaderPluginFindTracesServer{stream}) -} - -type SpanReaderPlugin_FindTracesServer interface { - Send(*SpansResponseChunk) error - grpc.ServerStream -} - -type spanReaderPluginFindTracesServer struct { - grpc.ServerStream -} - -func (x *spanReaderPluginFindTracesServer) Send(m *SpansResponseChunk) error { - return x.ServerStream.SendMsg(m) -} - -func _SpanReaderPlugin_FindTraceIDs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(FindTraceIDsRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(SpanReaderPluginServer).FindTraceIDs(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/jaeger.storage.v1.SpanReaderPlugin/FindTraceIDs", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(SpanReaderPluginServer).FindTraceIDs(ctx, req.(*FindTraceIDsRequest)) - } - return interceptor(ctx, in, info, handler) -} - -var _SpanReaderPlugin_serviceDesc = grpc.ServiceDesc{ - ServiceName: "jaeger.storage.v1.SpanReaderPlugin", - HandlerType: (*SpanReaderPluginServer)(nil), +var _SpanWriterPlugin_serviceDesc = grpc.ServiceDesc{ + ServiceName: "jaeger.storage.v1.SpanWriterPlugin", + HandlerType: (*SpanWriterPluginServer)(nil), Methods: []grpc.MethodDesc{ { - MethodName: "GetServices", - Handler: _SpanReaderPlugin_GetServices_Handler, - }, - { - MethodName: "GetOperations", - Handler: _SpanReaderPlugin_GetOperations_Handler, - }, - { - MethodName: "FindTraceIDs", - Handler: _SpanReaderPlugin_FindTraceIDs_Handler, - }, - }, - Streams: []grpc.StreamDesc{ - { - StreamName: "GetTrace", - Handler: _SpanReaderPlugin_GetTrace_Handler, - ServerStreams: true, + MethodName: "WriteSpan", + Handler: _SpanWriterPlugin_WriteSpan_Handler, }, { - StreamName: "FindTraces", - Handler: _SpanReaderPlugin_FindTraces_Handler, - ServerStreams: true, + MethodName: "Close", + Handler: _SpanWriterPlugin_Close_Handler, }, }, + Streams: []grpc.StreamDesc{}, Metadata: "storage.proto", } -// ArchiveSpanWriterPluginClient is the client API for ArchiveSpanWriterPlugin service. +// StreamingSpanWriterPluginClient is the client API for StreamingSpanWriterPlugin service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. -type ArchiveSpanWriterPluginClient interface { - // spanstore/Writer - WriteArchiveSpan(ctx context.Context, in *WriteSpanRequest, opts ...grpc.CallOption) (*WriteSpanResponse, error) +type StreamingSpanWriterPluginClient interface { + WriteSpanStream(ctx context.Context, opts ...grpc.CallOption) (StreamingSpanWriterPlugin_WriteSpanStreamClient, error) } -type archiveSpanWriterPluginClient struct { +type streamingSpanWriterPluginClient struct { cc *grpc.ClientConn } -func NewArchiveSpanWriterPluginClient(cc *grpc.ClientConn) ArchiveSpanWriterPluginClient { - return &archiveSpanWriterPluginClient{cc} +func NewStreamingSpanWriterPluginClient(cc *grpc.ClientConn) StreamingSpanWriterPluginClient { + return &streamingSpanWriterPluginClient{cc} } -func (c *archiveSpanWriterPluginClient) WriteArchiveSpan(ctx context.Context, in *WriteSpanRequest, opts ...grpc.CallOption) (*WriteSpanResponse, error) { - out := new(WriteSpanResponse) - err := c.cc.Invoke(ctx, "/jaeger.storage.v1.ArchiveSpanWriterPlugin/WriteArchiveSpan", in, out, opts...) +func (c *streamingSpanWriterPluginClient) WriteSpanStream(ctx context.Context, opts ...grpc.CallOption) (StreamingSpanWriterPlugin_WriteSpanStreamClient, error) { + stream, err := c.cc.NewStream(ctx, &_StreamingSpanWriterPlugin_serviceDesc.Streams[0], "/jaeger.storage.v1.StreamingSpanWriterPlugin/WriteSpanStream", opts...) if err != nil { return nil, err } - return out, nil -} - -// ArchiveSpanWriterPluginServer is the server API for ArchiveSpanWriterPlugin service. -type ArchiveSpanWriterPluginServer interface { - // spanstore/Writer - WriteArchiveSpan(context.Context, *WriteSpanRequest) (*WriteSpanResponse, error) + x := &streamingSpanWriterPluginWriteSpanStreamClient{stream} + return x, nil } -// UnimplementedArchiveSpanWriterPluginServer can be embedded to have forward compatible implementations. -type UnimplementedArchiveSpanWriterPluginServer struct { +type StreamingSpanWriterPlugin_WriteSpanStreamClient interface { + Send(*WriteSpanRequest) error + CloseAndRecv() (*WriteSpanResponse, error) + grpc.ClientStream } -func (*UnimplementedArchiveSpanWriterPluginServer) WriteArchiveSpan(ctx context.Context, req *WriteSpanRequest) (*WriteSpanResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method WriteArchiveSpan not implemented") +type streamingSpanWriterPluginWriteSpanStreamClient struct { + grpc.ClientStream } -func RegisterArchiveSpanWriterPluginServer(s *grpc.Server, srv ArchiveSpanWriterPluginServer) { - s.RegisterService(&_ArchiveSpanWriterPlugin_serviceDesc, srv) +func (x *streamingSpanWriterPluginWriteSpanStreamClient) Send(m *WriteSpanRequest) error { + return x.ClientStream.SendMsg(m) } -func _ArchiveSpanWriterPlugin_WriteArchiveSpan_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(WriteSpanRequest) - if err := dec(in); err != nil { +func (x *streamingSpanWriterPluginWriteSpanStreamClient) CloseAndRecv() (*WriteSpanResponse, error) { + if err := x.ClientStream.CloseSend(); err != nil { return nil, err } - if interceptor == nil { - return srv.(ArchiveSpanWriterPluginServer).WriteArchiveSpan(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/jaeger.storage.v1.ArchiveSpanWriterPlugin/WriteArchiveSpan", + m := new(WriteSpanResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(ArchiveSpanWriterPluginServer).WriteArchiveSpan(ctx, req.(*WriteSpanRequest)) + return m, nil +} + +// StreamingSpanWriterPluginServer is the server API for StreamingSpanWriterPlugin service. +type StreamingSpanWriterPluginServer interface { + WriteSpanStream(StreamingSpanWriterPlugin_WriteSpanStreamServer) error +} + +// UnimplementedStreamingSpanWriterPluginServer can be embedded to have forward compatible implementations. +type UnimplementedStreamingSpanWriterPluginServer struct { +} + +func (*UnimplementedStreamingSpanWriterPluginServer) WriteSpanStream(srv StreamingSpanWriterPlugin_WriteSpanStreamServer) error { + return status.Errorf(codes.Unimplemented, "method WriteSpanStream not implemented") +} + +func RegisterStreamingSpanWriterPluginServer(s *grpc.Server, srv StreamingSpanWriterPluginServer) { + s.RegisterService(&_StreamingSpanWriterPlugin_serviceDesc, srv) +} + +func _StreamingSpanWriterPlugin_WriteSpanStream_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(StreamingSpanWriterPluginServer).WriteSpanStream(&streamingSpanWriterPluginWriteSpanStreamServer{stream}) +} + +type StreamingSpanWriterPlugin_WriteSpanStreamServer interface { + SendAndClose(*WriteSpanResponse) error + Recv() (*WriteSpanRequest, error) + grpc.ServerStream +} + +type streamingSpanWriterPluginWriteSpanStreamServer struct { + grpc.ServerStream +} + +func (x *streamingSpanWriterPluginWriteSpanStreamServer) SendAndClose(m *WriteSpanResponse) error { + return x.ServerStream.SendMsg(m) +} + +func (x *streamingSpanWriterPluginWriteSpanStreamServer) Recv() (*WriteSpanRequest, error) { + m := new(WriteSpanRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err } - return interceptor(ctx, in, info, handler) + return m, nil } -var _ArchiveSpanWriterPlugin_serviceDesc = grpc.ServiceDesc{ - ServiceName: "jaeger.storage.v1.ArchiveSpanWriterPlugin", - HandlerType: (*ArchiveSpanWriterPluginServer)(nil), - Methods: []grpc.MethodDesc{ +var _StreamingSpanWriterPlugin_serviceDesc = grpc.ServiceDesc{ + ServiceName: "jaeger.storage.v1.StreamingSpanWriterPlugin", + HandlerType: (*StreamingSpanWriterPluginServer)(nil), + Methods: []grpc.MethodDesc{}, + Streams: []grpc.StreamDesc{ { - MethodName: "WriteArchiveSpan", - Handler: _ArchiveSpanWriterPlugin_WriteArchiveSpan_Handler, + StreamName: "WriteSpanStream", + Handler: _StreamingSpanWriterPlugin_WriteSpanStream_Handler, + ClientStreams: true, }, }, - Streams: []grpc.StreamDesc{}, Metadata: "storage.proto", } -// ArchiveSpanReaderPluginClient is the client API for ArchiveSpanReaderPlugin service. +// SpanReaderPluginClient is the client API for SpanReaderPlugin service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. -type ArchiveSpanReaderPluginClient interface { +type SpanReaderPluginClient interface { // spanstore/Reader - GetArchiveTrace(ctx context.Context, in *GetTraceRequest, opts ...grpc.CallOption) (ArchiveSpanReaderPlugin_GetArchiveTraceClient, error) + GetTrace(ctx context.Context, in *GetTraceRequest, opts ...grpc.CallOption) (SpanReaderPlugin_GetTraceClient, error) + GetServices(ctx context.Context, in *GetServicesRequest, opts ...grpc.CallOption) (*GetServicesResponse, error) + GetOperations(ctx context.Context, in *GetOperationsRequest, opts ...grpc.CallOption) (*GetOperationsResponse, error) + FindTraces(ctx context.Context, in *FindTracesRequest, opts ...grpc.CallOption) (SpanReaderPlugin_FindTracesClient, error) + FindTraceIDs(ctx context.Context, in *FindTraceIDsRequest, opts ...grpc.CallOption) (*FindTraceIDsResponse, error) } -type archiveSpanReaderPluginClient struct { +type spanReaderPluginClient struct { cc *grpc.ClientConn } -func NewArchiveSpanReaderPluginClient(cc *grpc.ClientConn) ArchiveSpanReaderPluginClient { - return &archiveSpanReaderPluginClient{cc} +func NewSpanReaderPluginClient(cc *grpc.ClientConn) SpanReaderPluginClient { + return &spanReaderPluginClient{cc} } -func (c *archiveSpanReaderPluginClient) GetArchiveTrace(ctx context.Context, in *GetTraceRequest, opts ...grpc.CallOption) (ArchiveSpanReaderPlugin_GetArchiveTraceClient, error) { - stream, err := c.cc.NewStream(ctx, &_ArchiveSpanReaderPlugin_serviceDesc.Streams[0], "/jaeger.storage.v1.ArchiveSpanReaderPlugin/GetArchiveTrace", opts...) +func (c *spanReaderPluginClient) GetTrace(ctx context.Context, in *GetTraceRequest, opts ...grpc.CallOption) (SpanReaderPlugin_GetTraceClient, error) { + stream, err := c.cc.NewStream(ctx, &_SpanReaderPlugin_serviceDesc.Streams[0], "/jaeger.storage.v1.SpanReaderPlugin/GetTrace", opts...) if err != nil { return nil, err } - x := &archiveSpanReaderPluginGetArchiveTraceClient{stream} + x := &spanReaderPluginGetTraceClient{stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -1698,16 +1986,16 @@ func (c *archiveSpanReaderPluginClient) GetArchiveTrace(ctx context.Context, in return x, nil } -type ArchiveSpanReaderPlugin_GetArchiveTraceClient interface { +type SpanReaderPlugin_GetTraceClient interface { Recv() (*SpansResponseChunk, error) grpc.ClientStream } -type archiveSpanReaderPluginGetArchiveTraceClient struct { +type spanReaderPluginGetTraceClient struct { grpc.ClientStream } -func (x *archiveSpanReaderPluginGetArchiveTraceClient) Recv() (*SpansResponseChunk, error) { +func (x *spanReaderPluginGetTraceClient) Recv() (*SpansResponseChunk, error) { m := new(SpansResponseChunk) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err @@ -1715,755 +2003,729 @@ func (x *archiveSpanReaderPluginGetArchiveTraceClient) Recv() (*SpansResponseChu return m, nil } -// ArchiveSpanReaderPluginServer is the server API for ArchiveSpanReaderPlugin service. -type ArchiveSpanReaderPluginServer interface { - // spanstore/Reader - GetArchiveTrace(*GetTraceRequest, ArchiveSpanReaderPlugin_GetArchiveTraceServer) error +func (c *spanReaderPluginClient) GetServices(ctx context.Context, in *GetServicesRequest, opts ...grpc.CallOption) (*GetServicesResponse, error) { + out := new(GetServicesResponse) + err := c.cc.Invoke(ctx, "/jaeger.storage.v1.SpanReaderPlugin/GetServices", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -// UnimplementedArchiveSpanReaderPluginServer can be embedded to have forward compatible implementations. -type UnimplementedArchiveSpanReaderPluginServer struct { +func (c *spanReaderPluginClient) GetOperations(ctx context.Context, in *GetOperationsRequest, opts ...grpc.CallOption) (*GetOperationsResponse, error) { + out := new(GetOperationsResponse) + err := c.cc.Invoke(ctx, "/jaeger.storage.v1.SpanReaderPlugin/GetOperations", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (*UnimplementedArchiveSpanReaderPluginServer) GetArchiveTrace(req *GetTraceRequest, srv ArchiveSpanReaderPlugin_GetArchiveTraceServer) error { - return status.Errorf(codes.Unimplemented, "method GetArchiveTrace not implemented") +func (c *spanReaderPluginClient) FindTraces(ctx context.Context, in *FindTracesRequest, opts ...grpc.CallOption) (SpanReaderPlugin_FindTracesClient, error) { + stream, err := c.cc.NewStream(ctx, &_SpanReaderPlugin_serviceDesc.Streams[1], "/jaeger.storage.v1.SpanReaderPlugin/FindTraces", opts...) + if err != nil { + return nil, err + } + x := &spanReaderPluginFindTracesClient{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 } -func RegisterArchiveSpanReaderPluginServer(s *grpc.Server, srv ArchiveSpanReaderPluginServer) { - s.RegisterService(&_ArchiveSpanReaderPlugin_serviceDesc, srv) +type SpanReaderPlugin_FindTracesClient interface { + Recv() (*SpansResponseChunk, error) + grpc.ClientStream } -func _ArchiveSpanReaderPlugin_GetArchiveTrace_Handler(srv interface{}, stream grpc.ServerStream) error { - m := new(GetTraceRequest) - if err := stream.RecvMsg(m); err != nil { - return err +type spanReaderPluginFindTracesClient struct { + grpc.ClientStream +} + +func (x *spanReaderPluginFindTracesClient) Recv() (*SpansResponseChunk, error) { + m := new(SpansResponseChunk) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err } - return srv.(ArchiveSpanReaderPluginServer).GetArchiveTrace(m, &archiveSpanReaderPluginGetArchiveTraceServer{stream}) + return m, nil } -type ArchiveSpanReaderPlugin_GetArchiveTraceServer interface { - Send(*SpansResponseChunk) error - grpc.ServerStream +func (c *spanReaderPluginClient) FindTraceIDs(ctx context.Context, in *FindTraceIDsRequest, opts ...grpc.CallOption) (*FindTraceIDsResponse, error) { + out := new(FindTraceIDsResponse) + err := c.cc.Invoke(ctx, "/jaeger.storage.v1.SpanReaderPlugin/FindTraceIDs", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -type archiveSpanReaderPluginGetArchiveTraceServer struct { - grpc.ServerStream +// SpanReaderPluginServer is the server API for SpanReaderPlugin service. +type SpanReaderPluginServer interface { + // spanstore/Reader + GetTrace(*GetTraceRequest, SpanReaderPlugin_GetTraceServer) error + GetServices(context.Context, *GetServicesRequest) (*GetServicesResponse, error) + GetOperations(context.Context, *GetOperationsRequest) (*GetOperationsResponse, error) + FindTraces(*FindTracesRequest, SpanReaderPlugin_FindTracesServer) error + FindTraceIDs(context.Context, *FindTraceIDsRequest) (*FindTraceIDsResponse, error) } -func (x *archiveSpanReaderPluginGetArchiveTraceServer) Send(m *SpansResponseChunk) error { - return x.ServerStream.SendMsg(m) +// UnimplementedSpanReaderPluginServer can be embedded to have forward compatible implementations. +type UnimplementedSpanReaderPluginServer struct { } -var _ArchiveSpanReaderPlugin_serviceDesc = grpc.ServiceDesc{ - ServiceName: "jaeger.storage.v1.ArchiveSpanReaderPlugin", - HandlerType: (*ArchiveSpanReaderPluginServer)(nil), - Methods: []grpc.MethodDesc{}, - Streams: []grpc.StreamDesc{ - { - StreamName: "GetArchiveTrace", - Handler: _ArchiveSpanReaderPlugin_GetArchiveTrace_Handler, - ServerStreams: true, - }, - }, - Metadata: "storage.proto", +func (*UnimplementedSpanReaderPluginServer) GetTrace(req *GetTraceRequest, srv SpanReaderPlugin_GetTraceServer) error { + return status.Errorf(codes.Unimplemented, "method GetTrace not implemented") +} +func (*UnimplementedSpanReaderPluginServer) GetServices(ctx context.Context, req *GetServicesRequest) (*GetServicesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetServices not implemented") +} +func (*UnimplementedSpanReaderPluginServer) GetOperations(ctx context.Context, req *GetOperationsRequest) (*GetOperationsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetOperations not implemented") +} +func (*UnimplementedSpanReaderPluginServer) FindTraces(req *FindTracesRequest, srv SpanReaderPlugin_FindTracesServer) error { + return status.Errorf(codes.Unimplemented, "method FindTraces not implemented") +} +func (*UnimplementedSpanReaderPluginServer) FindTraceIDs(ctx context.Context, req *FindTraceIDsRequest) (*FindTraceIDsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method FindTraceIDs not implemented") } -// DependenciesReaderPluginClient is the client API for DependenciesReaderPlugin service. -// -// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. -type DependenciesReaderPluginClient interface { - // dependencystore/Reader - GetDependencies(ctx context.Context, in *GetDependenciesRequest, opts ...grpc.CallOption) (*GetDependenciesResponse, error) +func RegisterSpanReaderPluginServer(s *grpc.Server, srv SpanReaderPluginServer) { + s.RegisterService(&_SpanReaderPlugin_serviceDesc, srv) } -type dependenciesReaderPluginClient struct { - cc *grpc.ClientConn +func _SpanReaderPlugin_GetTrace_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(GetTraceRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(SpanReaderPluginServer).GetTrace(m, &spanReaderPluginGetTraceServer{stream}) } -func NewDependenciesReaderPluginClient(cc *grpc.ClientConn) DependenciesReaderPluginClient { - return &dependenciesReaderPluginClient{cc} +type SpanReaderPlugin_GetTraceServer interface { + Send(*SpansResponseChunk) error + grpc.ServerStream } -func (c *dependenciesReaderPluginClient) GetDependencies(ctx context.Context, in *GetDependenciesRequest, opts ...grpc.CallOption) (*GetDependenciesResponse, error) { - out := new(GetDependenciesResponse) - err := c.cc.Invoke(ctx, "/jaeger.storage.v1.DependenciesReaderPlugin/GetDependencies", in, out, opts...) - if err != nil { +type spanReaderPluginGetTraceServer struct { + grpc.ServerStream +} + +func (x *spanReaderPluginGetTraceServer) Send(m *SpansResponseChunk) error { + return x.ServerStream.SendMsg(m) +} + +func _SpanReaderPlugin_GetServices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetServicesRequest) + if err := dec(in); err != nil { return nil, err } - return out, nil + if interceptor == nil { + return srv.(SpanReaderPluginServer).GetServices(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/jaeger.storage.v1.SpanReaderPlugin/GetServices", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SpanReaderPluginServer).GetServices(ctx, req.(*GetServicesRequest)) + } + return interceptor(ctx, in, info, handler) } -// DependenciesReaderPluginServer is the server API for DependenciesReaderPlugin service. -type DependenciesReaderPluginServer interface { - // dependencystore/Reader - GetDependencies(context.Context, *GetDependenciesRequest) (*GetDependenciesResponse, error) +func _SpanReaderPlugin_GetOperations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetOperationsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SpanReaderPluginServer).GetOperations(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/jaeger.storage.v1.SpanReaderPlugin/GetOperations", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SpanReaderPluginServer).GetOperations(ctx, req.(*GetOperationsRequest)) + } + return interceptor(ctx, in, info, handler) } -// UnimplementedDependenciesReaderPluginServer can be embedded to have forward compatible implementations. -type UnimplementedDependenciesReaderPluginServer struct { +func _SpanReaderPlugin_FindTraces_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(FindTracesRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(SpanReaderPluginServer).FindTraces(m, &spanReaderPluginFindTracesServer{stream}) } -func (*UnimplementedDependenciesReaderPluginServer) GetDependencies(ctx context.Context, req *GetDependenciesRequest) (*GetDependenciesResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetDependencies not implemented") +type SpanReaderPlugin_FindTracesServer interface { + Send(*SpansResponseChunk) error + grpc.ServerStream } -func RegisterDependenciesReaderPluginServer(s *grpc.Server, srv DependenciesReaderPluginServer) { - s.RegisterService(&_DependenciesReaderPlugin_serviceDesc, srv) +type spanReaderPluginFindTracesServer struct { + grpc.ServerStream } -func _DependenciesReaderPlugin_GetDependencies_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetDependenciesRequest) +func (x *spanReaderPluginFindTracesServer) Send(m *SpansResponseChunk) error { + return x.ServerStream.SendMsg(m) +} + +func _SpanReaderPlugin_FindTraceIDs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(FindTraceIDsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(DependenciesReaderPluginServer).GetDependencies(ctx, in) + return srv.(SpanReaderPluginServer).FindTraceIDs(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/jaeger.storage.v1.DependenciesReaderPlugin/GetDependencies", + FullMethod: "/jaeger.storage.v1.SpanReaderPlugin/FindTraceIDs", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(DependenciesReaderPluginServer).GetDependencies(ctx, req.(*GetDependenciesRequest)) + return srv.(SpanReaderPluginServer).FindTraceIDs(ctx, req.(*FindTraceIDsRequest)) } return interceptor(ctx, in, info, handler) } -var _DependenciesReaderPlugin_serviceDesc = grpc.ServiceDesc{ - ServiceName: "jaeger.storage.v1.DependenciesReaderPlugin", - HandlerType: (*DependenciesReaderPluginServer)(nil), +var _SpanReaderPlugin_serviceDesc = grpc.ServiceDesc{ + ServiceName: "jaeger.storage.v1.SpanReaderPlugin", + HandlerType: (*SpanReaderPluginServer)(nil), Methods: []grpc.MethodDesc{ { - MethodName: "GetDependencies", - Handler: _DependenciesReaderPlugin_GetDependencies_Handler, + MethodName: "GetServices", + Handler: _SpanReaderPlugin_GetServices_Handler, + }, + { + MethodName: "GetOperations", + Handler: _SpanReaderPlugin_GetOperations_Handler, + }, + { + MethodName: "FindTraceIDs", + Handler: _SpanReaderPlugin_FindTraceIDs_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "GetTrace", + Handler: _SpanReaderPlugin_GetTrace_Handler, + ServerStreams: true, + }, + { + StreamName: "FindTraces", + Handler: _SpanReaderPlugin_FindTraces_Handler, + ServerStreams: true, }, }, - Streams: []grpc.StreamDesc{}, Metadata: "storage.proto", } -// PluginCapabilitiesClient is the client API for PluginCapabilities service. +// ArchiveSpanWriterPluginClient is the client API for ArchiveSpanWriterPlugin service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. -type PluginCapabilitiesClient interface { - Capabilities(ctx context.Context, in *CapabilitiesRequest, opts ...grpc.CallOption) (*CapabilitiesResponse, error) +type ArchiveSpanWriterPluginClient interface { + // spanstore/Writer + WriteArchiveSpan(ctx context.Context, in *WriteSpanRequest, opts ...grpc.CallOption) (*WriteSpanResponse, error) } -type pluginCapabilitiesClient struct { +type archiveSpanWriterPluginClient struct { cc *grpc.ClientConn } -func NewPluginCapabilitiesClient(cc *grpc.ClientConn) PluginCapabilitiesClient { - return &pluginCapabilitiesClient{cc} +func NewArchiveSpanWriterPluginClient(cc *grpc.ClientConn) ArchiveSpanWriterPluginClient { + return &archiveSpanWriterPluginClient{cc} } -func (c *pluginCapabilitiesClient) Capabilities(ctx context.Context, in *CapabilitiesRequest, opts ...grpc.CallOption) (*CapabilitiesResponse, error) { - out := new(CapabilitiesResponse) - err := c.cc.Invoke(ctx, "/jaeger.storage.v1.PluginCapabilities/Capabilities", in, out, opts...) +func (c *archiveSpanWriterPluginClient) WriteArchiveSpan(ctx context.Context, in *WriteSpanRequest, opts ...grpc.CallOption) (*WriteSpanResponse, error) { + out := new(WriteSpanResponse) + err := c.cc.Invoke(ctx, "/jaeger.storage.v1.ArchiveSpanWriterPlugin/WriteArchiveSpan", in, out, opts...) if err != nil { return nil, err } return out, nil } -// PluginCapabilitiesServer is the server API for PluginCapabilities service. -type PluginCapabilitiesServer interface { - Capabilities(context.Context, *CapabilitiesRequest) (*CapabilitiesResponse, error) +// ArchiveSpanWriterPluginServer is the server API for ArchiveSpanWriterPlugin service. +type ArchiveSpanWriterPluginServer interface { + // spanstore/Writer + WriteArchiveSpan(context.Context, *WriteSpanRequest) (*WriteSpanResponse, error) } -// UnimplementedPluginCapabilitiesServer can be embedded to have forward compatible implementations. -type UnimplementedPluginCapabilitiesServer struct { +// UnimplementedArchiveSpanWriterPluginServer can be embedded to have forward compatible implementations. +type UnimplementedArchiveSpanWriterPluginServer struct { } -func (*UnimplementedPluginCapabilitiesServer) Capabilities(ctx context.Context, req *CapabilitiesRequest) (*CapabilitiesResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method Capabilities not implemented") +func (*UnimplementedArchiveSpanWriterPluginServer) WriteArchiveSpan(ctx context.Context, req *WriteSpanRequest) (*WriteSpanResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method WriteArchiveSpan not implemented") } -func RegisterPluginCapabilitiesServer(s *grpc.Server, srv PluginCapabilitiesServer) { - s.RegisterService(&_PluginCapabilities_serviceDesc, srv) +func RegisterArchiveSpanWriterPluginServer(s *grpc.Server, srv ArchiveSpanWriterPluginServer) { + s.RegisterService(&_ArchiveSpanWriterPlugin_serviceDesc, srv) } -func _PluginCapabilities_Capabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(CapabilitiesRequest) +func _ArchiveSpanWriterPlugin_WriteArchiveSpan_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(WriteSpanRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(PluginCapabilitiesServer).Capabilities(ctx, in) + return srv.(ArchiveSpanWriterPluginServer).WriteArchiveSpan(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/jaeger.storage.v1.PluginCapabilities/Capabilities", + FullMethod: "/jaeger.storage.v1.ArchiveSpanWriterPlugin/WriteArchiveSpan", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PluginCapabilitiesServer).Capabilities(ctx, req.(*CapabilitiesRequest)) + return srv.(ArchiveSpanWriterPluginServer).WriteArchiveSpan(ctx, req.(*WriteSpanRequest)) } return interceptor(ctx, in, info, handler) } -var _PluginCapabilities_serviceDesc = grpc.ServiceDesc{ - ServiceName: "jaeger.storage.v1.PluginCapabilities", - HandlerType: (*PluginCapabilitiesServer)(nil), +var _ArchiveSpanWriterPlugin_serviceDesc = grpc.ServiceDesc{ + ServiceName: "jaeger.storage.v1.ArchiveSpanWriterPlugin", + HandlerType: (*ArchiveSpanWriterPluginServer)(nil), Methods: []grpc.MethodDesc{ { - MethodName: "Capabilities", - Handler: _PluginCapabilities_Capabilities_Handler, + MethodName: "WriteArchiveSpan", + Handler: _ArchiveSpanWriterPlugin_WriteArchiveSpan_Handler, }, }, Streams: []grpc.StreamDesc{}, Metadata: "storage.proto", } -func (m *GetDependenciesRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +// ArchiveSpanReaderPluginClient is the client API for ArchiveSpanReaderPlugin service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type ArchiveSpanReaderPluginClient interface { + // spanstore/Reader + GetArchiveTrace(ctx context.Context, in *GetTraceRequest, opts ...grpc.CallOption) (ArchiveSpanReaderPlugin_GetArchiveTraceClient, error) } -func (m *GetDependenciesRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type archiveSpanReaderPluginClient struct { + cc *grpc.ClientConn } -func (m *GetDependenciesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime):]) - if err1 != nil { - return 0, err1 - } - i -= n1 - i = encodeVarintStorage(dAtA, i, uint64(n1)) - i-- - dAtA[i] = 0x12 - n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime):]) - if err2 != nil { - return 0, err2 - } - i -= n2 - i = encodeVarintStorage(dAtA, i, uint64(n2)) - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil +func NewArchiveSpanReaderPluginClient(cc *grpc.ClientConn) ArchiveSpanReaderPluginClient { + return &archiveSpanReaderPluginClient{cc} } -func (m *GetDependenciesResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) +func (c *archiveSpanReaderPluginClient) GetArchiveTrace(ctx context.Context, in *GetTraceRequest, opts ...grpc.CallOption) (ArchiveSpanReaderPlugin_GetArchiveTraceClient, error) { + stream, err := c.cc.NewStream(ctx, &_ArchiveSpanReaderPlugin_serviceDesc.Streams[0], "/jaeger.storage.v1.ArchiveSpanReaderPlugin/GetArchiveTrace", opts...) if err != nil { return nil, err } - return dAtA[:n], nil + x := &archiveSpanReaderPluginGetArchiveTraceClient{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 } -func (m *GetDependenciesResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type ArchiveSpanReaderPlugin_GetArchiveTraceClient interface { + Recv() (*SpansResponseChunk, error) + grpc.ClientStream } -func (m *GetDependenciesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - if len(m.Dependencies) > 0 { - for iNdEx := len(m.Dependencies) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Dependencies[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStorage(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - } - return len(dAtA) - i, nil +type archiveSpanReaderPluginGetArchiveTraceClient struct { + grpc.ClientStream } -func (m *WriteSpanRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func (x *archiveSpanReaderPluginGetArchiveTraceClient) Recv() (*SpansResponseChunk, error) { + m := new(SpansResponseChunk) + if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } - return dAtA[:n], nil + return m, nil } -func (m *WriteSpanRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +// ArchiveSpanReaderPluginServer is the server API for ArchiveSpanReaderPlugin service. +type ArchiveSpanReaderPluginServer interface { + // spanstore/Reader + GetArchiveTrace(*GetTraceRequest, ArchiveSpanReaderPlugin_GetArchiveTraceServer) error } -func (m *WriteSpanRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - if m.Span != nil { - { - size, err := m.Span.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStorage(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil +// UnimplementedArchiveSpanReaderPluginServer can be embedded to have forward compatible implementations. +type UnimplementedArchiveSpanReaderPluginServer struct { } -func (m *WriteSpanResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +func (*UnimplementedArchiveSpanReaderPluginServer) GetArchiveTrace(req *GetTraceRequest, srv ArchiveSpanReaderPlugin_GetArchiveTraceServer) error { + return status.Errorf(codes.Unimplemented, "method GetArchiveTrace not implemented") } -func (m *WriteSpanResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func RegisterArchiveSpanReaderPluginServer(s *grpc.Server, srv ArchiveSpanReaderPluginServer) { + s.RegisterService(&_ArchiveSpanReaderPlugin_serviceDesc, srv) } -func (m *WriteSpanResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) +func _ArchiveSpanReaderPlugin_GetArchiveTrace_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(GetTraceRequest) + if err := stream.RecvMsg(m); err != nil { + return err } - return len(dAtA) - i, nil + return srv.(ArchiveSpanReaderPluginServer).GetArchiveTrace(m, &archiveSpanReaderPluginGetArchiveTraceServer{stream}) } -func (m *CloseWriterRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +type ArchiveSpanReaderPlugin_GetArchiveTraceServer interface { + Send(*SpansResponseChunk) error + grpc.ServerStream } -func (m *CloseWriterRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type archiveSpanReaderPluginGetArchiveTraceServer struct { + grpc.ServerStream } -func (m *CloseWriterRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - return len(dAtA) - i, nil +func (x *archiveSpanReaderPluginGetArchiveTraceServer) Send(m *SpansResponseChunk) error { + return x.ServerStream.SendMsg(m) } -func (m *CloseWriterResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +var _ArchiveSpanReaderPlugin_serviceDesc = grpc.ServiceDesc{ + ServiceName: "jaeger.storage.v1.ArchiveSpanReaderPlugin", + HandlerType: (*ArchiveSpanReaderPluginServer)(nil), + Methods: []grpc.MethodDesc{}, + Streams: []grpc.StreamDesc{ + { + StreamName: "GetArchiveTrace", + Handler: _ArchiveSpanReaderPlugin_GetArchiveTrace_Handler, + ServerStreams: true, + }, + }, + Metadata: "storage.proto", } -func (m *CloseWriterResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +// DependenciesReaderPluginClient is the client API for DependenciesReaderPlugin service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type DependenciesReaderPluginClient interface { + // dependencystore/Reader + GetDependencies(ctx context.Context, in *GetDependenciesRequest, opts ...grpc.CallOption) (*GetDependenciesResponse, error) } -func (m *CloseWriterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - return len(dAtA) - i, nil +type dependenciesReaderPluginClient struct { + cc *grpc.ClientConn } -func (m *GetTraceRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) +func NewDependenciesReaderPluginClient(cc *grpc.ClientConn) DependenciesReaderPluginClient { + return &dependenciesReaderPluginClient{cc} +} + +func (c *dependenciesReaderPluginClient) GetDependencies(ctx context.Context, in *GetDependenciesRequest, opts ...grpc.CallOption) (*GetDependenciesResponse, error) { + out := new(GetDependenciesResponse) + err := c.cc.Invoke(ctx, "/jaeger.storage.v1.DependenciesReaderPlugin/GetDependencies", in, out, opts...) if err != nil { return nil, err } - return dAtA[:n], nil + return out, nil } -func (m *GetTraceRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +// DependenciesReaderPluginServer is the server API for DependenciesReaderPlugin service. +type DependenciesReaderPluginServer interface { + // dependencystore/Reader + GetDependencies(context.Context, *GetDependenciesRequest) (*GetDependenciesResponse, error) } -func (m *GetTraceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime):]) - if err4 != nil { - return 0, err4 +// UnimplementedDependenciesReaderPluginServer can be embedded to have forward compatible implementations. +type UnimplementedDependenciesReaderPluginServer struct { +} + +func (*UnimplementedDependenciesReaderPluginServer) GetDependencies(ctx context.Context, req *GetDependenciesRequest) (*GetDependenciesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetDependencies not implemented") +} + +func RegisterDependenciesReaderPluginServer(s *grpc.Server, srv DependenciesReaderPluginServer) { + s.RegisterService(&_DependenciesReaderPlugin_serviceDesc, srv) +} + +func _DependenciesReaderPlugin_GetDependencies_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetDependenciesRequest) + if err := dec(in); err != nil { + return nil, err } - i -= n4 - i = encodeVarintStorage(dAtA, i, uint64(n4)) - i-- - dAtA[i] = 0x1a - n5, err5 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime):]) - if err5 != nil { - return 0, err5 + if interceptor == nil { + return srv.(DependenciesReaderPluginServer).GetDependencies(ctx, in) } - i -= n5 - i = encodeVarintStorage(dAtA, i, uint64(n5)) - i-- - dAtA[i] = 0x12 - { - size := m.TraceID.Size() - i -= size - if _, err := m.TraceID.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintStorage(dAtA, i, uint64(size)) + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/jaeger.storage.v1.DependenciesReaderPlugin/GetDependencies", } - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DependenciesReaderPluginServer).GetDependencies(ctx, req.(*GetDependenciesRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *GetServicesRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +var _DependenciesReaderPlugin_serviceDesc = grpc.ServiceDesc{ + ServiceName: "jaeger.storage.v1.DependenciesReaderPlugin", + HandlerType: (*DependenciesReaderPluginServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "GetDependencies", + Handler: _DependenciesReaderPlugin_GetDependencies_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "storage.proto", } -func (m *GetServicesRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +// SamplingStorePluginClient is the client API for SamplingStorePlugin service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type SamplingStorePluginClient interface { + InsertThroughput(ctx context.Context, in *InsertThroughputRequest, opts ...grpc.CallOption) (*InsertThroughputResponse, error) + InsertProbabilitiesAndQPS(ctx context.Context, in *InsertProbabilitiesAndQPSRequest, opts ...grpc.CallOption) (*InsertProbabilitiesAndQPSResponse, error) + GetThroughput(ctx context.Context, in *GetThroughputRequest, opts ...grpc.CallOption) (*GetThroughputResponse, error) + GetLatestProbabilities(ctx context.Context, in *GetLatestProbabilitiesRequest, opts ...grpc.CallOption) (*GetLatestProbabilitiesResponse, error) } -func (m *GetServicesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - return len(dAtA) - i, nil +type samplingStorePluginClient struct { + cc *grpc.ClientConn } -func (m *GetServicesResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) +func NewSamplingStorePluginClient(cc *grpc.ClientConn) SamplingStorePluginClient { + return &samplingStorePluginClient{cc} +} + +func (c *samplingStorePluginClient) InsertThroughput(ctx context.Context, in *InsertThroughputRequest, opts ...grpc.CallOption) (*InsertThroughputResponse, error) { + out := new(InsertThroughputResponse) + err := c.cc.Invoke(ctx, "/jaeger.storage.v1.SamplingStorePlugin/InsertThroughput", in, out, opts...) if err != nil { return nil, err } - return dAtA[:n], nil + return out, nil } -func (m *GetServicesResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (c *samplingStorePluginClient) InsertProbabilitiesAndQPS(ctx context.Context, in *InsertProbabilitiesAndQPSRequest, opts ...grpc.CallOption) (*InsertProbabilitiesAndQPSResponse, error) { + out := new(InsertProbabilitiesAndQPSResponse) + err := c.cc.Invoke(ctx, "/jaeger.storage.v1.SamplingStorePlugin/InsertProbabilitiesAndQPS", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (m *GetServicesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - if len(m.Services) > 0 { - for iNdEx := len(m.Services) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.Services[iNdEx]) - copy(dAtA[i:], m.Services[iNdEx]) - i = encodeVarintStorage(dAtA, i, uint64(len(m.Services[iNdEx]))) - i-- - dAtA[i] = 0xa - } +func (c *samplingStorePluginClient) GetThroughput(ctx context.Context, in *GetThroughputRequest, opts ...grpc.CallOption) (*GetThroughputResponse, error) { + out := new(GetThroughputResponse) + err := c.cc.Invoke(ctx, "/jaeger.storage.v1.SamplingStorePlugin/GetThroughput", in, out, opts...) + if err != nil { + return nil, err } - return len(dAtA) - i, nil + return out, nil } -func (m *GetOperationsRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) +func (c *samplingStorePluginClient) GetLatestProbabilities(ctx context.Context, in *GetLatestProbabilitiesRequest, opts ...grpc.CallOption) (*GetLatestProbabilitiesResponse, error) { + out := new(GetLatestProbabilitiesResponse) + err := c.cc.Invoke(ctx, "/jaeger.storage.v1.SamplingStorePlugin/GetLatestProbabilities", in, out, opts...) if err != nil { return nil, err } - return dAtA[:n], nil + return out, nil } -func (m *GetOperationsRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +// SamplingStorePluginServer is the server API for SamplingStorePlugin service. +type SamplingStorePluginServer interface { + InsertThroughput(context.Context, *InsertThroughputRequest) (*InsertThroughputResponse, error) + InsertProbabilitiesAndQPS(context.Context, *InsertProbabilitiesAndQPSRequest) (*InsertProbabilitiesAndQPSResponse, error) + GetThroughput(context.Context, *GetThroughputRequest) (*GetThroughputResponse, error) + GetLatestProbabilities(context.Context, *GetLatestProbabilitiesRequest) (*GetLatestProbabilitiesResponse, error) } -func (m *GetOperationsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - if len(m.SpanKind) > 0 { - i -= len(m.SpanKind) - copy(dAtA[i:], m.SpanKind) - i = encodeVarintStorage(dAtA, i, uint64(len(m.SpanKind))) - i-- - dAtA[i] = 0x12 - } - if len(m.Service) > 0 { - i -= len(m.Service) - copy(dAtA[i:], m.Service) - i = encodeVarintStorage(dAtA, i, uint64(len(m.Service))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil +// UnimplementedSamplingStorePluginServer can be embedded to have forward compatible implementations. +type UnimplementedSamplingStorePluginServer struct { } -func (m *Operation) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +func (*UnimplementedSamplingStorePluginServer) InsertThroughput(ctx context.Context, req *InsertThroughputRequest) (*InsertThroughputResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method InsertThroughput not implemented") +} +func (*UnimplementedSamplingStorePluginServer) InsertProbabilitiesAndQPS(ctx context.Context, req *InsertProbabilitiesAndQPSRequest) (*InsertProbabilitiesAndQPSResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method InsertProbabilitiesAndQPS not implemented") +} +func (*UnimplementedSamplingStorePluginServer) GetThroughput(ctx context.Context, req *GetThroughputRequest) (*GetThroughputResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetThroughput not implemented") +} +func (*UnimplementedSamplingStorePluginServer) GetLatestProbabilities(ctx context.Context, req *GetLatestProbabilitiesRequest) (*GetLatestProbabilitiesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetLatestProbabilities not implemented") } -func (m *Operation) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func RegisterSamplingStorePluginServer(s *grpc.Server, srv SamplingStorePluginServer) { + s.RegisterService(&_SamplingStorePlugin_serviceDesc, srv) } -func (m *Operation) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) +func _SamplingStorePlugin_InsertThroughput_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(InsertThroughputRequest) + if err := dec(in); err != nil { + return nil, err } - if len(m.SpanKind) > 0 { - i -= len(m.SpanKind) - copy(dAtA[i:], m.SpanKind) - i = encodeVarintStorage(dAtA, i, uint64(len(m.SpanKind))) - i-- - dAtA[i] = 0x12 + if interceptor == nil { + return srv.(SamplingStorePluginServer).InsertThroughput(ctx, in) } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintStorage(dAtA, i, uint64(len(m.Name))) - i-- - dAtA[i] = 0xa + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/jaeger.storage.v1.SamplingStorePlugin/InsertThroughput", } - return len(dAtA) - i, nil + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SamplingStorePluginServer).InsertThroughput(ctx, req.(*InsertThroughputRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *GetOperationsResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _SamplingStorePlugin_InsertProbabilitiesAndQPS_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(InsertProbabilitiesAndQPSRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *GetOperationsResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *GetOperationsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) + if interceptor == nil { + return srv.(SamplingStorePluginServer).InsertProbabilitiesAndQPS(ctx, in) } - if len(m.Operations) > 0 { - for iNdEx := len(m.Operations) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Operations[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStorage(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/jaeger.storage.v1.SamplingStorePlugin/InsertProbabilitiesAndQPS", } - if len(m.OperationNames) > 0 { - for iNdEx := len(m.OperationNames) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.OperationNames[iNdEx]) - copy(dAtA[i:], m.OperationNames[iNdEx]) - i = encodeVarintStorage(dAtA, i, uint64(len(m.OperationNames[iNdEx]))) - i-- - dAtA[i] = 0xa - } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SamplingStorePluginServer).InsertProbabilitiesAndQPS(ctx, req.(*InsertProbabilitiesAndQPSRequest)) } - return len(dAtA) - i, nil + return interceptor(ctx, in, info, handler) } -func (m *TraceQueryParameters) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _SamplingStorePlugin_GetThroughput_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetThroughputRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *TraceQueryParameters) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} + if interceptor == nil { + return srv.(SamplingStorePluginServer).GetThroughput(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/jaeger.storage.v1.SamplingStorePlugin/GetThroughput", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SamplingStorePluginServer).GetThroughput(ctx, req.(*GetThroughputRequest)) + } + return interceptor(ctx, in, info, handler) +} -func (m *TraceQueryParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) +func _SamplingStorePlugin_GetLatestProbabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetLatestProbabilitiesRequest) + if err := dec(in); err != nil { + return nil, err } - if m.NumTraces != 0 { - i = encodeVarintStorage(dAtA, i, uint64(m.NumTraces)) - i-- - dAtA[i] = 0x40 + if interceptor == nil { + return srv.(SamplingStorePluginServer).GetLatestProbabilities(ctx, in) } - n6, err6 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.DurationMax, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.DurationMax):]) - if err6 != nil { - return 0, err6 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/jaeger.storage.v1.SamplingStorePlugin/GetLatestProbabilities", } - i -= n6 - i = encodeVarintStorage(dAtA, i, uint64(n6)) - i-- - dAtA[i] = 0x3a - n7, err7 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.DurationMin, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.DurationMin):]) - if err7 != nil { - return 0, err7 + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SamplingStorePluginServer).GetLatestProbabilities(ctx, req.(*GetLatestProbabilitiesRequest)) } - i -= n7 - i = encodeVarintStorage(dAtA, i, uint64(n7)) - i-- - dAtA[i] = 0x32 - n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTimeMax, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTimeMax):]) - if err8 != nil { - return 0, err8 + return interceptor(ctx, in, info, handler) +} + +var _SamplingStorePlugin_serviceDesc = grpc.ServiceDesc{ + ServiceName: "jaeger.storage.v1.SamplingStorePlugin", + HandlerType: (*SamplingStorePluginServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "InsertThroughput", + Handler: _SamplingStorePlugin_InsertThroughput_Handler, + }, + { + MethodName: "InsertProbabilitiesAndQPS", + Handler: _SamplingStorePlugin_InsertProbabilitiesAndQPS_Handler, + }, + { + MethodName: "GetThroughput", + Handler: _SamplingStorePlugin_GetThroughput_Handler, + }, + { + MethodName: "GetLatestProbabilities", + Handler: _SamplingStorePlugin_GetLatestProbabilities_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "storage.proto", +} + +// PluginCapabilitiesClient is the client API for PluginCapabilities service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type PluginCapabilitiesClient interface { + Capabilities(ctx context.Context, in *CapabilitiesRequest, opts ...grpc.CallOption) (*CapabilitiesResponse, error) +} + +type pluginCapabilitiesClient struct { + cc *grpc.ClientConn +} + +func NewPluginCapabilitiesClient(cc *grpc.ClientConn) PluginCapabilitiesClient { + return &pluginCapabilitiesClient{cc} +} + +func (c *pluginCapabilitiesClient) Capabilities(ctx context.Context, in *CapabilitiesRequest, opts ...grpc.CallOption) (*CapabilitiesResponse, error) { + out := new(CapabilitiesResponse) + err := c.cc.Invoke(ctx, "/jaeger.storage.v1.PluginCapabilities/Capabilities", in, out, opts...) + if err != nil { + return nil, err } - i -= n8 - i = encodeVarintStorage(dAtA, i, uint64(n8)) - i-- - dAtA[i] = 0x2a - n9, err9 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTimeMin, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTimeMin):]) - if err9 != nil { - return 0, err9 + return out, nil +} + +// PluginCapabilitiesServer is the server API for PluginCapabilities service. +type PluginCapabilitiesServer interface { + Capabilities(context.Context, *CapabilitiesRequest) (*CapabilitiesResponse, error) +} + +// UnimplementedPluginCapabilitiesServer can be embedded to have forward compatible implementations. +type UnimplementedPluginCapabilitiesServer struct { +} + +func (*UnimplementedPluginCapabilitiesServer) Capabilities(ctx context.Context, req *CapabilitiesRequest) (*CapabilitiesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Capabilities not implemented") +} + +func RegisterPluginCapabilitiesServer(s *grpc.Server, srv PluginCapabilitiesServer) { + s.RegisterService(&_PluginCapabilities_serviceDesc, srv) +} + +func _PluginCapabilities_Capabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CapabilitiesRequest) + if err := dec(in); err != nil { + return nil, err } - i -= n9 - i = encodeVarintStorage(dAtA, i, uint64(n9)) - i-- - dAtA[i] = 0x22 - if len(m.Tags) > 0 { - for k := range m.Tags { - v := m.Tags[k] - baseI := i - i -= len(v) - copy(dAtA[i:], v) - i = encodeVarintStorage(dAtA, i, uint64(len(v))) - i-- - dAtA[i] = 0x12 - i -= len(k) - copy(dAtA[i:], k) - i = encodeVarintStorage(dAtA, i, uint64(len(k))) - i-- - dAtA[i] = 0xa - i = encodeVarintStorage(dAtA, i, uint64(baseI-i)) - i-- - dAtA[i] = 0x1a - } + if interceptor == nil { + return srv.(PluginCapabilitiesServer).Capabilities(ctx, in) } - if len(m.OperationName) > 0 { - i -= len(m.OperationName) - copy(dAtA[i:], m.OperationName) - i = encodeVarintStorage(dAtA, i, uint64(len(m.OperationName))) - i-- - dAtA[i] = 0x12 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/jaeger.storage.v1.PluginCapabilities/Capabilities", } - if len(m.ServiceName) > 0 { - i -= len(m.ServiceName) - copy(dAtA[i:], m.ServiceName) - i = encodeVarintStorage(dAtA, i, uint64(len(m.ServiceName))) - i-- - dAtA[i] = 0xa + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PluginCapabilitiesServer).Capabilities(ctx, req.(*CapabilitiesRequest)) } - return len(dAtA) - i, nil + return interceptor(ctx, in, info, handler) } -func (m *FindTracesRequest) Marshal() (dAtA []byte, err error) { +var _PluginCapabilities_serviceDesc = grpc.ServiceDesc{ + ServiceName: "jaeger.storage.v1.PluginCapabilities", + HandlerType: (*PluginCapabilitiesServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Capabilities", + Handler: _PluginCapabilities_Capabilities_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "storage.proto", +} + +func (m *GetDependenciesRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2473,12 +2735,12 @@ func (m *FindTracesRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *FindTracesRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *GetDependenciesRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *FindTracesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GetDependenciesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -2487,22 +2749,26 @@ func (m *FindTracesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Query != nil { - { - size, err := m.Query.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStorage(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime):]) + if err1 != nil { + return 0, err1 + } + i -= n1 + i = encodeVarintStorage(dAtA, i, uint64(n1)) + i-- + dAtA[i] = 0x12 + n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime):]) + if err2 != nil { + return 0, err2 } + i -= n2 + i = encodeVarintStorage(dAtA, i, uint64(n2)) + i-- + dAtA[i] = 0xa return len(dAtA) - i, nil } -func (m *SpansResponseChunk) Marshal() (dAtA []byte, err error) { +func (m *GetDependenciesResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2512,12 +2778,12 @@ func (m *SpansResponseChunk) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SpansResponseChunk) MarshalTo(dAtA []byte) (int, error) { +func (m *GetDependenciesResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SpansResponseChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GetDependenciesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -2526,10 +2792,10 @@ func (m *SpansResponseChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Spans) > 0 { - for iNdEx := len(m.Spans) - 1; iNdEx >= 0; iNdEx-- { + if len(m.Dependencies) > 0 { + for iNdEx := len(m.Dependencies) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.Spans[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Dependencies[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -2543,7 +2809,7 @@ func (m *SpansResponseChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *FindTraceIDsRequest) Marshal() (dAtA []byte, err error) { +func (m *WriteSpanRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2553,12 +2819,12 @@ func (m *FindTraceIDsRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *FindTraceIDsRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *WriteSpanRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *FindTraceIDsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *WriteSpanRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -2567,9 +2833,9 @@ func (m *FindTraceIDsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Query != nil { + if m.Span != nil { { - size, err := m.Query.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Span.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -2582,7 +2848,7 @@ func (m *FindTraceIDsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *FindTraceIDsResponse) Marshal() (dAtA []byte, err error) { +func (m *WriteSpanResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2592,12 +2858,12 @@ func (m *FindTraceIDsResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *FindTraceIDsResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *WriteSpanResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *FindTraceIDsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *WriteSpanResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -2606,24 +2872,10 @@ func (m *FindTraceIDsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.TraceIDs) > 0 { - for iNdEx := len(m.TraceIDs) - 1; iNdEx >= 0; iNdEx-- { - { - size := m.TraceIDs[iNdEx].Size() - i -= size - if _, err := m.TraceIDs[iNdEx].MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintStorage(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - } return len(dAtA) - i, nil } -func (m *CapabilitiesRequest) Marshal() (dAtA []byte, err error) { +func (m *CloseWriterRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2633,12 +2885,12 @@ func (m *CapabilitiesRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *CapabilitiesRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *CloseWriterRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *CapabilitiesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *CloseWriterRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -2650,7 +2902,7 @@ func (m *CapabilitiesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *CapabilitiesResponse) Marshal() (dAtA []byte, err error) { +func (m *CloseWriterResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2660,12 +2912,12 @@ func (m *CapabilitiesResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *CapabilitiesResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *CloseWriterResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *CapabilitiesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *CloseWriterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -2674,395 +2926,2761 @@ func (m *CapabilitiesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.StreamingSpanWriter { - i-- - if m.StreamingSpanWriter { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x18 - } - if m.ArchiveSpanWriter { - i-- - if m.ArchiveSpanWriter { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x10 - } - if m.ArchiveSpanReader { - i-- - if m.ArchiveSpanReader { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x8 - } return len(dAtA) - i, nil } -func encodeVarintStorage(dAtA []byte, offset int, v uint64) int { - offset -= sovStorage(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ +func (m *GetTraceRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - dAtA[offset] = uint8(v) - return base + return dAtA[:n], nil } -func (m *GetDependenciesRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime) - n += 1 + l + sovStorage(uint64(l)) - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime) - n += 1 + l + sovStorage(uint64(l)) - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n + +func (m *GetTraceRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GetDependenciesResponse) Size() (n int) { - if m == nil { - return 0 - } +func (m *GetTraceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if len(m.Dependencies) > 0 { - for _, e := range m.Dependencies { - l = e.Size() - n += 1 + l + sovStorage(uint64(l)) - } - } if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return n -} - -func (m *WriteSpanRequest) Size() (n int) { - if m == nil { - return 0 + n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime):]) + if err4 != nil { + return 0, err4 } - var l int - _ = l - if m.Span != nil { - l = m.Span.Size() - n += 1 + l + sovStorage(uint64(l)) + i -= n4 + i = encodeVarintStorage(dAtA, i, uint64(n4)) + i-- + dAtA[i] = 0x1a + n5, err5 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime):]) + if err5 != nil { + return 0, err5 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i -= n5 + i = encodeVarintStorage(dAtA, i, uint64(n5)) + i-- + dAtA[i] = 0x12 + { + size := m.TraceID.Size() + i -= size + if _, err := m.TraceID.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintStorage(dAtA, i, uint64(size)) } - return n + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil } -func (m *WriteSpanResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) +func (m *GetServicesRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *CloseWriterRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n +func (m *GetServicesRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *CloseWriterResponse) Size() (n int) { - if m == nil { - return 0 - } +func (m *GetServicesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return n + return len(dAtA) - i, nil } -func (m *GetTraceRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = m.TraceID.Size() - n += 1 + l + sovStorage(uint64(l)) - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime) - n += 1 + l + sovStorage(uint64(l)) - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime) - n += 1 + l + sovStorage(uint64(l)) - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) +func (m *GetServicesResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *GetServicesRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n +func (m *GetServicesResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GetServicesResponse) Size() (n int) { - if m == nil { - return 0 - } +func (m *GetServicesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } if len(m.Services) > 0 { - for _, s := range m.Services { - l = len(s) - n += 1 + l + sovStorage(uint64(l)) + for iNdEx := len(m.Services) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Services[iNdEx]) + copy(dAtA[i:], m.Services[iNdEx]) + i = encodeVarintStorage(dAtA, i, uint64(len(m.Services[iNdEx]))) + i-- + dAtA[i] = 0xa } } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n + return len(dAtA) - i, nil } -func (m *GetOperationsRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Service) - if l > 0 { - n += 1 + l + sovStorage(uint64(l)) - } - l = len(m.SpanKind) - if l > 0 { - n += 1 + l + sovStorage(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) +func (m *GetOperationsRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *Operation) Size() (n int) { - if m == nil { - return 0 - } +func (m *GetOperationsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetOperationsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Name) - if l > 0 { - n += 1 + l + sovStorage(uint64(l)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - l = len(m.SpanKind) - if l > 0 { - n += 1 + l + sovStorage(uint64(l)) + if len(m.SpanKind) > 0 { + i -= len(m.SpanKind) + copy(dAtA[i:], m.SpanKind) + i = encodeVarintStorage(dAtA, i, uint64(len(m.SpanKind))) + i-- + dAtA[i] = 0x12 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if len(m.Service) > 0 { + i -= len(m.Service) + copy(dAtA[i:], m.Service) + i = encodeVarintStorage(dAtA, i, uint64(len(m.Service))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *GetOperationsResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.OperationNames) > 0 { - for _, s := range m.OperationNames { - l = len(s) - n += 1 + l + sovStorage(uint64(l)) - } - } - if len(m.Operations) > 0 { - for _, e := range m.Operations { - l = e.Size() - n += 1 + l + sovStorage(uint64(l)) - } - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) +func (m *Operation) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *TraceQueryParameters) Size() (n int) { - if m == nil { - return 0 - } +func (m *Operation) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Operation) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.ServiceName) - if l > 0 { - n += 1 + l + sovStorage(uint64(l)) - } - l = len(m.OperationName) - if l > 0 { - n += 1 + l + sovStorage(uint64(l)) - } - if len(m.Tags) > 0 { - for k, v := range m.Tags { - _ = k - _ = v - mapEntrySize := 1 + len(k) + sovStorage(uint64(len(k))) + 1 + len(v) + sovStorage(uint64(len(v))) - n += mapEntrySize + 1 + sovStorage(uint64(mapEntrySize)) - } + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTimeMin) - n += 1 + l + sovStorage(uint64(l)) - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTimeMax) - n += 1 + l + sovStorage(uint64(l)) - l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.DurationMin) - n += 1 + l + sovStorage(uint64(l)) - l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.DurationMax) - n += 1 + l + sovStorage(uint64(l)) - if m.NumTraces != 0 { - n += 1 + sovStorage(uint64(m.NumTraces)) + if len(m.SpanKind) > 0 { + i -= len(m.SpanKind) + copy(dAtA[i:], m.SpanKind) + i = encodeVarintStorage(dAtA, i, uint64(len(m.SpanKind))) + i-- + dAtA[i] = 0x12 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintStorage(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *FindTracesRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Query != nil { - l = m.Query.Size() - n += 1 + l + sovStorage(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) +func (m *GetOperationsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *SpansResponseChunk) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.Spans) > 0 { - for _, e := range m.Spans { - l = e.Size() - n += 1 + l + sovStorage(uint64(l)) - } - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n +func (m *GetOperationsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *FindTraceIDsRequest) Size() (n int) { - if m == nil { - return 0 - } +func (m *GetOperationsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Query != nil { - l = m.Query.Size() - n += 1 + l + sovStorage(uint64(l)) - } if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n -} - -func (m *FindTraceIDsResponse) Size() (n int) { - if m == nil { - return 0 + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - var l int - _ = l - if len(m.TraceIDs) > 0 { - for _, e := range m.TraceIDs { - l = e.Size() - n += 1 + l + sovStorage(uint64(l)) + if len(m.Operations) > 0 { + for iNdEx := len(m.Operations) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Operations[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStorage(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if len(m.OperationNames) > 0 { + for iNdEx := len(m.OperationNames) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.OperationNames[iNdEx]) + copy(dAtA[i:], m.OperationNames[iNdEx]) + i = encodeVarintStorage(dAtA, i, uint64(len(m.OperationNames[iNdEx]))) + i-- + dAtA[i] = 0xa + } } - return n + return len(dAtA) - i, nil } -func (m *CapabilitiesRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) +func (m *TraceQueryParameters) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *CapabilitiesResponse) Size() (n int) { - if m == nil { - return 0 - } +func (m *TraceQueryParameters) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TraceQueryParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.ArchiveSpanReader { - n += 2 + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.ArchiveSpanWriter { - n += 2 + if m.NumTraces != 0 { + i = encodeVarintStorage(dAtA, i, uint64(m.NumTraces)) + i-- + dAtA[i] = 0x40 } - if m.StreamingSpanWriter { - n += 2 + n6, err6 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.DurationMax, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.DurationMax):]) + if err6 != nil { + return 0, err6 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i -= n6 + i = encodeVarintStorage(dAtA, i, uint64(n6)) + i-- + dAtA[i] = 0x3a + n7, err7 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.DurationMin, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.DurationMin):]) + if err7 != nil { + return 0, err7 } - return n -} - -func sovStorage(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozStorage(x uint64) (n int) { + i -= n7 + i = encodeVarintStorage(dAtA, i, uint64(n7)) + i-- + dAtA[i] = 0x32 + n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTimeMax, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTimeMax):]) + if err8 != nil { + return 0, err8 + } + i -= n8 + i = encodeVarintStorage(dAtA, i, uint64(n8)) + i-- + dAtA[i] = 0x2a + n9, err9 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTimeMin, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTimeMin):]) + if err9 != nil { + return 0, err9 + } + i -= n9 + i = encodeVarintStorage(dAtA, i, uint64(n9)) + i-- + dAtA[i] = 0x22 + if len(m.Tags) > 0 { + for k := range m.Tags { + v := m.Tags[k] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintStorage(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(k) + copy(dAtA[i:], k) + i = encodeVarintStorage(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = encodeVarintStorage(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x1a + } + } + if len(m.OperationName) > 0 { + i -= len(m.OperationName) + copy(dAtA[i:], m.OperationName) + i = encodeVarintStorage(dAtA, i, uint64(len(m.OperationName))) + i-- + dAtA[i] = 0x12 + } + if len(m.ServiceName) > 0 { + i -= len(m.ServiceName) + copy(dAtA[i:], m.ServiceName) + i = encodeVarintStorage(dAtA, i, uint64(len(m.ServiceName))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *FindTracesRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FindTracesRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FindTracesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Query != nil { + { + size, err := m.Query.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStorage(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SpansResponseChunk) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SpansResponseChunk) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SpansResponseChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Spans) > 0 { + for iNdEx := len(m.Spans) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Spans[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStorage(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *FindTraceIDsRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FindTraceIDsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FindTraceIDsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Query != nil { + { + size, err := m.Query.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStorage(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *FindTraceIDsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FindTraceIDsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FindTraceIDsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.TraceIDs) > 0 { + for iNdEx := len(m.TraceIDs) - 1; iNdEx >= 0; iNdEx-- { + { + size := m.TraceIDs[iNdEx].Size() + i -= size + if _, err := m.TraceIDs[iNdEx].MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintStorage(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *Throughput) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Throughput) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Throughput) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Probabilities) > 0 { + for iNdEx := len(m.Probabilities) - 1; iNdEx >= 0; iNdEx-- { + f12 := math.Float64bits(float64(m.Probabilities[iNdEx])) + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f12)) + } + i = encodeVarintStorage(dAtA, i, uint64(len(m.Probabilities)*8)) + i-- + dAtA[i] = 0x22 + } + if m.Count != 0 { + i = encodeVarintStorage(dAtA, i, uint64(m.Count)) + i-- + dAtA[i] = 0x18 + } + if len(m.Operation) > 0 { + i -= len(m.Operation) + copy(dAtA[i:], m.Operation) + i = encodeVarintStorage(dAtA, i, uint64(len(m.Operation))) + i-- + dAtA[i] = 0x12 + } + if len(m.Service) > 0 { + i -= len(m.Service) + copy(dAtA[i:], m.Service) + i = encodeVarintStorage(dAtA, i, uint64(len(m.Service))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *InsertThroughputRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *InsertThroughputRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *InsertThroughputRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Throughput) > 0 { + for iNdEx := len(m.Throughput) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Throughput[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStorage(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *InsertThroughputResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *InsertThroughputResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *InsertThroughputResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + return len(dAtA) - i, nil +} + +func (m *StringFloatMap) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StringFloatMap) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StringFloatMap) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.StringFloatMap) > 0 { + for k := range m.StringFloatMap { + v := m.StringFloatMap[k] + baseI := i + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(v)))) + i-- + dAtA[i] = 0x11 + i -= len(k) + copy(dAtA[i:], k) + i = encodeVarintStorage(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = encodeVarintStorage(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *ServiceOperationProbabilities) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ServiceOperationProbabilities) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ServiceOperationProbabilities) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.ServiceOperationProbabilities) > 0 { + for k := range m.ServiceOperationProbabilities { + v := m.ServiceOperationProbabilities[k] + baseI := i + if v != nil { + { + size, err := v.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStorage(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i -= len(k) + copy(dAtA[i:], k) + i = encodeVarintStorage(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = encodeVarintStorage(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *ServiceOperationQPS) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ServiceOperationQPS) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ServiceOperationQPS) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.ServiceOperationQPS) > 0 { + for k := range m.ServiceOperationQPS { + v := m.ServiceOperationQPS[k] + baseI := i + if v != nil { + { + size, err := v.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStorage(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i -= len(k) + copy(dAtA[i:], k) + i = encodeVarintStorage(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = encodeVarintStorage(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *InsertProbabilitiesAndQPSRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *InsertProbabilitiesAndQPSRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *InsertProbabilitiesAndQPSRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Qps != nil { + { + size, err := m.Qps.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStorage(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Probabilities != nil { + { + size, err := m.Probabilities.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStorage(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.Hostname) > 0 { + i -= len(m.Hostname) + copy(dAtA[i:], m.Hostname) + i = encodeVarintStorage(dAtA, i, uint64(len(m.Hostname))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *InsertProbabilitiesAndQPSResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *InsertProbabilitiesAndQPSResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *InsertProbabilitiesAndQPSResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + return len(dAtA) - i, nil +} + +func (m *GetThroughputRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetThroughputRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetThroughputRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + n17, err17 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime):]) + if err17 != nil { + return 0, err17 + } + i -= n17 + i = encodeVarintStorage(dAtA, i, uint64(n17)) + i-- + dAtA[i] = 0x12 + n18, err18 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime):]) + if err18 != nil { + return 0, err18 + } + i -= n18 + i = encodeVarintStorage(dAtA, i, uint64(n18)) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *GetThroughputResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetThroughputResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetThroughputResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Throughput) > 0 { + for iNdEx := len(m.Throughput) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Throughput[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStorage(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *GetLatestProbabilitiesRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetLatestProbabilitiesRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetLatestProbabilitiesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + return len(dAtA) - i, nil +} + +func (m *GetLatestProbabilitiesResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetLatestProbabilitiesResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetLatestProbabilitiesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.ServiceOperationProbabilities != nil { + { + size, err := m.ServiceOperationProbabilities.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStorage(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CapabilitiesRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CapabilitiesRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CapabilitiesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + return len(dAtA) - i, nil +} + +func (m *CapabilitiesResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CapabilitiesResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CapabilitiesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.StreamingSpanWriter { + i-- + if m.StreamingSpanWriter { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if m.ArchiveSpanWriter { + i-- + if m.ArchiveSpanWriter { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + } + if m.ArchiveSpanReader { + i-- + if m.ArchiveSpanReader { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintStorage(dAtA []byte, offset int, v uint64) int { + offset -= sovStorage(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *GetDependenciesRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime) + n += 1 + l + sovStorage(uint64(l)) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime) + n += 1 + l + sovStorage(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetDependenciesResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Dependencies) > 0 { + for _, e := range m.Dependencies { + l = e.Size() + n += 1 + l + sovStorage(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *WriteSpanRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Span != nil { + l = m.Span.Size() + n += 1 + l + sovStorage(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *WriteSpanResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CloseWriterRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CloseWriterResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetTraceRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.TraceID.Size() + n += 1 + l + sovStorage(uint64(l)) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime) + n += 1 + l + sovStorage(uint64(l)) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime) + n += 1 + l + sovStorage(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetServicesRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetServicesResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Services) > 0 { + for _, s := range m.Services { + l = len(s) + n += 1 + l + sovStorage(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetOperationsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Service) + if l > 0 { + n += 1 + l + sovStorage(uint64(l)) + } + l = len(m.SpanKind) + if l > 0 { + n += 1 + l + sovStorage(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Operation) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovStorage(uint64(l)) + } + l = len(m.SpanKind) + if l > 0 { + n += 1 + l + sovStorage(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetOperationsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.OperationNames) > 0 { + for _, s := range m.OperationNames { + l = len(s) + n += 1 + l + sovStorage(uint64(l)) + } + } + if len(m.Operations) > 0 { + for _, e := range m.Operations { + l = e.Size() + n += 1 + l + sovStorage(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceQueryParameters) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ServiceName) + if l > 0 { + n += 1 + l + sovStorage(uint64(l)) + } + l = len(m.OperationName) + if l > 0 { + n += 1 + l + sovStorage(uint64(l)) + } + if len(m.Tags) > 0 { + for k, v := range m.Tags { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovStorage(uint64(len(k))) + 1 + len(v) + sovStorage(uint64(len(v))) + n += mapEntrySize + 1 + sovStorage(uint64(mapEntrySize)) + } + } + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTimeMin) + n += 1 + l + sovStorage(uint64(l)) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTimeMax) + n += 1 + l + sovStorage(uint64(l)) + l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.DurationMin) + n += 1 + l + sovStorage(uint64(l)) + l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.DurationMax) + n += 1 + l + sovStorage(uint64(l)) + if m.NumTraces != 0 { + n += 1 + sovStorage(uint64(m.NumTraces)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *FindTracesRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Query != nil { + l = m.Query.Size() + n += 1 + l + sovStorage(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SpansResponseChunk) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Spans) > 0 { + for _, e := range m.Spans { + l = e.Size() + n += 1 + l + sovStorage(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *FindTraceIDsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Query != nil { + l = m.Query.Size() + n += 1 + l + sovStorage(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *FindTraceIDsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.TraceIDs) > 0 { + for _, e := range m.TraceIDs { + l = e.Size() + n += 1 + l + sovStorage(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Throughput) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Service) + if l > 0 { + n += 1 + l + sovStorage(uint64(l)) + } + l = len(m.Operation) + if l > 0 { + n += 1 + l + sovStorage(uint64(l)) + } + if m.Count != 0 { + n += 1 + sovStorage(uint64(m.Count)) + } + if len(m.Probabilities) > 0 { + n += 1 + sovStorage(uint64(len(m.Probabilities)*8)) + len(m.Probabilities)*8 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *InsertThroughputRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Throughput) > 0 { + for _, e := range m.Throughput { + l = e.Size() + n += 1 + l + sovStorage(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *InsertThroughputResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StringFloatMap) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.StringFloatMap) > 0 { + for k, v := range m.StringFloatMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovStorage(uint64(len(k))) + 1 + 8 + n += mapEntrySize + 1 + sovStorage(uint64(mapEntrySize)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ServiceOperationProbabilities) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.ServiceOperationProbabilities) > 0 { + for k, v := range m.ServiceOperationProbabilities { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + l += 1 + sovStorage(uint64(l)) + } + mapEntrySize := 1 + len(k) + sovStorage(uint64(len(k))) + l + n += mapEntrySize + 1 + sovStorage(uint64(mapEntrySize)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ServiceOperationQPS) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.ServiceOperationQPS) > 0 { + for k, v := range m.ServiceOperationQPS { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + l += 1 + sovStorage(uint64(l)) + } + mapEntrySize := 1 + len(k) + sovStorage(uint64(len(k))) + l + n += mapEntrySize + 1 + sovStorage(uint64(mapEntrySize)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *InsertProbabilitiesAndQPSRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Hostname) + if l > 0 { + n += 1 + l + sovStorage(uint64(l)) + } + if m.Probabilities != nil { + l = m.Probabilities.Size() + n += 1 + l + sovStorage(uint64(l)) + } + if m.Qps != nil { + l = m.Qps.Size() + n += 1 + l + sovStorage(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *InsertProbabilitiesAndQPSResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetThroughputRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime) + n += 1 + l + sovStorage(uint64(l)) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime) + n += 1 + l + sovStorage(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetThroughputResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Throughput) > 0 { + for _, e := range m.Throughput { + l = e.Size() + n += 1 + l + sovStorage(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetLatestProbabilitiesRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetLatestProbabilitiesResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ServiceOperationProbabilities != nil { + l = m.ServiceOperationProbabilities.Size() + n += 1 + l + sovStorage(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CapabilitiesRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CapabilitiesResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ArchiveSpanReader { + n += 2 + } + if m.ArchiveSpanWriter { + n += 2 + } + if m.StreamingSpanWriter { + n += 2 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovStorage(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozStorage(x uint64) (n int) { return sovStorage(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } -func (m *GetDependenciesRequest) Unmarshal(dAtA []byte) error { +func (m *GetDependenciesRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetDependenciesRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetDependenciesRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStorage + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StartTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EndTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStorage + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.EndTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetDependenciesResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetDependenciesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetDependenciesResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Dependencies", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStorage + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Dependencies = append(m.Dependencies, model.DependencyLink{}) + if err := m.Dependencies[len(m.Dependencies)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WriteSpanRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: WriteSpanRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WriteSpanRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Span", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStorage + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Span == nil { + m.Span = &model.Span{} + } + if err := m.Span.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WriteSpanResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: WriteSpanResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WriteSpanResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CloseWriterRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CloseWriterRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CloseWriterRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CloseWriterResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CloseWriterResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CloseWriterResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetTraceRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetTraceRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetTraceRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TraceID", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthStorage + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.TraceID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStorage + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StartTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EndTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStorage + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.EndTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetServicesRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetServicesRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetServicesRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetServicesResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetServicesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetServicesResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Services", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + 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 ErrInvalidLengthStorage + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Services = append(m.Services, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetOperationsRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetOperationsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetOperationsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Service", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + 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 ErrInvalidLengthStorage + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Service = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SpanKind", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + 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 ErrInvalidLengthStorage + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SpanKind = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Operation) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Operation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Operation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + 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 ErrInvalidLengthStorage + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SpanKind", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + 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 ErrInvalidLengthStorage + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SpanKind = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetOperationsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetOperationsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetOperationsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OperationNames", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + 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 ErrInvalidLengthStorage + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OperationNames = append(m.OperationNames, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Operations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStorage + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Operations = append(m.Operations, &Operation{}) + if err := m.Operations[len(m.Operations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceQueryParameters) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3072,28 +5690,92 @@ func (m *GetDependenciesRequest) Unmarshal(dAtA []byte) error { if shift >= 64 { return ErrIntOverflowStorage } - if iNdEx >= l { - return io.ErrUnexpectedEOF + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TraceQueryParameters: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TraceQueryParameters: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + 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 ErrInvalidLengthStorage + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ServiceName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OperationName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + 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 ErrInvalidLengthStorage + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStorage } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if postIndex > l { + return io.ErrUnexpectedEOF } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: GetDependenciesRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: GetDependenciesRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + m.OperationName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Tags", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -3120,13 +5802,107 @@ func (m *GetDependenciesRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StartTime, dAtA[iNdEx:postIndex]); err != nil { - return err + if m.Tags == nil { + m.Tags = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthStorage + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthStorage + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthStorage + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return ErrInvalidLengthStorage + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } } + m.Tags[mapkey] = mapvalue iNdEx = postIndex - case 2: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EndTime", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StartTimeMin", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -3153,64 +5929,79 @@ func (m *GetDependenciesRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.EndTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StartTimeMin, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipStorage(dAtA[iNdEx:]) - if err != nil { - return err + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartTimeMax", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { return ErrInvalidLengthStorage } - if (iNdEx + skippy) > l { + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { return io.ErrUnexpectedEOF } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *GetDependenciesResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStorage + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StartTimeMax, dAtA[iNdEx:postIndex]); err != nil { + return err } - if iNdEx >= l { + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DurationMin", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStorage + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.DurationMin, dAtA[iNdEx:postIndex]); err != nil { + return err } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: GetDependenciesResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: GetDependenciesResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + iNdEx = postIndex + case 7: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Dependencies", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DurationMax", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -3237,11 +6028,29 @@ func (m *GetDependenciesResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Dependencies = append(m.Dependencies, model.DependencyLink{}) - if err := m.Dependencies[len(m.Dependencies)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.DurationMax, dAtA[iNdEx:postIndex]); err != nil { return err } - iNdEx = postIndex + iNdEx = postIndex + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NumTraces", wireType) + } + m.NumTraces = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NumTraces |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipStorage(dAtA[iNdEx:]) @@ -3264,7 +6073,7 @@ func (m *GetDependenciesResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *WriteSpanRequest) Unmarshal(dAtA []byte) error { +func (m *FindTracesRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3287,15 +6096,15 @@ func (m *WriteSpanRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: WriteSpanRequest: wiretype end group for non-group") + return fmt.Errorf("proto: FindTracesRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: WriteSpanRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: FindTracesRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Span", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -3322,10 +6131,10 @@ func (m *WriteSpanRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Span == nil { - m.Span = &model.Span{} + if m.Query == nil { + m.Query = &TraceQueryParameters{} } - if err := m.Span.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Query.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -3351,7 +6160,7 @@ func (m *WriteSpanRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *WriteSpanResponse) Unmarshal(dAtA []byte) error { +func (m *SpansResponseChunk) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3374,114 +6183,46 @@ func (m *WriteSpanResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: WriteSpanResponse: wiretype end group for non-group") + return fmt.Errorf("proto: SpansResponseChunk: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: WriteSpanResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SpansResponseChunk: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - default: - iNdEx = preIndex - skippy, err := skipStorage(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthStorage - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *CloseWriterRequest) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStorage - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spans", wireType) } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: CloseWriterRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: CloseWriterRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - default: - iNdEx = preIndex - skippy, err := skipStorage(dAtA[iNdEx:]) - if err != nil { - return err + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - if (skippy < 0) || (iNdEx+skippy) < 0 { + if msglen < 0 { return ErrInvalidLengthStorage } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *CloseWriterResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStorage + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStorage } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + m.Spans = append(m.Spans, model.Span{}) + if err := m.Spans[len(m.Spans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: CloseWriterResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: CloseWriterResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipStorage(dAtA[iNdEx:]) @@ -3504,7 +6245,7 @@ func (m *CloseWriterResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetTraceRequest) Unmarshal(dAtA []byte) error { +func (m *FindTraceIDsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3527,48 +6268,15 @@ func (m *GetTraceRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetTraceRequest: wiretype end group for non-group") + return fmt.Errorf("proto: FindTraceIDsRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetTraceRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: FindTraceIDsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TraceID", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStorage - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthStorage - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthStorage - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.TraceID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -3595,40 +6303,10 @@ func (m *GetTraceRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StartTime, dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EndTime", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStorage - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthStorage - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthStorage - } - if postIndex > l { - return io.ErrUnexpectedEOF + if m.Query == nil { + m.Query = &TraceQueryParameters{} } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.EndTime, dAtA[iNdEx:postIndex]); err != nil { + if err := m.Query.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -3654,7 +6332,7 @@ func (m *GetTraceRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetServicesRequest) Unmarshal(dAtA []byte) error { +func (m *FindTraceIDsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3677,12 +6355,47 @@ func (m *GetServicesRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetServicesRequest: wiretype end group for non-group") + return fmt.Errorf("proto: FindTraceIDsResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetServicesRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: FindTraceIDsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TraceIDs", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthStorage + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_jaegertracing_jaeger_model.TraceID + m.TraceIDs = append(m.TraceIDs, v) + if err := m.TraceIDs[len(m.TraceIDs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipStorage(dAtA[iNdEx:]) @@ -3705,7 +6418,7 @@ func (m *GetServicesRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetServicesResponse) Unmarshal(dAtA []byte) error { +func (m *Throughput) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3728,15 +6441,15 @@ func (m *GetServicesResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetServicesResponse: wiretype end group for non-group") + return fmt.Errorf("proto: Throughput: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetServicesResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Throughput: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Services", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Service", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -3764,8 +6477,113 @@ func (m *GetServicesResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Services = append(m.Services, string(dAtA[iNdEx:postIndex])) + m.Service = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Operation", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + 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 ErrInvalidLengthStorage + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Operation = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType) + } + m.Count = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Count |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType == 1 { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + v2 := float64(math.Float64frombits(v)) + m.Probabilities = append(m.Probabilities, v2) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthStorage + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + elementCount = packedLen / 8 + if elementCount != 0 && len(m.Probabilities) == 0 { + m.Probabilities = make([]float64, 0, elementCount) + } + for iNdEx < postIndex { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + v2 := float64(math.Float64frombits(v)) + m.Probabilities = append(m.Probabilities, v2) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Probabilities", wireType) + } default: iNdEx = preIndex skippy, err := skipStorage(dAtA[iNdEx:]) @@ -3788,7 +6606,7 @@ func (m *GetServicesResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetOperationsRequest) Unmarshal(dAtA []byte) error { +func (m *InsertThroughputRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3811,17 +6629,17 @@ func (m *GetOperationsRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetOperationsRequest: wiretype end group for non-group") + return fmt.Errorf("proto: InsertThroughputRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetOperationsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: InsertThroughputRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Service", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Throughput", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStorage @@ -3831,56 +6649,77 @@ func (m *GetOperationsRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthStorage } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthStorage } if postIndex > l { return io.ErrUnexpectedEOF } - m.Service = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SpanKind", wireType) + m.Throughput = append(m.Throughput, &Throughput{}) + if err := m.Throughput[len(m.Throughput)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStorage - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err } - intStringLen := int(stringLen) - if intStringLen < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthStorage } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthStorage + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF } - if postIndex > l { + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *InsertThroughputResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { return io.ErrUnexpectedEOF } - m.SpanKind = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: InsertThroughputResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: InsertThroughputResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { default: iNdEx = preIndex skippy, err := skipStorage(dAtA[iNdEx:]) @@ -3903,7 +6742,7 @@ func (m *GetOperationsRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *Operation) Unmarshal(dAtA []byte) error { +func (m *StringFloatMap) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3926,17 +6765,17 @@ func (m *Operation) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Operation: wiretype end group for non-group") + return fmt.Errorf("proto: StringFloatMap: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Operation: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: StringFloatMap: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StringFloatMap", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStorage @@ -3946,55 +6785,97 @@ func (m *Operation) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthStorage } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthStorage } if postIndex > l { return io.ErrUnexpectedEOF } - m.Name = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SpanKind", wireType) + if m.StringFloatMap == nil { + m.StringFloatMap = make(map[string]float64) } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStorage - } - if iNdEx >= l { - return io.ErrUnexpectedEOF + var mapkey string + var mapvalue float64 + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthStorage + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthStorage + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var mapvaluetemp uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + mapvaluetemp = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + mapvalue = math.Float64frombits(mapvaluetemp) + } else { + iNdEx = entryPreIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthStorage - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthStorage - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.SpanKind = string(dAtA[iNdEx:postIndex]) + m.StringFloatMap[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex @@ -4018,7 +6899,7 @@ func (m *Operation) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetOperationsResponse) Unmarshal(dAtA []byte) error { +func (m *ServiceOperationProbabilities) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4041,47 +6922,15 @@ func (m *GetOperationsResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetOperationsResponse: wiretype end group for non-group") + return fmt.Errorf("proto: ServiceOperationProbabilities: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetOperationsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ServiceOperationProbabilities: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field OperationNames", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStorage - } - 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 ErrInvalidLengthStorage - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthStorage - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.OperationNames = append(m.OperationNames, string(dAtA[iNdEx:postIndex])) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Operations", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ServiceOperationProbabilities", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4108,10 +6957,105 @@ func (m *GetOperationsResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Operations = append(m.Operations, &Operation{}) - if err := m.Operations[len(m.Operations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + if m.ServiceOperationProbabilities == nil { + m.ServiceOperationProbabilities = make(map[string]*StringFloatMap) + } + var mapkey string + var mapvalue *StringFloatMap + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthStorage + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthStorage + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthStorage + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return ErrInvalidLengthStorage + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = &StringFloatMap{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } } + m.ServiceOperationProbabilities[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex @@ -4135,7 +7079,7 @@ func (m *GetOperationsResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *TraceQueryParameters) Unmarshal(dAtA []byte) error { +func (m *ServiceOperationQPS) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4158,79 +7102,15 @@ func (m *TraceQueryParameters) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: TraceQueryParameters: wiretype end group for non-group") + return fmt.Errorf("proto: ServiceOperationQPS: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: TraceQueryParameters: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ServiceOperationQPS: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStorage - } - 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 ErrInvalidLengthStorage - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthStorage - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ServiceName = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field OperationName", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStorage - } - 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 ErrInvalidLengthStorage - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthStorage - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.OperationName = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Tags", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ServiceOperationQPS", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4257,11 +7137,11 @@ func (m *TraceQueryParameters) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Tags == nil { - m.Tags = make(map[string]string) + if m.ServiceOperationQPS == nil { + m.ServiceOperationQPS = make(map[string]*StringFloatMap) } var mapkey string - var mapvalue string + var mapvalue *StringFloatMap for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 @@ -4310,7 +7190,7 @@ func (m *TraceQueryParameters) Unmarshal(dAtA []byte) error { mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { - var stringLenmapvalue uint64 + var mapmsglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStorage @@ -4320,79 +7200,99 @@ func (m *TraceQueryParameters) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLenmapvalue |= uint64(b&0x7F) << shift + mapmsglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLenmapvalue := int(stringLenmapvalue) - if intStringLenmapvalue < 0 { - return ErrInvalidLengthStorage - } - postStringIndexmapvalue := iNdEx + intStringLenmapvalue - if postStringIndexmapvalue < 0 { + if mapmsglen < 0 { return ErrInvalidLengthStorage } - if postStringIndexmapvalue > l { - return io.ErrUnexpectedEOF - } - mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) - iNdEx = postStringIndexmapvalue - } else { - iNdEx = entryPreIndex - skippy, err := skipStorage(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { return ErrInvalidLengthStorage } - if (iNdEx + skippy) > postIndex { + if postmsgIndex > l { return io.ErrUnexpectedEOF } - iNdEx += skippy - } - } - m.Tags[mapkey] = mapvalue - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StartTimeMin", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStorage - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break + mapvalue = &StringFloatMap{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy } } - if msglen < 0 { - return ErrInvalidLengthStorage + m.ServiceOperationQPS[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err } - postIndex := iNdEx + msglen - if postIndex < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthStorage } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StartTimeMin, dAtA[iNdEx:postIndex]); err != nil { - return err + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *InsertProbabilitiesAndQPSRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage } - iNdEx = postIndex - case 5: + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: InsertProbabilitiesAndQPSRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: InsertProbabilitiesAndQPSRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StartTimeMax", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStorage @@ -4402,28 +7302,27 @@ func (m *TraceQueryParameters) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthStorage } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthStorage } if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StartTimeMax, dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Hostname = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 6: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DurationMin", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Probabilities", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4450,13 +7349,16 @@ func (m *TraceQueryParameters) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.DurationMin, dAtA[iNdEx:postIndex]); err != nil { + if m.Probabilities == nil { + m.Probabilities = &ServiceOperationProbabilities{} + } + if err := m.Probabilities.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 7: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DurationMax", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Qps", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4483,29 +7385,64 @@ func (m *TraceQueryParameters) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.DurationMax, dAtA[iNdEx:postIndex]); err != nil { + if m.Qps == nil { + m.Qps = &ServiceOperationQPS{} + } + if err := m.Qps.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 8: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field NumTraces", wireType) + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err } - m.NumTraces = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStorage - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.NumTraces |= int32(b&0x7F) << shift - if b < 0x80 { - break - } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *InsertProbabilitiesAndQPSResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: InsertProbabilitiesAndQPSResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: InsertProbabilitiesAndQPSResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { default: iNdEx = preIndex skippy, err := skipStorage(dAtA[iNdEx:]) @@ -4528,7 +7465,7 @@ func (m *TraceQueryParameters) Unmarshal(dAtA []byte) error { } return nil } -func (m *FindTracesRequest) Unmarshal(dAtA []byte) error { +func (m *GetThroughputRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4551,15 +7488,15 @@ func (m *FindTracesRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: FindTracesRequest: wiretype end group for non-group") + return fmt.Errorf("proto: GetThroughputRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: FindTracesRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetThroughputRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4586,10 +7523,40 @@ func (m *FindTracesRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Query == nil { - m.Query = &TraceQueryParameters{} + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StartTime, dAtA[iNdEx:postIndex]); err != nil { + return err } - if err := m.Query.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EndTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStorage + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.EndTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -4615,7 +7582,7 @@ func (m *FindTracesRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *SpansResponseChunk) Unmarshal(dAtA []byte) error { +func (m *GetThroughputResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4638,15 +7605,15 @@ func (m *SpansResponseChunk) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SpansResponseChunk: wiretype end group for non-group") + return fmt.Errorf("proto: GetThroughputResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SpansResponseChunk: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetThroughputResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Spans", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Throughput", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4673,8 +7640,8 @@ func (m *SpansResponseChunk) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Spans = append(m.Spans, model.Span{}) - if err := m.Spans[len(m.Spans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Throughput = append(m.Throughput, &Throughput{}) + if err := m.Throughput[len(m.Throughput)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -4700,7 +7667,7 @@ func (m *SpansResponseChunk) Unmarshal(dAtA []byte) error { } return nil } -func (m *FindTraceIDsRequest) Unmarshal(dAtA []byte) error { +func (m *GetLatestProbabilitiesRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4723,48 +7690,12 @@ func (m *FindTraceIDsRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: FindTraceIDsRequest: wiretype end group for non-group") + return fmt.Errorf("proto: GetLatestProbabilitiesRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: FindTraceIDsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetLatestProbabilitiesRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStorage - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthStorage - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthStorage - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Query == nil { - m.Query = &TraceQueryParameters{} - } - if err := m.Query.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipStorage(dAtA[iNdEx:]) @@ -4787,7 +7718,7 @@ func (m *FindTraceIDsRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *FindTraceIDsResponse) Unmarshal(dAtA []byte) error { +func (m *GetLatestProbabilitiesResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4810,17 +7741,17 @@ func (m *FindTraceIDsResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: FindTraceIDsResponse: wiretype end group for non-group") + return fmt.Errorf("proto: GetLatestProbabilitiesResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: FindTraceIDsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetLatestProbabilitiesResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TraceIDs", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ServiceOperationProbabilities", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStorage @@ -4830,24 +7761,25 @@ func (m *FindTraceIDsResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthStorage } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthStorage } if postIndex > l { return io.ErrUnexpectedEOF } - var v github_com_jaegertracing_jaeger_model.TraceID - m.TraceIDs = append(m.TraceIDs, v) - if err := m.TraceIDs[len(m.TraceIDs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.ServiceOperationProbabilities == nil { + m.ServiceOperationProbabilities = &ServiceOperationProbabilities{} + } + if err := m.ServiceOperationProbabilities.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex