diff --git a/Gopkg.lock b/Gopkg.lock index 38397d3abb2..f9660795119 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -271,14 +271,14 @@ revision = "181004e14a3fb735efcc826a4256369d0c96747b" [[projects]] - digest = "1:08fc980336305dcf34156af60e58073ba8326437d64d027fe624fdd9c4ff0ae6" + digest = "1:b066682d13a181fe2d34f55e0d05cb53211884725d55bc19468edcc61b8e9290" name = "github.com/gogo/googleapis" packages = ["google/api"] - pruneopts = "UT" + pruneopts = "T" revision = "b23578765ee54ff6bceff57f397d833bf4ca6869" [[projects]] - digest = "1:2d91858167615bbc9f642045d8f7e38a16b346fcc2523f9dc75b6da4d8b3397c" + digest = "1:c6e109ed32d266dea072dd6d00e3ee26fb960f86ed0ba7f6a07e5d2bfdeab868" name = "github.com/gogo/protobuf" packages = [ "gogoproto", @@ -311,7 +311,7 @@ "vanity", "vanity/command", ] - pruneopts = "UT" + pruneopts = "T" revision = "ba06b47c162d49f2af050fb4c75bcbc86a159d5c" [[projects]] @@ -381,7 +381,7 @@ version = "v1.0.0" [[projects]] - digest = "1:e4f2416beca662090d5cfc9489208e9d7e3c17dee87e4fe2c5f2c8fe3cb71aa8" + digest = "1:babeeaa91ba4ba96ad36f520899ed27bb0120c9f617f75dda0ad3227e91eecac" name = "github.com/grpc-ecosystem/grpc-gateway" packages = [ "codegenerator", @@ -397,7 +397,7 @@ "runtime", "utilities", ] - pruneopts = "UT" + pruneopts = "T" revision = "b7a5640779183161e8d6c3e51f60f0859b5559ba" version = "v1.7.0" diff --git a/Gopkg.toml b/Gopkg.toml index baece65950b..5295d785a14 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -118,6 +118,18 @@ required = [ [prune] go-tests = true unused-packages = true + [[prune.project]] + name = "github.com/gogo/protobuf" + non-go = false + unused-packages = false + [[prune.project]] + name = "github.com/grpc-ecosystem/grpc-gateway" + non-go = false + unused-packages = false + [[prune.project]] + name = "github.com/gogo/googleapis" + non-go = false + unused-packages = false [[constraint]] name = "github.com/Shopify/sarama" diff --git a/Makefile b/Makefile index 6c4f5ed7ee3..41a46bb2cfc 100644 --- a/Makefile +++ b/Makefile @@ -11,6 +11,7 @@ ALL_SRC := $(shell find . -name '*.go' \ -not -name '*_test.go' \ -not -name 'model.pb.go' \ -not -name 'model_test.pb.go' \ + -not -name 'storage_test.pb.go' \ -not -path './examples/*' \ -not -path './vendor/*' \ -not -path '*/mocks/*' \ @@ -337,9 +338,11 @@ PROTO_INCLUDES := \ -I model/proto \ -I vendor/github.com/grpc-ecosystem/grpc-gateway \ -I vendor/github.com/gogo/googleapis \ + -I vendor/github.com/gogo/protobuf/protobuf \ -I vendor/github.com/gogo/protobuf # Remapping of std types to gogo types (must not contain spaces) PROTO_GOGO_MAPPINGS := $(shell echo \ + Mgoogle/protobuf/descriptor.proto=github.com/gogo/protobuf/types, \ Mgoogle/protobuf/timestamp.proto=github.com/gogo/protobuf/types, \ Mgoogle/protobuf/duration.proto=github.com/gogo/protobuf/types, \ Mgoogle/protobuf/empty.proto=github.com/gogo/protobuf/types, \ @@ -347,9 +350,10 @@ PROTO_GOGO_MAPPINGS := $(shell echo \ Mmodel.proto=github.com/jaegertracing/jaeger/model \ | sed 's/ //g') + .PHONY: proto proto: - # Generate gogo, gRPC-Gateway, swagger, go-validators output. + # Generate gogo, gRPC-Gateway, swagger, go-validators, gRPC-storage-plugin output. # # -I declares import folders, in order of importance # This is how proto resolves the protofile imports. @@ -385,11 +389,23 @@ proto: --swagger_out=allow_merge=true:$(PWD)/proto-gen/openapi/ \ model/proto/api_v2/*.proto + $(PROTOC) \ + $(PROTO_INCLUDES) \ + -I plugin/storage/grpc/proto \ + --gogo_out=plugins=grpc,$(PROTO_GOGO_MAPPINGS):$(PWD)/proto-gen/storage_v1 \ + plugin/storage/grpc/proto/storage.proto + $(PROTOC) \ -I model/proto \ --go_out=$(PWD)/model/prototest/ \ model/proto/model_test.proto + $(PROTOC) \ + -I plugin/storage/grpc/proto \ + --go_out=$(PWD)/plugin/storage/grpc/proto/storageprototest/ \ + plugin/storage/grpc/proto/storage_test.proto + + .PHONY: proto-install proto-install: go get -u github.com/golang/glog diff --git a/model/dependencies.go b/model/dependencies.go index 7a33bf45201..00e18a9ad2b 100644 --- a/model/dependencies.go +++ b/model/dependencies.go @@ -14,22 +14,11 @@ package model -// DependencyLinkSource is the source of data used to generate the dependencies. -type DependencyLinkSource string - const ( // JaegerDependencyLinkSource describes a dependency diagram that was generated from Jaeger traces. - JaegerDependencyLinkSource = DependencyLinkSource("jaeger") + JaegerDependencyLinkSource = "jaeger" ) -// DependencyLink shows dependencies between services -type DependencyLink struct { - Parent string `json:"parent"` - Child string `json:"child"` - CallCount uint64 `json:"callCount"` - Source DependencyLinkSource `json:"source"` -} - // ApplyDefaults applies defaults to the DependencyLink. func (d DependencyLink) ApplyDefaults() DependencyLink { if d.Source == "" { diff --git a/model/dependencies_test.go b/model/dependencies_test.go index 5ec933e7a0f..61b9d1ce46d 100644 --- a/model/dependencies_test.go +++ b/model/dependencies_test.go @@ -24,7 +24,7 @@ func TestDependencyLinkApplyDefaults(t *testing.T) { dl := DependencyLink{}.ApplyDefaults() assert.Equal(t, JaegerDependencyLinkSource, dl.Source) - networkSource := DependencyLinkSource("network") + networkSource := "network" dl = DependencyLink{Source: networkSource}.ApplyDefaults() assert.Equal(t, networkSource, dl.Source) } diff --git a/model/model.pb.go b/model/model.pb.go index 48005005910..ca5bf9926cc 100644 --- a/model/model.pb.go +++ b/model/model.pb.go @@ -631,6 +631,77 @@ func (m *Batch) GetProcess() *Process { return nil } +type DependencyLink struct { + Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"` + Child string `protobuf:"bytes,2,opt,name=child,proto3" json:"child,omitempty"` + CallCount uint64 `protobuf:"varint,3,opt,name=call_count,json=callCount,proto3" json:"call_count,omitempty"` + Source string `protobuf:"bytes,4,opt,name=source,proto3" json:"source,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DependencyLink) Reset() { *m = DependencyLink{} } +func (m *DependencyLink) String() string { return proto.CompactTextString(m) } +func (*DependencyLink) ProtoMessage() {} +func (*DependencyLink) Descriptor() ([]byte, []int) { + return fileDescriptor_4c16552f9fdb66d8, []int{7} +} +func (m *DependencyLink) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DependencyLink) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DependencyLink.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *DependencyLink) XXX_Merge(src proto.Message) { + xxx_messageInfo_DependencyLink.Merge(m, src) +} +func (m *DependencyLink) XXX_Size() int { + return m.Size() +} +func (m *DependencyLink) XXX_DiscardUnknown() { + xxx_messageInfo_DependencyLink.DiscardUnknown(m) +} + +var xxx_messageInfo_DependencyLink proto.InternalMessageInfo + +func (m *DependencyLink) GetParent() string { + if m != nil { + return m.Parent + } + return "" +} + +func (m *DependencyLink) GetChild() string { + if m != nil { + return m.Child + } + return "" +} + +func (m *DependencyLink) GetCallCount() uint64 { + if m != nil { + return m.CallCount + } + return 0 +} + +func (m *DependencyLink) GetSource() string { + if m != nil { + return m.Source + } + return "" +} + func init() { proto.RegisterEnum("jaeger.api_v2.ValueType", ValueType_name, ValueType_value) golang_proto.RegisterEnum("jaeger.api_v2.ValueType", ValueType_name, ValueType_value) @@ -652,70 +723,76 @@ func init() { golang_proto.RegisterType((*Trace_ProcessMapping)(nil), "jaeger.api_v2.Trace.ProcessMapping") proto.RegisterType((*Batch)(nil), "jaeger.api_v2.Batch") golang_proto.RegisterType((*Batch)(nil), "jaeger.api_v2.Batch") + proto.RegisterType((*DependencyLink)(nil), "jaeger.api_v2.DependencyLink") + golang_proto.RegisterType((*DependencyLink)(nil), "jaeger.api_v2.DependencyLink") } func init() { proto.RegisterFile("model.proto", fileDescriptor_4c16552f9fdb66d8) } func init() { golang_proto.RegisterFile("model.proto", fileDescriptor_4c16552f9fdb66d8) } var fileDescriptor_4c16552f9fdb66d8 = []byte{ - // 905 bytes of a gzipped FileDescriptorProto + // 975 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0x41, 0x8f, 0xdb, 0x44, - 0x14, 0xde, 0x49, 0xec, 0xd8, 0x79, 0x49, 0x56, 0xd1, 0x14, 0x58, 0x37, 0xa0, 0x24, 0xa4, 0x42, - 0x0a, 0x55, 0x49, 0xda, 0xd0, 0xee, 0x01, 0x21, 0xa1, 0xba, 0x4b, 0xc0, 0x90, 0xdd, 0xa0, 0xd9, - 0x08, 0x04, 0x17, 0x6b, 0x36, 0x99, 0x18, 0x17, 0xc7, 0x63, 0xd9, 0x5e, 0xa3, 0xdc, 0xf8, 0x09, - 0x88, 0x13, 0x47, 0xb8, 0xf2, 0x2b, 0x38, 0xf6, 0xc8, 0x81, 0x13, 0x12, 0x0b, 0x0a, 0x97, 0xfe, - 0x0c, 0x34, 0xe3, 0x71, 0xb6, 0x1b, 0x2a, 0xd8, 0x5e, 0x38, 0x79, 0x66, 0xde, 0xf7, 0xde, 0x7c, - 0xef, 0x7b, 0x9f, 0x6d, 0xa8, 0xad, 0xf8, 0x82, 0x05, 0x83, 0x28, 0xe6, 0x29, 0xc7, 0x8d, 0xc7, - 0x94, 0x79, 0x2c, 0x1e, 0xd0, 0xc8, 0x77, 0xb3, 0x51, 0xeb, 0x25, 0x8f, 0x7b, 0x5c, 0x46, 0x86, - 0x62, 0x95, 0x83, 0x5a, 0xaf, 0x79, 0x9c, 0x7b, 0x01, 0x1b, 0xd2, 0xc8, 0x1f, 0xd2, 0x30, 0xe4, - 0x29, 0x4d, 0x7d, 0x1e, 0x26, 0x2a, 0xda, 0x51, 0x51, 0xb9, 0x3b, 0x3b, 0x5f, 0x0e, 0x53, 0x7f, - 0xc5, 0x92, 0x94, 0xae, 0x22, 0x05, 0x68, 0xef, 0x02, 0x16, 0xe7, 0xb1, 0xac, 0x90, 0xc7, 0x7b, - 0xbf, 0x22, 0x30, 0x3f, 0x66, 0xeb, 0x4f, 0x69, 0x70, 0xce, 0x70, 0x13, 0xca, 0x5f, 0xb1, 0xb5, - 0x85, 0xba, 0xa8, 0x5f, 0x25, 0x62, 0x89, 0x87, 0x50, 0xc9, 0xdc, 0x74, 0x1d, 0x31, 0xab, 0xd4, - 0x45, 0xfd, 0xfd, 0x91, 0x35, 0xb8, 0xc2, 0x79, 0x20, 0xf3, 0x66, 0xeb, 0x88, 0x11, 0x3d, 0x13, - 0x0f, 0x7c, 0x03, 0xf4, 0xcc, 0x4d, 0xd2, 0xd8, 0x2a, 0xcb, 0x22, 0x5a, 0x76, 0x9a, 0xc6, 0xf8, - 0x65, 0x51, 0xe5, 0x8c, 0xf3, 0xc0, 0xd2, 0xba, 0xa8, 0x6f, 0x12, 0x3d, 0xb3, 0x39, 0x0f, 0xf0, - 0x01, 0x18, 0x99, 0xeb, 0x87, 0xe9, 0xe1, 0x7d, 0x4b, 0xef, 0xa2, 0x7e, 0x99, 0x54, 0x32, 0x47, - 0xec, 0xf0, 0xab, 0x50, 0xcd, 0xdc, 0x65, 0xc0, 0xa9, 0x08, 0x55, 0xba, 0xa8, 0x8f, 0x88, 0x99, - 0x8d, 0xf3, 0x3d, 0xbe, 0x09, 0x66, 0xe6, 0x9e, 0xf9, 0x21, 0x8d, 0xd7, 0x96, 0xd1, 0x45, 0xfd, - 0x3a, 0x31, 0x32, 0x5b, 0x6e, 0xdf, 0x31, 0x9f, 0xfe, 0xd0, 0x41, 0x4f, 0x7f, 0xec, 0xa0, 0xde, - 0x37, 0x08, 0xca, 0x13, 0xee, 0x61, 0x1b, 0xaa, 0x5b, 0x45, 0x64, 0x5f, 0xb5, 0x51, 0x6b, 0x90, - 0x4b, 0x32, 0x28, 0x24, 0x19, 0xcc, 0x0a, 0x84, 0x6d, 0x3e, 0xb9, 0xe8, 0xec, 0x7d, 0xfb, 0x47, - 0x07, 0x91, 0xcb, 0x34, 0xfc, 0x00, 0x2a, 0x4b, 0x9f, 0x05, 0x8b, 0xc4, 0x2a, 0x75, 0xcb, 0xfd, - 0xda, 0xe8, 0x60, 0x47, 0x83, 0x42, 0x3e, 0x5b, 0x13, 0xd9, 0x44, 0x81, 0x7b, 0x3f, 0x21, 0x30, - 0x4e, 0x23, 0x1a, 0x12, 0xb6, 0xc4, 0x0f, 0xc0, 0x4c, 0x63, 0x3a, 0x67, 0xae, 0xbf, 0x90, 0x2c, - 0xea, 0x76, 0x4b, 0x60, 0x7f, 0xbb, 0xe8, 0x18, 0x33, 0x71, 0xee, 0x1c, 0x6d, 0x2e, 0x97, 0xc4, - 0x90, 0x58, 0x67, 0x81, 0xef, 0x81, 0x91, 0x44, 0x34, 0x14, 0x59, 0x25, 0x99, 0x65, 0xa9, 0xac, - 0x8a, 0x28, 0x2c, 0x93, 0xd4, 0x8a, 0x54, 0x04, 0xd0, 0x59, 0x88, 0x9b, 0x62, 0xb6, 0xcc, 0x47, - 0x56, 0x96, 0x23, 0x6b, 0xed, 0xd0, 0x55, 0x9c, 0xe4, 0xd0, 0x8c, 0x38, 0x5f, 0xf4, 0x5c, 0x30, - 0x3e, 0x89, 0xf9, 0x9c, 0x25, 0x09, 0x7e, 0x1d, 0xea, 0x09, 0x8b, 0x33, 0x7f, 0xce, 0xdc, 0x90, - 0xae, 0x98, 0x72, 0x43, 0x4d, 0x9d, 0x9d, 0xd0, 0x15, 0xc3, 0xf7, 0x40, 0x4b, 0xa9, 0x77, 0x4d, - 0x3d, 0x24, 0xb4, 0xf7, 0xbb, 0x06, 0x9a, 0xb8, 0xf9, 0x7f, 0x94, 0xe2, 0x0d, 0xd8, 0xe7, 0x11, - 0xcb, 0xdd, 0x9e, 0xb7, 0x92, 0x7b, 0xb2, 0xb1, 0x3d, 0x95, 0xcd, 0xbc, 0x0b, 0x10, 0xb3, 0x25, - 0x8b, 0x59, 0x38, 0x67, 0x89, 0xa5, 0xc9, 0x96, 0x5e, 0x79, 0xbe, 0x66, 0xaa, 0xa3, 0x67, 0xf0, - 0xf8, 0x16, 0xe8, 0xcb, 0x40, 0x68, 0x21, 0x1c, 0xdc, 0xb0, 0x1b, 0x8a, 0x95, 0x3e, 0x16, 0x87, - 0x24, 0x8f, 0xe1, 0x47, 0x00, 0x49, 0x4a, 0xe3, 0xd4, 0x15, 0xa6, 0x92, 0x86, 0xbe, 0xb6, 0x0d, - 0x65, 0x9e, 0x88, 0xe0, 0xf7, 0xc0, 0x2c, 0xde, 0x5d, 0xe9, 0xfb, 0xda, 0xe8, 0xe6, 0x3f, 0x4a, - 0x1c, 0x29, 0x40, 0x5e, 0xe1, 0x7b, 0x51, 0x61, 0x9b, 0xb4, 0x9d, 0x9a, 0x79, 0xed, 0xa9, 0xe1, - 0x3b, 0xa0, 0x05, 0xdc, 0x4b, 0xac, 0xaa, 0x4c, 0xc1, 0x3b, 0x29, 0x13, 0xee, 0x15, 0x68, 0x81, - 0xc2, 0x77, 0xc1, 0x88, 0x72, 0x13, 0x59, 0x20, 0x09, 0xee, 0xca, 0xa8, 0x2c, 0x46, 0x0a, 0x18, - 0xbe, 0x03, 0xa0, 0x96, 0x62, 0xb0, 0x35, 0x31, 0x1e, 0xbb, 0xb1, 0xb9, 0xe8, 0x54, 0x15, 0xd2, - 0x39, 0x22, 0x55, 0x05, 0x70, 0x16, 0xb8, 0x05, 0xe6, 0xd7, 0x34, 0x0e, 0xfd, 0xd0, 0x4b, 0xac, - 0x7a, 0xb7, 0xdc, 0xaf, 0x92, 0xed, 0xbe, 0xf7, 0x5d, 0x09, 0x74, 0x69, 0x1a, 0xfc, 0x26, 0xe8, - 0xc2, 0x00, 0x89, 0x85, 0x24, 0xe9, 0x1b, 0xcf, 0x1b, 0x65, 0x8e, 0xc0, 0x1f, 0x41, 0xad, 0xb8, - 0x7e, 0x45, 0x23, 0x65, 0xe7, 0x5b, 0x3b, 0x09, 0xb2, 0x6a, 0x41, 0xfd, 0x98, 0x46, 0x91, 0x1f, - 0x16, 0x6d, 0x17, 0xe4, 0x8f, 0x69, 0x74, 0x85, 0x5c, 0xf9, 0x2a, 0xb9, 0x56, 0x06, 0xfb, 0x57, - 0xf3, 0x77, 0x1a, 0x47, 0xff, 0xd1, 0xf8, 0xe1, 0xa5, 0xb0, 0xa5, 0x7f, 0x13, 0x56, 0xd1, 0x2a, - 0xc0, 0xbd, 0xc7, 0xa0, 0xdb, 0x34, 0x9d, 0x7f, 0xf9, 0x22, 0x9a, 0xbc, 0xd0, 0x5d, 0x68, 0x7b, - 0xd7, 0xed, 0xf7, 0xa1, 0xba, 0xfd, 0x19, 0x60, 0x80, 0xca, 0xe9, 0x8c, 0x38, 0x27, 0x1f, 0x34, - 0xf7, 0xb0, 0x09, 0x9a, 0x3d, 0x9d, 0x4e, 0x9a, 0x08, 0x57, 0x41, 0x77, 0x4e, 0x66, 0x87, 0xf7, - 0x9b, 0x25, 0x5c, 0x03, 0x63, 0x3c, 0x99, 0x3e, 0x14, 0x9b, 0xb2, 0x40, 0xdb, 0xce, 0xc9, 0x43, - 0xf2, 0x79, 0x53, 0xbb, 0xfd, 0x16, 0xd4, 0x9e, 0xf9, 0x40, 0xe1, 0x3a, 0x98, 0x8f, 0x3e, 0x74, - 0x26, 0x47, 0xee, 0x74, 0xdc, 0xdc, 0xc3, 0x4d, 0xa8, 0x8f, 0xa7, 0x93, 0xc9, 0xf4, 0xb3, 0x53, - 0x77, 0x4c, 0xa6, 0xc7, 0x4d, 0x64, 0xdf, 0x7d, 0xb2, 0x69, 0xa3, 0x5f, 0x36, 0x6d, 0xf4, 0xe7, - 0xa6, 0x8d, 0x7e, 0xfe, 0xab, 0x8d, 0xe0, 0xc0, 0xe7, 0x8a, 0xb0, 0xf8, 0x74, 0xf8, 0xa1, 0xa7, - 0x78, 0x7f, 0xa1, 0xcb, 0x5f, 0xef, 0x59, 0x45, 0xbe, 0x2c, 0x6f, 0xff, 0x1d, 0x00, 0x00, 0xff, - 0xff, 0xc9, 0x46, 0x02, 0x11, 0x8a, 0x07, 0x00, 0x00, + 0x14, 0xde, 0x49, 0xec, 0xd8, 0x7e, 0xc9, 0xae, 0xa2, 0x69, 0xe9, 0xba, 0x01, 0x36, 0x21, 0x15, + 0x52, 0xa8, 0x4a, 0xb6, 0x5d, 0xda, 0x3d, 0x20, 0x24, 0x54, 0xef, 0x12, 0x08, 0x64, 0x37, 0x68, + 0x76, 0x05, 0x82, 0x8b, 0x35, 0xeb, 0x4c, 0x5c, 0xb7, 0x8e, 0xc7, 0xb2, 0x1d, 0xa3, 0xdc, 0xf8, + 0x09, 0x88, 0x13, 0x47, 0xb8, 0xf2, 0x2b, 0x38, 0xf6, 0xc8, 0x81, 0x13, 0x12, 0x0b, 0x0a, 0x97, + 0xfe, 0x0c, 0x34, 0xe3, 0x71, 0xb6, 0x1b, 0x2a, 0xd8, 0x5e, 0x7a, 0xf2, 0xbc, 0x79, 0xdf, 0x7b, + 0xf3, 0xde, 0xf7, 0xbe, 0xf1, 0x40, 0x7d, 0xc6, 0x27, 0x2c, 0xec, 0xc7, 0x09, 0xcf, 0x38, 0xde, + 0x7c, 0x4c, 0x99, 0xcf, 0x92, 0x3e, 0x8d, 0x03, 0x37, 0xdf, 0x6b, 0x5d, 0xf7, 0xb9, 0xcf, 0xa5, + 0x67, 0x57, 0xac, 0x0a, 0x50, 0xeb, 0x0d, 0x9f, 0x73, 0x3f, 0x64, 0xbb, 0x34, 0x0e, 0x76, 0x69, + 0x14, 0xf1, 0x8c, 0x66, 0x01, 0x8f, 0x52, 0xe5, 0x6d, 0x2b, 0xaf, 0xb4, 0xce, 0xe6, 0xd3, 0xdd, + 0x2c, 0x98, 0xb1, 0x34, 0xa3, 0xb3, 0x58, 0x01, 0x76, 0xd6, 0x01, 0x93, 0x79, 0x22, 0x33, 0x14, + 0xfe, 0xee, 0x6f, 0x08, 0xcc, 0xcf, 0xd8, 0xe2, 0x0b, 0x1a, 0xce, 0x19, 0x6e, 0x42, 0xf5, 0x09, + 0x5b, 0xd8, 0xa8, 0x83, 0x7a, 0x16, 0x11, 0x4b, 0xbc, 0x0b, 0xb5, 0xdc, 0xcd, 0x16, 0x31, 0xb3, + 0x2b, 0x1d, 0xd4, 0xdb, 0xda, 0xb3, 0xfb, 0x97, 0x6a, 0xee, 0xcb, 0xb8, 0xd3, 0x45, 0xcc, 0x88, + 0x9e, 0x8b, 0x0f, 0xbe, 0x06, 0x7a, 0xee, 0xa6, 0x59, 0x62, 0x57, 0x65, 0x12, 0x2d, 0x3f, 0xc9, + 0x12, 0xfc, 0x9a, 0xc8, 0x72, 0xc6, 0x79, 0x68, 0x6b, 0x1d, 0xd4, 0x33, 0x89, 0x9e, 0x3b, 0x9c, + 0x87, 0x78, 0x1b, 0x8c, 0xdc, 0x0d, 0xa2, 0x6c, 0xff, 0xbe, 0xad, 0x77, 0x50, 0xaf, 0x4a, 0x6a, + 0xf9, 0x50, 0x58, 0xf8, 0x75, 0xb0, 0x72, 0x77, 0x1a, 0x72, 0x2a, 0x5c, 0xb5, 0x0e, 0xea, 0x21, + 0x62, 0xe6, 0x83, 0xc2, 0xc6, 0x37, 0xc1, 0xcc, 0xdd, 0xb3, 0x20, 0xa2, 0xc9, 0xc2, 0x36, 0x3a, + 0xa8, 0xd7, 0x20, 0x46, 0xee, 0x48, 0xf3, 0x7d, 0xf3, 0xd9, 0x8f, 0x6d, 0xf4, 0xec, 0xa7, 0x36, + 0xea, 0x7e, 0x8b, 0xa0, 0x3a, 0xe2, 0x3e, 0x76, 0xc0, 0x5a, 0x31, 0x22, 0xfb, 0xaa, 0xef, 0xb5, + 0xfa, 0x05, 0x25, 0xfd, 0x92, 0x92, 0xfe, 0x69, 0x89, 0x70, 0xcc, 0xa7, 0xe7, 0xed, 0x8d, 0xef, + 0xfe, 0x6c, 0x23, 0x72, 0x11, 0x86, 0x1f, 0x40, 0x6d, 0x1a, 0xb0, 0x70, 0x92, 0xda, 0x95, 0x4e, + 0xb5, 0x57, 0xdf, 0xdb, 0x5e, 0xe3, 0xa0, 0xa4, 0xcf, 0xd1, 0x44, 0x34, 0x51, 0xe0, 0xee, 0xcf, + 0x08, 0x8c, 0x93, 0x98, 0x46, 0x84, 0x4d, 0xf1, 0x03, 0x30, 0xb3, 0x84, 0x7a, 0xcc, 0x0d, 0x26, + 0xb2, 0x8a, 0x86, 0xd3, 0x12, 0xd8, 0xdf, 0xcf, 0xdb, 0xc6, 0xa9, 0xd8, 0x1f, 0x1e, 0x2e, 0x2f, + 0x96, 0xc4, 0x90, 0xd8, 0xe1, 0x04, 0xdf, 0x03, 0x23, 0x8d, 0x69, 0x24, 0xa2, 0x2a, 0x32, 0xca, + 0x56, 0x51, 0x35, 0x91, 0x58, 0x06, 0xa9, 0x15, 0xa9, 0x09, 0xe0, 0x70, 0x22, 0x4e, 0x4a, 0xd8, + 0xb4, 0x18, 0x59, 0x55, 0x8e, 0xac, 0xb5, 0x56, 0xae, 0xaa, 0x49, 0x0e, 0xcd, 0x48, 0x8a, 0x45, + 0xd7, 0x05, 0xe3, 0xf3, 0x84, 0x7b, 0x2c, 0x4d, 0xf1, 0x5b, 0xd0, 0x48, 0x59, 0x92, 0x07, 0x1e, + 0x73, 0x23, 0x3a, 0x63, 0x4a, 0x0d, 0x75, 0xb5, 0x77, 0x4c, 0x67, 0x0c, 0xdf, 0x03, 0x2d, 0xa3, + 0xfe, 0x15, 0xf9, 0x90, 0xd0, 0xee, 0x1f, 0x1a, 0x68, 0xe2, 0xe4, 0x57, 0x48, 0xc5, 0xdb, 0xb0, + 0xc5, 0x63, 0x56, 0xa8, 0xbd, 0x68, 0xa5, 0xd0, 0xe4, 0xe6, 0x6a, 0x57, 0x36, 0xf3, 0x01, 0x40, + 0xc2, 0xa6, 0x2c, 0x61, 0x91, 0xc7, 0x52, 0x5b, 0x93, 0x2d, 0xdd, 0x78, 0x31, 0x67, 0xaa, 0xa3, + 0xe7, 0xf0, 0xf8, 0x16, 0xe8, 0xd3, 0x50, 0x70, 0x21, 0x14, 0xbc, 0xe9, 0x6c, 0xaa, 0xaa, 0xf4, + 0x81, 0xd8, 0x24, 0x85, 0x0f, 0x1f, 0x00, 0xa4, 0x19, 0x4d, 0x32, 0x57, 0x88, 0x4a, 0x0a, 0xfa, + 0xca, 0x32, 0x94, 0x71, 0xc2, 0x83, 0x3f, 0x04, 0xb3, 0xbc, 0xbb, 0x52, 0xf7, 0xf5, 0xbd, 0x9b, + 0xff, 0x4a, 0x71, 0xa8, 0x00, 0x45, 0x86, 0x1f, 0x44, 0x86, 0x55, 0xd0, 0x6a, 0x6a, 0xe6, 0x95, + 0xa7, 0x86, 0xef, 0x80, 0x16, 0x72, 0x3f, 0xb5, 0x2d, 0x19, 0x82, 0xd7, 0x42, 0x46, 0xdc, 0x2f, + 0xd1, 0x02, 0x85, 0xef, 0x82, 0x11, 0x17, 0x22, 0xb2, 0x41, 0x16, 0xb8, 0x4e, 0xa3, 0x92, 0x18, + 0x29, 0x61, 0xf8, 0x0e, 0x80, 0x5a, 0x8a, 0xc1, 0xd6, 0xc5, 0x78, 0x9c, 0xcd, 0xe5, 0x79, 0xdb, + 0x52, 0xc8, 0xe1, 0x21, 0xb1, 0x14, 0x60, 0x38, 0xc1, 0x2d, 0x30, 0xbf, 0xa1, 0x49, 0x14, 0x44, + 0x7e, 0x6a, 0x37, 0x3a, 0xd5, 0x9e, 0x45, 0x56, 0x76, 0xf7, 0xfb, 0x0a, 0xe8, 0x52, 0x34, 0xf8, + 0x1d, 0xd0, 0x85, 0x00, 0x52, 0x1b, 0xc9, 0xa2, 0xaf, 0xbd, 0x68, 0x94, 0x05, 0x02, 0x7f, 0x0a, + 0xf5, 0xf2, 0xf8, 0x19, 0x8d, 0x95, 0x9c, 0x6f, 0xad, 0x05, 0xc8, 0xac, 0x65, 0xe9, 0x47, 0x34, + 0x8e, 0x83, 0xa8, 0x6c, 0xbb, 0x2c, 0xfe, 0x88, 0xc6, 0x97, 0x8a, 0xab, 0x5e, 0x2e, 0xae, 0x95, + 0xc3, 0xd6, 0xe5, 0xf8, 0xb5, 0xc6, 0xd1, 0xff, 0x34, 0xbe, 0x7f, 0x41, 0x6c, 0xe5, 0xbf, 0x88, + 0x55, 0x65, 0x95, 0xe0, 0xee, 0x63, 0xd0, 0x1d, 0x9a, 0x79, 0x8f, 0x5e, 0x86, 0x93, 0x97, 0x3a, + 0x0b, 0x5d, 0x9c, 0x35, 0x87, 0xad, 0x43, 0x16, 0xb3, 0x68, 0xc2, 0x22, 0x6f, 0x31, 0x0a, 0xa2, + 0x27, 0xf8, 0x06, 0xd4, 0x62, 0x9a, 0xb0, 0x28, 0x53, 0xbf, 0x10, 0x65, 0xe1, 0xeb, 0xa0, 0x7b, + 0x8f, 0x82, 0xb0, 0xb8, 0xc8, 0x16, 0x29, 0x0c, 0xfc, 0x26, 0x80, 0x47, 0xc3, 0xd0, 0xf5, 0xf8, + 0x3c, 0xca, 0xe4, 0x4d, 0xd5, 0x88, 0x25, 0x76, 0x0e, 0xc4, 0x86, 0x48, 0x96, 0xf2, 0x79, 0xe2, + 0x31, 0xf9, 0x84, 0x58, 0x44, 0x59, 0xb7, 0x3f, 0x02, 0x6b, 0xf5, 0x06, 0x61, 0x80, 0xda, 0xc9, + 0x29, 0x19, 0x1e, 0x7f, 0xdc, 0xdc, 0xc0, 0x26, 0x68, 0xce, 0x78, 0x3c, 0x6a, 0x22, 0x6c, 0x81, + 0x3e, 0x3c, 0x3e, 0xdd, 0xbf, 0xdf, 0xac, 0xe0, 0x3a, 0x18, 0x83, 0xd1, 0xf8, 0xa1, 0x30, 0xaa, + 0x02, 0xed, 0x0c, 0x8f, 0x1f, 0x92, 0xaf, 0x9a, 0xda, 0xed, 0x77, 0xa1, 0xfe, 0xdc, 0x7f, 0x11, + 0x37, 0xc0, 0x3c, 0xf8, 0x64, 0x38, 0x3a, 0x74, 0xc7, 0x83, 0xe6, 0x06, 0x6e, 0x42, 0x63, 0x30, + 0x1e, 0x8d, 0xc6, 0x5f, 0x9e, 0xb8, 0x03, 0x32, 0x3e, 0x6a, 0x22, 0xe7, 0xee, 0xd3, 0xe5, 0x0e, + 0xfa, 0x75, 0xb9, 0x83, 0xfe, 0x5a, 0xee, 0xa0, 0x5f, 0xfe, 0xde, 0x41, 0xb0, 0x1d, 0x70, 0xc5, + 0x93, 0xf8, 0x63, 0x05, 0x91, 0xaf, 0xe8, 0xfa, 0x5a, 0x97, 0x2f, 0xfe, 0x59, 0x4d, 0xde, 0xd1, + 0xf7, 0xfe, 0x09, 0x00, 0x00, 0xff, 0xff, 0xff, 0xb8, 0x61, 0xb8, 0x01, 0x08, 0x00, 0x00, } func (this *KeyValue) Compare(that interface{}) int { @@ -1288,6 +1365,50 @@ func (m *Batch) MarshalTo(dAtA []byte) (int, error) { return i, nil } +func (m *DependencyLink) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DependencyLink) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Parent) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintModel(dAtA, i, uint64(len(m.Parent))) + i += copy(dAtA[i:], m.Parent) + } + if len(m.Child) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintModel(dAtA, i, uint64(len(m.Child))) + i += copy(dAtA[i:], m.Child) + } + if m.CallCount != 0 { + dAtA[i] = 0x18 + i++ + i = encodeVarintModel(dAtA, i, uint64(m.CallCount)) + } + if len(m.Source) > 0 { + dAtA[i] = 0x22 + i++ + i = encodeVarintModel(dAtA, i, uint64(len(m.Source))) + i += copy(dAtA[i:], m.Source) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + func encodeVarintModel(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) @@ -1523,6 +1644,33 @@ func (m *Batch) Size() (n int) { return n } +func (m *DependencyLink) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Parent) + if l > 0 { + n += 1 + l + sovModel(uint64(l)) + } + l = len(m.Child) + if l > 0 { + n += 1 + l + sovModel(uint64(l)) + } + if m.CallCount != 0 { + n += 1 + sovModel(uint64(m.CallCount)) + } + l = len(m.Source) + if l > 0 { + n += 1 + l + sovModel(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + func sovModel(x uint64) (n int) { for { n++ @@ -2973,6 +3121,175 @@ func (m *Batch) Unmarshal(dAtA []byte) error { } return nil } +func (m *DependencyLink) 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 ErrIntOverflowModel + } + 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: DependencyLink: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DependencyLink: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Parent", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowModel + } + 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 ErrInvalidLengthModel + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthModel + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Parent = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Child", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowModel + } + 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 ErrInvalidLengthModel + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthModel + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Child = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CallCount", wireType) + } + m.CallCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowModel + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CallCount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowModel + } + 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 ErrInvalidLengthModel + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthModel + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Source = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipModel(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthModel + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthModel + } + 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 skipModel(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/model/proto/model.proto b/model/proto/model.proto index 3bce8a1ac5a..be73fb474bf 100644 --- a/model/proto/model.proto +++ b/model/proto/model.proto @@ -158,3 +158,10 @@ message Batch { (gogoproto.nullable) = true ]; } + +message DependencyLink { + string parent = 1; + string child = 2; + uint64 call_count = 3; + string source = 4; +} diff --git a/plugin/storage/cassandra/dependencystore/storage.go b/plugin/storage/cassandra/dependencystore/storage.go index de95ff3ceea..fce4e17ba73 100644 --- a/plugin/storage/cassandra/dependencystore/storage.go +++ b/plugin/storage/cassandra/dependencystore/storage.go @@ -124,7 +124,7 @@ func (s *DependencyStore) GetDependencies(endTs time.Time, lookback time.Duratio Parent: dependency.Parent, Child: dependency.Child, CallCount: uint64(dependency.CallCount), - Source: model.DependencyLinkSource(dependency.Source), + Source: dependency.Source, }.ApplyDefaults() mDependency = append(mDependency, dl) } diff --git a/plugin/storage/grpc/proto/storage.proto b/plugin/storage/grpc/proto/storage.proto new file mode 100644 index 00000000000..0c347883dcf --- /dev/null +++ b/plugin/storage/grpc/proto/storage.proto @@ -0,0 +1,147 @@ +// Copyright (c) 2019 The Jaeger Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +syntax = "proto3"; + +package jaeger.storage.v1; + +option go_package = "storage_v1"; + +import "gogoproto/gogo.proto"; +import "google/protobuf/timestamp.proto"; +import "google/protobuf/duration.proto"; + +import "model.proto"; + +// Enable gogoprotobuf extensions (https://github.com/gogo/protobuf/blob/master/extensions.md). +// Enable custom Marshal method. +option (gogoproto.marshaler_all) = true; +// Enable custom Unmarshal method. +option (gogoproto.unmarshaler_all) = true; +// Enable custom Size method (Required by Marshal and Unmarshal). +option (gogoproto.sizer_all) = true; +// Enable registration with golang/protobuf for the grpc-gateway. +option (gogoproto.goproto_registration) = true; + +message GetDependenciesRequest { + 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 GetDependenciesResponse { + repeated jaeger.api_v2.DependencyLink dependencies = 1 [ + (gogoproto.nullable) = false + ]; +} + +message WriteSpanRequest { + jaeger.api_v2.Span span = 1; +} + +// empty; extensible in the future +message WriteSpanResponse { + +} + +message GetTraceRequest { + bytes trace_id = 1 [ + (gogoproto.nullable) = false, + (gogoproto.customtype) = "github.com/jaegertracing/jaeger/model.TraceID", + (gogoproto.customname) = "TraceID" + ]; +} + +message GetServicesRequest {} + +message GetServicesResponse { + repeated string services = 1; +} + +message GetOperationsRequest { + string service = 1; +} + +message GetOperationsResponse { + repeated string operations = 1; +} + +message TraceQueryParameters { + string service_name = 1; + string operation_name = 2; + map tags = 3; + google.protobuf.Timestamp start_time_min = 4 [ + (gogoproto.stdtime) = true, + (gogoproto.nullable) = false + ]; + google.protobuf.Timestamp start_time_max = 5 [ + (gogoproto.stdtime) = true, + (gogoproto.nullable) = false + ]; + google.protobuf.Duration duration_min = 6 [ + (gogoproto.stdduration) = true, + (gogoproto.nullable) = false + ]; + google.protobuf.Duration duration_max = 7 [ + (gogoproto.stdduration) = true, + (gogoproto.nullable) = false + ]; + int32 num_traces = 8; +} + +message FindTracesRequest { + TraceQueryParameters query = 1; +} + +message SpansResponseChunk { + repeated jaeger.api_v2.Span spans = 1 [ + (gogoproto.nullable) = false + ]; +} + +message FindTraceIDsRequest { + TraceQueryParameters query = 1; +} + +message FindTraceIDsResponse { + repeated bytes trace_ids = 1 [ + (gogoproto.nullable) = false, + (gogoproto.customtype) = "github.com/jaegertracing/jaeger/model.TraceID", + (gogoproto.customname) = "TraceIDs" + ]; +} + +service SpanWriterPlugin { + // spanstore/Writer + rpc WriteSpan(WriteSpanRequest) returns (WriteSpanResponse); +} + +service SpanReaderPlugin { + // spanstore/Reader + rpc GetTrace(GetTraceRequest) returns (stream SpansResponseChunk); + rpc GetServices(GetServicesRequest) returns (GetServicesResponse); + rpc GetOperations(GetOperationsRequest) returns (GetOperationsResponse); + rpc FindTraces(FindTracesRequest) returns (stream SpansResponseChunk); + rpc FindTraceIDs(FindTraceIDsRequest) returns (FindTraceIDsResponse); +} + +service DependenciesReaderPlugin { + // dependencystore/Reader + rpc GetDependencies(GetDependenciesRequest) returns (GetDependenciesResponse); +} diff --git a/plugin/storage/grpc/proto/storage_test.proto b/plugin/storage/grpc/proto/storage_test.proto new file mode 100644 index 00000000000..972fc1e08ce --- /dev/null +++ b/plugin/storage/grpc/proto/storage_test.proto @@ -0,0 +1,21 @@ +// Copyright (c) 2019 The Jaeger Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +syntax="proto3"; + +package storageprototest; + +message GetTraceRequest { + bytes trace_id = 1; +} diff --git a/plugin/storage/grpc/proto/storage_v1/storage_test.go b/plugin/storage/grpc/proto/storage_v1/storage_test.go new file mode 100644 index 00000000000..6d499fcaa0f --- /dev/null +++ b/plugin/storage/grpc/proto/storage_v1/storage_test.go @@ -0,0 +1,118 @@ +// Copyright (c) 2019 The Jaeger Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package storage_v1_test + +import ( + "testing" + "time" + + "github.com/gogo/protobuf/proto" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/jaegertracing/jaeger/model" + "github.com/jaegertracing/jaeger/plugin/storage/grpc/proto/storageprototest" + "github.com/jaegertracing/jaeger/proto-gen/storage_v1" +) + +func TestGetTraceRequestMarshalProto(t *testing.T) { + testCases := []struct { + name string + marshal func(proto.Message) ([]byte, error) + unmarshal func([]byte, proto.Message) error + }{ + { + name: "protobuf", + marshal: proto.Marshal, + unmarshal: proto.Unmarshal, + }, + } + for _, testCase := range testCases { + t.Run(testCase.name, func(t *testing.T) { + ref1 := storage_v1.GetTraceRequest{TraceID: model.NewTraceID(2, 3)} + ref2 := storageprototest.GetTraceRequest{ + TraceId: []byte{0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3}, + } + d1, err := testCase.marshal(&ref1) + require.NoError(t, err) + d2, err := testCase.marshal(&ref2) + require.NoError(t, err) + assert.Equal(t, d2, d1) + + // test unmarshal + var ref1u storage_v1.GetTraceRequest + err = testCase.unmarshal(d2, &ref1u) + require.NoError(t, err) + assert.Equal(t, ref1, ref1u) + }) + } +} + +func TestSpansResponseChunkMarshalProto(t *testing.T) { + testCases := []struct { + name string + marshal func(proto.Message) ([]byte, error) + unmarshal func([]byte, proto.Message) error + }{ + { + name: "protobuf", + marshal: proto.Marshal, + unmarshal: proto.Unmarshal, + }, + } + for _, testCase := range testCases { + t.Run(testCase.name, func(t *testing.T) { + span1 := makeSpan(model.KeyValue{Key: "key", VStr: "value"}) + span2 := makeSpan(model.KeyValue{Key: "key2", VStr: "value2"}) + // If we don't normalize timestamps then the tests will fail due to locale not being preserved + span1.NormalizeTimestamps() + span2.NormalizeTimestamps() + ref1 := storage_v1.SpansResponseChunk{Spans: []model.Span{ + span1, span2, + }} + d1, err := testCase.marshal(&ref1) + require.NoError(t, err) + + // test unmarshal + var ref1u storage_v1.SpansResponseChunk + err = testCase.unmarshal(d1, &ref1u) + require.NoError(t, err) + assert.Equal(t, ref1, ref1u) + }) + } +} + +func makeSpan(someKV model.KeyValue) model.Span { + traceID := model.NewTraceID(0, 123) + return model.Span{ + TraceID: traceID, + SpanID: model.NewSpanID(567), + OperationName: "hi", + References: []model.SpanRef{model.NewChildOfRef(traceID, model.NewSpanID(123))}, + StartTime: time.Unix(0, 1000), + Duration: 5000, + Tags: model.KeyValues{someKV}, + Logs: []model.Log{ + { + Timestamp: time.Unix(0, 1000), + Fields: model.KeyValues{someKV}, + }, + }, + Process: &model.Process{ + ServiceName: "xyz", + Tags: model.KeyValues{someKV}, + }, + } +} diff --git a/plugin/storage/grpc/proto/storageprototest/storage_test.pb.go b/plugin/storage/grpc/proto/storageprototest/storage_test.pb.go new file mode 100644 index 00000000000..adeab64de99 --- /dev/null +++ b/plugin/storage/grpc/proto/storageprototest/storage_test.pb.go @@ -0,0 +1,74 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: storage_test.proto + +package storageprototest + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package + +type GetTraceRequest struct { + TraceId []byte `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetTraceRequest) Reset() { *m = GetTraceRequest{} } +func (m *GetTraceRequest) String() string { return proto.CompactTextString(m) } +func (*GetTraceRequest) ProtoMessage() {} +func (*GetTraceRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_storage_test_d286fda188bb5bc8, []int{0} +} +func (m *GetTraceRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GetTraceRequest.Unmarshal(m, b) +} +func (m *GetTraceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GetTraceRequest.Marshal(b, m, deterministic) +} +func (dst *GetTraceRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetTraceRequest.Merge(dst, src) +} +func (m *GetTraceRequest) XXX_Size() int { + return xxx_messageInfo_GetTraceRequest.Size(m) +} +func (m *GetTraceRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetTraceRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GetTraceRequest proto.InternalMessageInfo + +func (m *GetTraceRequest) GetTraceId() []byte { + if m != nil { + return m.TraceId + } + return nil +} + +func init() { + proto.RegisterType((*GetTraceRequest)(nil), "storageprototest.GetTraceRequest") +} + +func init() { proto.RegisterFile("storage_test.proto", fileDescriptor_storage_test_d286fda188bb5bc8) } + +var fileDescriptor_storage_test_d286fda188bb5bc8 = []byte{ + // 97 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x2a, 0x2e, 0xc9, 0x2f, + 0x4a, 0x4c, 0x4f, 0x8d, 0x2f, 0x49, 0x2d, 0x2e, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, + 0x80, 0x8a, 0x81, 0x79, 0x20, 0x71, 0x25, 0x1d, 0x2e, 0x7e, 0xf7, 0xd4, 0x92, 0x90, 0xa2, 0xc4, + 0xe4, 0xd4, 0xa0, 0xd4, 0xc2, 0xd2, 0xd4, 0xe2, 0x12, 0x21, 0x49, 0x2e, 0x8e, 0x12, 0x10, 0x3f, + 0x3e, 0x33, 0x45, 0x82, 0x51, 0x81, 0x51, 0x83, 0x27, 0x88, 0x1d, 0xcc, 0xf7, 0x4c, 0x49, 0x62, + 0x03, 0x6b, 0x34, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0xa9, 0x56, 0x76, 0x68, 0x5c, 0x00, 0x00, + 0x00, +} diff --git a/proto-gen/storage_v1/storage.pb.go b/proto-gen/storage_v1/storage.pb.go new file mode 100644 index 00000000000..4452ef3c715 --- /dev/null +++ b/proto-gen/storage_v1/storage.pb.go @@ -0,0 +1,3586 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: storage.proto + +package storage_v1 + +import ( + context "context" + fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + _ "github.com/gogo/protobuf/types" + github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" + golang_proto "github.com/golang/protobuf/proto" + github_com_jaegertracing_jaeger_model "github.com/jaegertracing/jaeger/model" + model "github.com/jaegertracing/jaeger/model" + grpc "google.golang.org/grpc" + io "io" + math "math" + time "time" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = golang_proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf +var _ = time.Kitchen + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package + +type GetDependenciesRequest 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:"-"` +} + +func (m *GetDependenciesRequest) Reset() { *m = GetDependenciesRequest{} } +func (m *GetDependenciesRequest) String() string { return proto.CompactTextString(m) } +func (*GetDependenciesRequest) ProtoMessage() {} +func (*GetDependenciesRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{0} +} +func (m *GetDependenciesRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetDependenciesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetDependenciesRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GetDependenciesRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetDependenciesRequest.Merge(m, src) +} +func (m *GetDependenciesRequest) XXX_Size() int { + return m.Size() +} +func (m *GetDependenciesRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetDependenciesRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GetDependenciesRequest proto.InternalMessageInfo + +func (m *GetDependenciesRequest) GetStartTime() time.Time { + if m != nil { + return m.StartTime + } + return time.Time{} +} + +func (m *GetDependenciesRequest) GetEndTime() time.Time { + if m != nil { + return m.EndTime + } + return time.Time{} +} + +type GetDependenciesResponse struct { + Dependencies []model.DependencyLink `protobuf:"bytes,1,rep,name=dependencies,proto3" json:"dependencies"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetDependenciesResponse) Reset() { *m = GetDependenciesResponse{} } +func (m *GetDependenciesResponse) String() string { return proto.CompactTextString(m) } +func (*GetDependenciesResponse) ProtoMessage() {} +func (*GetDependenciesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{1} +} +func (m *GetDependenciesResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetDependenciesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetDependenciesResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GetDependenciesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetDependenciesResponse.Merge(m, src) +} +func (m *GetDependenciesResponse) XXX_Size() int { + return m.Size() +} +func (m *GetDependenciesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetDependenciesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_GetDependenciesResponse proto.InternalMessageInfo + +func (m *GetDependenciesResponse) GetDependencies() []model.DependencyLink { + if m != nil { + return m.Dependencies + } + return nil +} + +type WriteSpanRequest struct { + Span *model.Span `protobuf:"bytes,1,opt,name=span,proto3" json:"span,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *WriteSpanRequest) Reset() { *m = WriteSpanRequest{} } +func (m *WriteSpanRequest) String() string { return proto.CompactTextString(m) } +func (*WriteSpanRequest) ProtoMessage() {} +func (*WriteSpanRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{2} +} +func (m *WriteSpanRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WriteSpanRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_WriteSpanRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *WriteSpanRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_WriteSpanRequest.Merge(m, src) +} +func (m *WriteSpanRequest) XXX_Size() int { + return m.Size() +} +func (m *WriteSpanRequest) XXX_DiscardUnknown() { + xxx_messageInfo_WriteSpanRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_WriteSpanRequest proto.InternalMessageInfo + +func (m *WriteSpanRequest) GetSpan() *model.Span { + if m != nil { + return m.Span + } + return nil +} + +// empty; extensible in the future +type WriteSpanResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *WriteSpanResponse) Reset() { *m = WriteSpanResponse{} } +func (m *WriteSpanResponse) String() string { return proto.CompactTextString(m) } +func (*WriteSpanResponse) ProtoMessage() {} +func (*WriteSpanResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{3} +} +func (m *WriteSpanResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WriteSpanResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_WriteSpanResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *WriteSpanResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_WriteSpanResponse.Merge(m, src) +} +func (m *WriteSpanResponse) XXX_Size() int { + return m.Size() +} +func (m *WriteSpanResponse) XXX_DiscardUnknown() { + xxx_messageInfo_WriteSpanResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_WriteSpanResponse proto.InternalMessageInfo + +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"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetTraceRequest) Reset() { *m = GetTraceRequest{} } +func (m *GetTraceRequest) String() string { return proto.CompactTextString(m) } +func (*GetTraceRequest) ProtoMessage() {} +func (*GetTraceRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{4} +} +func (m *GetTraceRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetTraceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetTraceRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GetTraceRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetTraceRequest.Merge(m, src) +} +func (m *GetTraceRequest) XXX_Size() int { + return m.Size() +} +func (m *GetTraceRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetTraceRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GetTraceRequest proto.InternalMessageInfo + +type GetServicesRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetServicesRequest) Reset() { *m = GetServicesRequest{} } +func (m *GetServicesRequest) String() string { return proto.CompactTextString(m) } +func (*GetServicesRequest) ProtoMessage() {} +func (*GetServicesRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{5} +} +func (m *GetServicesRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetServicesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetServicesRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GetServicesRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetServicesRequest.Merge(m, src) +} +func (m *GetServicesRequest) XXX_Size() int { + return m.Size() +} +func (m *GetServicesRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetServicesRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GetServicesRequest proto.InternalMessageInfo + +type GetServicesResponse struct { + Services []string `protobuf:"bytes,1,rep,name=services,proto3" json:"services,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetServicesResponse) Reset() { *m = GetServicesResponse{} } +func (m *GetServicesResponse) String() string { return proto.CompactTextString(m) } +func (*GetServicesResponse) ProtoMessage() {} +func (*GetServicesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{6} +} +func (m *GetServicesResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetServicesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetServicesResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GetServicesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetServicesResponse.Merge(m, src) +} +func (m *GetServicesResponse) XXX_Size() int { + return m.Size() +} +func (m *GetServicesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetServicesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_GetServicesResponse proto.InternalMessageInfo + +func (m *GetServicesResponse) GetServices() []string { + if m != nil { + return m.Services + } + return nil +} + +type GetOperationsRequest struct { + Service string `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetOperationsRequest) Reset() { *m = GetOperationsRequest{} } +func (m *GetOperationsRequest) String() string { return proto.CompactTextString(m) } +func (*GetOperationsRequest) ProtoMessage() {} +func (*GetOperationsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{7} +} +func (m *GetOperationsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetOperationsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetOperationsRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GetOperationsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetOperationsRequest.Merge(m, src) +} +func (m *GetOperationsRequest) XXX_Size() int { + return m.Size() +} +func (m *GetOperationsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetOperationsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GetOperationsRequest proto.InternalMessageInfo + +func (m *GetOperationsRequest) GetService() string { + if m != nil { + return m.Service + } + return "" +} + +type GetOperationsResponse struct { + Operations []string `protobuf:"bytes,1,rep,name=operations,proto3" json:"operations,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetOperationsResponse) Reset() { *m = GetOperationsResponse{} } +func (m *GetOperationsResponse) String() string { return proto.CompactTextString(m) } +func (*GetOperationsResponse) ProtoMessage() {} +func (*GetOperationsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{8} +} +func (m *GetOperationsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetOperationsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetOperationsResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GetOperationsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetOperationsResponse.Merge(m, src) +} +func (m *GetOperationsResponse) XXX_Size() int { + return m.Size() +} +func (m *GetOperationsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetOperationsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_GetOperationsResponse proto.InternalMessageInfo + +func (m *GetOperationsResponse) GetOperations() []string { + if m != nil { + return m.Operations + } + return nil +} + +type TraceQueryParameters struct { + ServiceName string `protobuf:"bytes,1,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"` + OperationName string `protobuf:"bytes,2,opt,name=operation_name,json=operationName,proto3" json:"operation_name,omitempty"` + Tags map[string]string `protobuf:"bytes,3,rep,name=tags,proto3" json:"tags,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + StartTimeMin time.Time `protobuf:"bytes,4,opt,name=start_time_min,json=startTimeMin,proto3,stdtime" json:"start_time_min"` + StartTimeMax time.Time `protobuf:"bytes,5,opt,name=start_time_max,json=startTimeMax,proto3,stdtime" json:"start_time_max"` + DurationMin time.Duration `protobuf:"bytes,6,opt,name=duration_min,json=durationMin,proto3,stdduration" json:"duration_min"` + DurationMax time.Duration `protobuf:"bytes,7,opt,name=duration_max,json=durationMax,proto3,stdduration" json:"duration_max"` + NumTraces int32 `protobuf:"varint,8,opt,name=num_traces,json=numTraces,proto3" json:"num_traces,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceQueryParameters) Reset() { *m = TraceQueryParameters{} } +func (m *TraceQueryParameters) String() string { return proto.CompactTextString(m) } +func (*TraceQueryParameters) ProtoMessage() {} +func (*TraceQueryParameters) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{9} +} +func (m *TraceQueryParameters) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceQueryParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceQueryParameters.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *TraceQueryParameters) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceQueryParameters.Merge(m, src) +} +func (m *TraceQueryParameters) XXX_Size() int { + return m.Size() +} +func (m *TraceQueryParameters) XXX_DiscardUnknown() { + xxx_messageInfo_TraceQueryParameters.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceQueryParameters proto.InternalMessageInfo + +func (m *TraceQueryParameters) GetServiceName() string { + if m != nil { + return m.ServiceName + } + return "" +} + +func (m *TraceQueryParameters) GetOperationName() string { + if m != nil { + return m.OperationName + } + return "" +} + +func (m *TraceQueryParameters) GetTags() map[string]string { + if m != nil { + return m.Tags + } + return nil +} + +func (m *TraceQueryParameters) GetStartTimeMin() time.Time { + if m != nil { + return m.StartTimeMin + } + return time.Time{} +} + +func (m *TraceQueryParameters) GetStartTimeMax() time.Time { + if m != nil { + return m.StartTimeMax + } + return time.Time{} +} + +func (m *TraceQueryParameters) GetDurationMin() time.Duration { + if m != nil { + return m.DurationMin + } + return 0 +} + +func (m *TraceQueryParameters) GetDurationMax() time.Duration { + if m != nil { + return m.DurationMax + } + return 0 +} + +func (m *TraceQueryParameters) GetNumTraces() int32 { + if m != nil { + return m.NumTraces + } + return 0 +} + +type FindTracesRequest struct { + Query *TraceQueryParameters `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FindTracesRequest) Reset() { *m = FindTracesRequest{} } +func (m *FindTracesRequest) String() string { return proto.CompactTextString(m) } +func (*FindTracesRequest) ProtoMessage() {} +func (*FindTracesRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{10} +} +func (m *FindTracesRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FindTracesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_FindTracesRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *FindTracesRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_FindTracesRequest.Merge(m, src) +} +func (m *FindTracesRequest) XXX_Size() int { + return m.Size() +} +func (m *FindTracesRequest) XXX_DiscardUnknown() { + xxx_messageInfo_FindTracesRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_FindTracesRequest proto.InternalMessageInfo + +func (m *FindTracesRequest) GetQuery() *TraceQueryParameters { + if m != nil { + return m.Query + } + return nil +} + +type SpansResponseChunk struct { + Spans []model.Span `protobuf:"bytes,1,rep,name=spans,proto3" json:"spans"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SpansResponseChunk) Reset() { *m = SpansResponseChunk{} } +func (m *SpansResponseChunk) String() string { return proto.CompactTextString(m) } +func (*SpansResponseChunk) ProtoMessage() {} +func (*SpansResponseChunk) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{11} +} +func (m *SpansResponseChunk) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SpansResponseChunk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SpansResponseChunk.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *SpansResponseChunk) XXX_Merge(src proto.Message) { + xxx_messageInfo_SpansResponseChunk.Merge(m, src) +} +func (m *SpansResponseChunk) XXX_Size() int { + return m.Size() +} +func (m *SpansResponseChunk) XXX_DiscardUnknown() { + xxx_messageInfo_SpansResponseChunk.DiscardUnknown(m) +} + +var xxx_messageInfo_SpansResponseChunk proto.InternalMessageInfo + +func (m *SpansResponseChunk) GetSpans() []model.Span { + if m != nil { + return m.Spans + } + return nil +} + +type FindTraceIDsRequest struct { + Query *TraceQueryParameters `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FindTraceIDsRequest) Reset() { *m = FindTraceIDsRequest{} } +func (m *FindTraceIDsRequest) String() string { return proto.CompactTextString(m) } +func (*FindTraceIDsRequest) ProtoMessage() {} +func (*FindTraceIDsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{12} +} +func (m *FindTraceIDsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FindTraceIDsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_FindTraceIDsRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *FindTraceIDsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_FindTraceIDsRequest.Merge(m, src) +} +func (m *FindTraceIDsRequest) XXX_Size() int { + return m.Size() +} +func (m *FindTraceIDsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_FindTraceIDsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_FindTraceIDsRequest proto.InternalMessageInfo + +func (m *FindTraceIDsRequest) GetQuery() *TraceQueryParameters { + if m != nil { + return m.Query + } + return nil +} + +type FindTraceIDsResponse struct { + TraceIDs []github_com_jaegertracing_jaeger_model.TraceID `protobuf:"bytes,1,rep,name=trace_ids,json=traceIds,proto3,customtype=github.com/jaegertracing/jaeger/model.TraceID" json:"trace_ids"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FindTraceIDsResponse) Reset() { *m = FindTraceIDsResponse{} } +func (m *FindTraceIDsResponse) String() string { return proto.CompactTextString(m) } +func (*FindTraceIDsResponse) ProtoMessage() {} +func (*FindTraceIDsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0d2c4ccf1453ffdb, []int{13} +} +func (m *FindTraceIDsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FindTraceIDsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_FindTraceIDsResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *FindTraceIDsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_FindTraceIDsResponse.Merge(m, src) +} +func (m *FindTraceIDsResponse) XXX_Size() int { + return m.Size() +} +func (m *FindTraceIDsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_FindTraceIDsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_FindTraceIDsResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*GetDependenciesRequest)(nil), "jaeger.storage.v1.GetDependenciesRequest") + golang_proto.RegisterType((*GetDependenciesRequest)(nil), "jaeger.storage.v1.GetDependenciesRequest") + proto.RegisterType((*GetDependenciesResponse)(nil), "jaeger.storage.v1.GetDependenciesResponse") + golang_proto.RegisterType((*GetDependenciesResponse)(nil), "jaeger.storage.v1.GetDependenciesResponse") + proto.RegisterType((*WriteSpanRequest)(nil), "jaeger.storage.v1.WriteSpanRequest") + golang_proto.RegisterType((*WriteSpanRequest)(nil), "jaeger.storage.v1.WriteSpanRequest") + proto.RegisterType((*WriteSpanResponse)(nil), "jaeger.storage.v1.WriteSpanResponse") + golang_proto.RegisterType((*WriteSpanResponse)(nil), "jaeger.storage.v1.WriteSpanResponse") + proto.RegisterType((*GetTraceRequest)(nil), "jaeger.storage.v1.GetTraceRequest") + golang_proto.RegisterType((*GetTraceRequest)(nil), "jaeger.storage.v1.GetTraceRequest") + proto.RegisterType((*GetServicesRequest)(nil), "jaeger.storage.v1.GetServicesRequest") + golang_proto.RegisterType((*GetServicesRequest)(nil), "jaeger.storage.v1.GetServicesRequest") + proto.RegisterType((*GetServicesResponse)(nil), "jaeger.storage.v1.GetServicesResponse") + golang_proto.RegisterType((*GetServicesResponse)(nil), "jaeger.storage.v1.GetServicesResponse") + proto.RegisterType((*GetOperationsRequest)(nil), "jaeger.storage.v1.GetOperationsRequest") + golang_proto.RegisterType((*GetOperationsRequest)(nil), "jaeger.storage.v1.GetOperationsRequest") + proto.RegisterType((*GetOperationsResponse)(nil), "jaeger.storage.v1.GetOperationsResponse") + golang_proto.RegisterType((*GetOperationsResponse)(nil), "jaeger.storage.v1.GetOperationsResponse") + proto.RegisterType((*TraceQueryParameters)(nil), "jaeger.storage.v1.TraceQueryParameters") + golang_proto.RegisterType((*TraceQueryParameters)(nil), "jaeger.storage.v1.TraceQueryParameters") + proto.RegisterMapType((map[string]string)(nil), "jaeger.storage.v1.TraceQueryParameters.TagsEntry") + golang_proto.RegisterMapType((map[string]string)(nil), "jaeger.storage.v1.TraceQueryParameters.TagsEntry") + proto.RegisterType((*FindTracesRequest)(nil), "jaeger.storage.v1.FindTracesRequest") + golang_proto.RegisterType((*FindTracesRequest)(nil), "jaeger.storage.v1.FindTracesRequest") + proto.RegisterType((*SpansResponseChunk)(nil), "jaeger.storage.v1.SpansResponseChunk") + golang_proto.RegisterType((*SpansResponseChunk)(nil), "jaeger.storage.v1.SpansResponseChunk") + proto.RegisterType((*FindTraceIDsRequest)(nil), "jaeger.storage.v1.FindTraceIDsRequest") + golang_proto.RegisterType((*FindTraceIDsRequest)(nil), "jaeger.storage.v1.FindTraceIDsRequest") + proto.RegisterType((*FindTraceIDsResponse)(nil), "jaeger.storage.v1.FindTraceIDsResponse") + golang_proto.RegisterType((*FindTraceIDsResponse)(nil), "jaeger.storage.v1.FindTraceIDsResponse") +} + +func init() { proto.RegisterFile("storage.proto", fileDescriptor_0d2c4ccf1453ffdb) } +func init() { golang_proto.RegisterFile("storage.proto", fileDescriptor_0d2c4ccf1453ffdb) } + +var fileDescriptor_0d2c4ccf1453ffdb = []byte{ + // 905 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0x4f, 0x6f, 0xe3, 0x44, + 0x14, 0xc7, 0x6d, 0xb2, 0x71, 0x5e, 0xd2, 0xa5, 0x9d, 0x06, 0x30, 0x16, 0x9b, 0x14, 0x43, 0xb7, + 0x05, 0x09, 0x67, 0x1b, 0x0e, 0x8b, 0x40, 0x08, 0xc8, 0xa6, 0x1b, 0x15, 0xf1, 0x67, 0xf1, 0x46, + 0xac, 0xc4, 0x22, 0xac, 0x49, 0x3c, 0xb8, 0xde, 0xc6, 0x63, 0xaf, 0x3d, 0x8e, 0x92, 0x3b, 0x1f, + 0x80, 0x23, 0x27, 0xae, 0x7c, 0x0d, 0x8e, 0x7b, 0xe4, 0xcc, 0xa1, 0xa0, 0x70, 0xe4, 0x4b, 0x20, + 0xcf, 0x8c, 0xdd, 0xfc, 0xb1, 0xb6, 0xdd, 0x8a, 0x9b, 0xe7, 0xcd, 0xef, 0xfd, 0xde, 0x9b, 0xf7, + 0xe7, 0x97, 0xc0, 0x56, 0xcc, 0x82, 0x08, 0xbb, 0xc4, 0x0c, 0xa3, 0x80, 0x05, 0x68, 0xe7, 0x09, + 0x26, 0x2e, 0x89, 0xcc, 0xcc, 0x3a, 0x39, 0xd2, 0x1b, 0x6e, 0xe0, 0x06, 0xfc, 0xb6, 0x9d, 0x7e, + 0x09, 0xa0, 0xde, 0x72, 0x83, 0xc0, 0x1d, 0x93, 0x36, 0x3f, 0x0d, 0x93, 0x1f, 0xdb, 0xcc, 0xf3, + 0x49, 0xcc, 0xb0, 0x1f, 0x4a, 0x40, 0x73, 0x15, 0xe0, 0x24, 0x11, 0x66, 0x5e, 0x40, 0xe5, 0x7d, + 0xcd, 0x0f, 0x1c, 0x32, 0x16, 0x07, 0xe3, 0x57, 0x05, 0x5e, 0xed, 0x13, 0xd6, 0x23, 0x21, 0xa1, + 0x0e, 0xa1, 0x23, 0x8f, 0xc4, 0x16, 0x79, 0x9a, 0x90, 0x98, 0xa1, 0x7b, 0x00, 0x31, 0xc3, 0x11, + 0xb3, 0xd3, 0x00, 0x9a, 0xb2, 0xa7, 0x1c, 0xd6, 0x3a, 0xba, 0x29, 0xc8, 0xcd, 0x8c, 0xdc, 0x1c, + 0x64, 0xd1, 0xbb, 0xea, 0xb3, 0xf3, 0xd6, 0x4b, 0x3f, 0xff, 0xd5, 0x52, 0xac, 0x2a, 0xf7, 0x4b, + 0x6f, 0xd0, 0x27, 0xa0, 0x12, 0xea, 0x08, 0x8a, 0x8d, 0x17, 0xa0, 0xa8, 0x10, 0xea, 0xa4, 0x76, + 0x63, 0x08, 0xaf, 0xad, 0xe5, 0x17, 0x87, 0x01, 0x8d, 0x09, 0xea, 0x43, 0xdd, 0x59, 0xb0, 0x6b, + 0xca, 0xde, 0xe6, 0x61, 0xad, 0x73, 0xcb, 0x94, 0x95, 0xc4, 0xa1, 0x67, 0x4f, 0x3a, 0x66, 0xee, + 0x3a, 0xfb, 0xc2, 0xa3, 0x67, 0xdd, 0x52, 0x1a, 0xc2, 0x5a, 0x72, 0x34, 0x3e, 0x82, 0xed, 0x47, + 0x91, 0xc7, 0xc8, 0xc3, 0x10, 0xd3, 0xec, 0xf5, 0x07, 0x50, 0x8a, 0x43, 0x4c, 0xe5, 0xbb, 0x77, + 0x57, 0x48, 0x39, 0x92, 0x03, 0x8c, 0x5d, 0xd8, 0x59, 0x70, 0x16, 0xa9, 0x19, 0x14, 0x5e, 0xee, + 0x13, 0x36, 0x88, 0xf0, 0x88, 0x64, 0x84, 0x8f, 0x41, 0x65, 0xe9, 0xd9, 0xf6, 0x1c, 0x4e, 0x5a, + 0xef, 0x7e, 0x9a, 0xa6, 0xf2, 0xe7, 0x79, 0xeb, 0x3d, 0xd7, 0x63, 0xa7, 0xc9, 0xd0, 0x1c, 0x05, + 0x7e, 0x5b, 0x84, 0x49, 0x81, 0x1e, 0x75, 0xe5, 0xa9, 0x2d, 0x1a, 0xc6, 0xd9, 0x4e, 0x7a, 0xf3, + 0xf3, 0x56, 0x45, 0x7e, 0x5a, 0x15, 0xce, 0x78, 0xe2, 0x18, 0x0d, 0x40, 0x7d, 0xc2, 0x1e, 0x92, + 0x68, 0xe2, 0x8d, 0xf2, 0x0e, 0x1a, 0x47, 0xb0, 0xbb, 0x64, 0x95, 0x75, 0xd3, 0x41, 0x8d, 0xa5, + 0x8d, 0xd7, 0xac, 0x6a, 0xe5, 0x67, 0xe3, 0x0e, 0x34, 0xfa, 0x84, 0x7d, 0x1d, 0x12, 0x31, 0x32, + 0xf9, 0x30, 0x68, 0x50, 0x91, 0x18, 0x9e, 0x7c, 0xd5, 0xca, 0x8e, 0xc6, 0x5d, 0x78, 0x65, 0xc5, + 0x43, 0x86, 0x69, 0x02, 0x04, 0xb9, 0x55, 0x06, 0x5a, 0xb0, 0x18, 0xbf, 0x95, 0xa0, 0xc1, 0x1f, + 0xf2, 0x4d, 0x42, 0xa2, 0xd9, 0x03, 0x1c, 0x61, 0x9f, 0x30, 0x12, 0xc5, 0xe8, 0x4d, 0xa8, 0x4b, + 0x72, 0x9b, 0x62, 0x3f, 0x0b, 0x58, 0x93, 0xb6, 0xaf, 0xb0, 0x4f, 0xd0, 0x3e, 0xdc, 0xcc, 0x99, + 0x04, 0x68, 0x83, 0x83, 0xb6, 0x72, 0x2b, 0x87, 0x1d, 0x43, 0x89, 0x61, 0x37, 0xd6, 0x36, 0xf9, + 0x64, 0x1c, 0x99, 0x6b, 0x3b, 0x66, 0x16, 0x25, 0x60, 0x0e, 0xb0, 0x1b, 0x1f, 0x53, 0x16, 0xcd, + 0x2c, 0xee, 0x8e, 0x3e, 0x87, 0x9b, 0x17, 0x9b, 0x60, 0xfb, 0x1e, 0xd5, 0x4a, 0x2f, 0x30, 0xca, + 0xf5, 0x7c, 0x1b, 0xbe, 0xf4, 0xe8, 0x2a, 0x17, 0x9e, 0x6a, 0xe5, 0xeb, 0x71, 0xe1, 0x29, 0xba, + 0x0f, 0xf5, 0x6c, 0xb7, 0x79, 0x56, 0x37, 0x38, 0xd3, 0xeb, 0x6b, 0x4c, 0x3d, 0x09, 0x12, 0x44, + 0xbf, 0xa4, 0x44, 0xb5, 0xcc, 0x31, 0xcd, 0x69, 0x89, 0x07, 0x4f, 0xb5, 0xca, 0x75, 0x78, 0xf0, + 0x14, 0xdd, 0x02, 0xa0, 0x89, 0x6f, 0xf3, 0xa1, 0x8c, 0x35, 0x75, 0x4f, 0x39, 0x2c, 0x5b, 0x55, + 0x9a, 0xf8, 0xbc, 0xc8, 0xb1, 0x7e, 0x17, 0xaa, 0x79, 0x65, 0xd1, 0x36, 0x6c, 0x9e, 0x91, 0x99, + 0xec, 0x6d, 0xfa, 0x89, 0x1a, 0x50, 0x9e, 0xe0, 0x71, 0x92, 0xb5, 0x52, 0x1c, 0x3e, 0xdc, 0xf8, + 0x40, 0x31, 0x2c, 0xd8, 0xb9, 0xef, 0x51, 0x47, 0xd0, 0x64, 0x13, 0xf9, 0x31, 0x94, 0x9f, 0xa6, + 0x7d, 0x93, 0x1b, 0x7a, 0x70, 0xc5, 0xe6, 0x5a, 0xc2, 0xcb, 0x38, 0x06, 0x94, 0x6e, 0x6c, 0x3e, + 0xae, 0xf7, 0x4e, 0x13, 0x7a, 0x86, 0xda, 0x50, 0x4e, 0x97, 0x3a, 0xd3, 0x92, 0xa2, 0xb5, 0x97, + 0x0a, 0x22, 0x70, 0xc6, 0x00, 0x76, 0xf3, 0xd4, 0x4e, 0x7a, 0xff, 0x57, 0x72, 0x13, 0x68, 0x2c, + 0xb3, 0xca, 0x95, 0xfa, 0x01, 0xaa, 0x99, 0x86, 0x88, 0x14, 0xeb, 0xdd, 0xcf, 0xae, 0x2b, 0x22, + 0x6a, 0xce, 0xae, 0x4a, 0x15, 0x89, 0x3b, 0x4f, 0x60, 0x3b, 0x7d, 0x22, 0xd7, 0xb3, 0xe8, 0xc1, + 0x38, 0x71, 0x3d, 0x8a, 0xbe, 0x85, 0x6a, 0xae, 0x6f, 0xe8, 0xad, 0x82, 0x87, 0xac, 0x4a, 0xa7, + 0xfe, 0xf6, 0xf3, 0x41, 0xe2, 0x2d, 0x9d, 0x7f, 0x37, 0x45, 0x30, 0x8b, 0x60, 0x27, 0x0f, 0xf6, + 0x08, 0xd4, 0x4c, 0x37, 0x91, 0x51, 0x40, 0xb3, 0x22, 0xaa, 0xfa, 0x7e, 0x01, 0x66, 0xbd, 0xad, + 0x77, 0x14, 0xf4, 0x3d, 0xd4, 0x16, 0xa4, 0x10, 0xed, 0x17, 0x73, 0xaf, 0x08, 0xa8, 0x7e, 0xfb, + 0x32, 0x98, 0xec, 0xcb, 0x10, 0xb6, 0x96, 0x34, 0x10, 0x1d, 0x14, 0x3b, 0xae, 0xe9, 0xaa, 0x7e, + 0x78, 0x39, 0x50, 0xc6, 0x78, 0x0c, 0x70, 0xb1, 0x04, 0xa8, 0xa8, 0xc6, 0x6b, 0x3b, 0x72, 0xf5, + 0xf2, 0xd8, 0x50, 0x5f, 0x1c, 0x38, 0x74, 0xfb, 0x79, 0xf4, 0x17, 0x73, 0xae, 0x1f, 0x5c, 0x8a, + 0x93, 0xdd, 0xfe, 0x49, 0x01, 0x6d, 0xf9, 0x47, 0x7c, 0xa1, 0xeb, 0xa7, 0xfc, 0xd7, 0x72, 0xf1, + 0x1a, 0xbd, 0x53, 0x5c, 0x97, 0x82, 0xff, 0x29, 0xfa, 0xbb, 0x57, 0x81, 0x8a, 0x34, 0xba, 0x6f, + 0x3c, 0x9b, 0x37, 0x95, 0x3f, 0xe6, 0x4d, 0xe5, 0xef, 0x79, 0x53, 0xf9, 0xfd, 0x9f, 0xa6, 0xf2, + 0x1d, 0x48, 0x2f, 0x7b, 0x72, 0x34, 0xbc, 0xc1, 0x95, 0xee, 0xfd, 0xff, 0x02, 0x00, 0x00, 0xff, + 0xff, 0x7d, 0x2c, 0x50, 0x42, 0x9b, 0x09, 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) +} + +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 +} + +// SpanWriterPluginServer is the server API for SpanWriterPlugin service. +type SpanWriterPluginServer interface { + // spanstore/Writer + WriteSpan(context.Context, *WriteSpanRequest) (*WriteSpanResponse, error) +} + +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.(SpanWriterPluginServer).WriteSpan(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/jaeger.storage.v1.SpanWriterPlugin/WriteSpan", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SpanWriterPluginServer).WriteSpan(ctx, req.(*WriteSpanRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _SpanWriterPlugin_serviceDesc = grpc.ServiceDesc{ + ServiceName: "jaeger.storage.v1.SpanWriterPlugin", + HandlerType: (*SpanWriterPluginServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "WriteSpan", + Handler: _SpanWriterPlugin_WriteSpan_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "storage.proto", +} + +// 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 spanReaderPluginClient struct { + cc *grpc.ClientConn +} + +func NewSpanReaderPluginClient(cc *grpc.ClientConn) SpanReaderPluginClient { + return &spanReaderPluginClient{cc} +} + +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 + } + return x, nil +} + +type SpanReaderPlugin_GetTraceClient interface { + Recv() (*SpansResponseChunk, error) + grpc.ClientStream +} + +type spanReaderPluginGetTraceClient struct { + grpc.ClientStream +} + +func (x *spanReaderPluginGetTraceClient) Recv() (*SpansResponseChunk, error) { + m := new(SpansResponseChunk) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +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 +} + +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 (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 +} + +type SpanReaderPlugin_FindTracesClient interface { + Recv() (*SpansResponseChunk, error) + grpc.ClientStream +} + +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 m, nil +} + +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 +} + +// 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 RegisterSpanReaderPluginServer(s *grpc.Server, srv SpanReaderPluginServer) { + s.RegisterService(&_SpanReaderPlugin_serviceDesc, srv) +} + +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}) +} + +type SpanReaderPlugin_GetTraceServer interface { + Send(*SpansResponseChunk) error + grpc.ServerStream +} + +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 + } + 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) +} + +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) +} + +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), + 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, + }, + { + StreamName: "FindTraces", + Handler: _SpanReaderPlugin_FindTraces_Handler, + ServerStreams: true, + }, + }, + Metadata: "storage.proto", +} + +// 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) +} + +type dependenciesReaderPluginClient struct { + cc *grpc.ClientConn +} + +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 out, nil +} + +// DependenciesReaderPluginServer is the server API for DependenciesReaderPlugin service. +type DependenciesReaderPluginServer interface { + // dependencystore/Reader + GetDependencies(context.Context, *GetDependenciesRequest) (*GetDependenciesResponse, error) +} + +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 + } + if interceptor == nil { + return srv.(DependenciesReaderPluginServer).GetDependencies(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/jaeger.storage.v1.DependenciesReaderPlugin/GetDependencies", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DependenciesReaderPluginServer).GetDependencies(ctx, req.(*GetDependenciesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +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 *GetDependenciesRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetDependenciesRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + dAtA[i] = 0xa + i++ + i = encodeVarintStorage(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime))) + n1, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i:]) + if err != nil { + return 0, err + } + i += n1 + dAtA[i] = 0x12 + i++ + i = encodeVarintStorage(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime))) + n2, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndTime, dAtA[i:]) + if err != nil { + return 0, err + } + i += n2 + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *GetDependenciesResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetDependenciesResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Dependencies) > 0 { + for _, msg := range m.Dependencies { + dAtA[i] = 0xa + i++ + i = encodeVarintStorage(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *WriteSpanRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *WriteSpanRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Span != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintStorage(dAtA, i, uint64(m.Span.Size())) + n3, err := m.Span.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n3 + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *WriteSpanResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *WriteSpanResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *GetTraceRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetTraceRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + dAtA[i] = 0xa + i++ + i = encodeVarintStorage(dAtA, i, uint64(m.TraceID.Size())) + n4, err := m.TraceID.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n4 + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *GetServicesRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetServicesRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *GetServicesResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetServicesResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Services) > 0 { + for _, s := range m.Services { + dAtA[i] = 0xa + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *GetOperationsRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetOperationsRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Service) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintStorage(dAtA, i, uint64(len(m.Service))) + i += copy(dAtA[i:], m.Service) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *GetOperationsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetOperationsResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Operations) > 0 { + for _, s := range m.Operations { + dAtA[i] = 0xa + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceQueryParameters) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceQueryParameters) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.ServiceName) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintStorage(dAtA, i, uint64(len(m.ServiceName))) + i += copy(dAtA[i:], m.ServiceName) + } + if len(m.OperationName) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintStorage(dAtA, i, uint64(len(m.OperationName))) + i += copy(dAtA[i:], m.OperationName) + } + if len(m.Tags) > 0 { + for k, _ := range m.Tags { + dAtA[i] = 0x1a + i++ + v := m.Tags[k] + mapSize := 1 + len(k) + sovStorage(uint64(len(k))) + 1 + len(v) + sovStorage(uint64(len(v))) + i = encodeVarintStorage(dAtA, i, uint64(mapSize)) + dAtA[i] = 0xa + i++ + i = encodeVarintStorage(dAtA, i, uint64(len(k))) + i += copy(dAtA[i:], k) + dAtA[i] = 0x12 + i++ + i = encodeVarintStorage(dAtA, i, uint64(len(v))) + i += copy(dAtA[i:], v) + } + } + dAtA[i] = 0x22 + i++ + i = encodeVarintStorage(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTimeMin))) + n5, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTimeMin, dAtA[i:]) + if err != nil { + return 0, err + } + i += n5 + dAtA[i] = 0x2a + i++ + i = encodeVarintStorage(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTimeMax))) + n6, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTimeMax, dAtA[i:]) + if err != nil { + return 0, err + } + i += n6 + dAtA[i] = 0x32 + i++ + i = encodeVarintStorage(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(m.DurationMin))) + n7, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.DurationMin, dAtA[i:]) + if err != nil { + return 0, err + } + i += n7 + dAtA[i] = 0x3a + i++ + i = encodeVarintStorage(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(m.DurationMax))) + n8, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.DurationMax, dAtA[i:]) + if err != nil { + return 0, err + } + i += n8 + if m.NumTraces != 0 { + dAtA[i] = 0x40 + i++ + i = encodeVarintStorage(dAtA, i, uint64(m.NumTraces)) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *FindTracesRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FindTracesRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Query != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintStorage(dAtA, i, uint64(m.Query.Size())) + n9, err := m.Query.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n9 + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *SpansResponseChunk) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SpansResponseChunk) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Spans) > 0 { + for _, msg := range m.Spans { + dAtA[i] = 0xa + i++ + i = encodeVarintStorage(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *FindTraceIDsRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FindTraceIDsRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Query != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintStorage(dAtA, i, uint64(m.Query.Size())) + n10, err := m.Query.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n10 + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *FindTraceIDsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FindTraceIDsResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.TraceIDs) > 0 { + for _, msg := range m.TraceIDs { + dAtA[i] = 0xa + i++ + i = encodeVarintStorage(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeVarintStorage(dAtA []byte, offset int, v uint64) int { + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return offset + 1 +} +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 *GetTraceRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.TraceID.Size() + 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)) + } + 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.Operations) > 0 { + for _, s := range m.Operations { + l = len(s) + 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 sovStorage(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozStorage(x uint64) (n int) { + return sovStorage(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +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 { + return ErrInvalidLengthStorage + } + if (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 { + return ErrInvalidLengthStorage + } + if (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 { + return ErrInvalidLengthStorage + } + if (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 { + return ErrInvalidLengthStorage + } + if (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 + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthStorage + } + if (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 { + return ErrInvalidLengthStorage + } + if (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 { + return ErrInvalidLengthStorage + } + if (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 + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthStorage + } + if (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 Operations", 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.Operations = append(m.Operations, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthStorage + } + if (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 { + 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: 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 + } + 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) + } + 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.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 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > postIndex { + 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 + } + } + 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.StartTimeMin, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartTimeMax", 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.StartTimeMax, dAtA[iNdEx:postIndex]); err != nil { + return err + } + 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 + } + if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.DurationMin, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DurationMax", 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.StdDurationUnmarshal(&m.DurationMax, 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) + } + 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:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthStorage + } + if (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 *FindTracesRequest) 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: FindTracesRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + 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 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:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthStorage + } + if (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 *SpansResponseChunk) 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: SpansResponseChunk: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SpansResponseChunk: 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) + } + 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.Spans = append(m.Spans, model.Span{}) + if err := m.Spans[len(m.Spans)-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 { + return ErrInvalidLengthStorage + } + if (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 *FindTraceIDsRequest) 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: FindTraceIDsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + 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 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:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthStorage + } + if (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 *FindTraceIDsResponse) 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: FindTraceIDsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + 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:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthStorage + } + if (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 skipStorage(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowStorage + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowStorage + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowStorage + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthStorage + } + iNdEx += length + if iNdEx < 0 { + return 0, ErrInvalidLengthStorage + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowStorage + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipStorage(dAtA[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + if iNdEx < 0 { + return 0, ErrInvalidLengthStorage + } + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthStorage = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowStorage = fmt.Errorf("proto: integer overflow") +) diff --git a/scripts/import-order-cleanup.sh b/scripts/import-order-cleanup.sh index f186495ddfe..b305ab5c0c0 100755 --- a/scripts/import-order-cleanup.sh +++ b/scripts/import-order-cleanup.sh @@ -2,4 +2,14 @@ set -e -python scripts/import-order-cleanup.py -o $1 -t $(git ls-files "*\.go" | grep -v -e thrift-gen -e swagger-gen -e thrift-0.9.2 -e gen_assets.go -e proto-gen -e model.pb.go -e model_test.pb.go) +python scripts/import-order-cleanup.py -o $1 -t $(git ls-files "*\.go" | \ + grep -v \ + -e thrift-gen \ + -e swagger-gen \ + -e thrift-0.9.2 \ + -e gen_assets.go \ + -e proto-gen \ + -e model.pb.go \ + -e model_test.pb.go \ + -e storage_test.pb.go +) diff --git a/scripts/updateLicenses.sh b/scripts/updateLicenses.sh index e1f33889618..4ab95dfffb8 100755 --- a/scripts/updateLicenses.sh +++ b/scripts/updateLicenses.sh @@ -11,4 +11,5 @@ python scripts/updateLicense.py $(git ls-files "*\.go" | \ -e model.pb.go \ -e model.pb.gw.go \ -e model_test.pb.go \ + -e storage_test.pb.go )