From ea1c2d52618e67d7cccedacad8195d5e75c323a8 Mon Sep 17 00:00:00 2001 From: justinsb Date: Sat, 14 Oct 2023 15:47:18 -0400 Subject: [PATCH] protobuf autogen --- tools/otel/traceserver/go.sum | 36 + .../traceserver/pb/jaeger/api/v2/model.pb.go | 1118 ++++++++++++ .../traceserver/pb/jaeger/api/v2/model.proto | 118 ++ .../pb/jaeger/storage/v1/storage.pb.go | 1560 +++++++++++++++++ .../pb/jaeger/storage/v1/storage.proto | 155 ++ .../pb/jaeger/storage/v1/storage_grpc.pb.go | 944 ++++++++++ 6 files changed, 3931 insertions(+) create mode 100644 tools/otel/traceserver/go.sum create mode 100644 tools/otel/traceserver/pb/jaeger/api/v2/model.pb.go create mode 100644 tools/otel/traceserver/pb/jaeger/api/v2/model.proto create mode 100644 tools/otel/traceserver/pb/jaeger/storage/v1/storage.pb.go create mode 100644 tools/otel/traceserver/pb/jaeger/storage/v1/storage.proto create mode 100644 tools/otel/traceserver/pb/jaeger/storage/v1/storage_grpc.pb.go diff --git a/tools/otel/traceserver/go.sum b/tools/otel/traceserver/go.sum new file mode 100644 index 0000000000000..06edead78ed38 --- /dev/null +++ b/tools/otel/traceserver/go.sum @@ -0,0 +1,36 @@ +github.com/go-logr/logr v1.2.0/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ= +github.com/go-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/golang/glog v1.1.0 h1:/d3pCKDPWNnvIWe0vVUpNP32qc8U3PDVxySP/y360qE= +github.com/golang/glog v1.1.0/go.mod h1:pfYeQZ3JWZoXTV5sFc986z3HTpwQs9At6P4ImfuP3NQ= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= +github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.16.0 h1:YBftPWNWd4WwGqtY2yeZL2ef8rHAxPBD8KFhJpmcqms= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.16.0/go.mod h1:YN5jB8ie0yfIUg6VvR9Kz84aCaG7AsGZnLjhHbUqwPg= +go.opentelemetry.io/proto/otlp v1.0.0 h1:T0TX0tmXU8a3CbNXzEKGeU5mIVOdf0oykP+u2lIVU/I= +go.opentelemetry.io/proto/otlp v1.0.0/go.mod h1:Sy6pihPLfYHkr3NkUbEhGHFhINUSI/v80hjKIs5JXpM= +golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM= +golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE= +golang.org/x/sys v0.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE= +golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k= +golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/genproto v0.0.0-20231002182017-d307bd883b97 h1:SeZZZx0cP0fqUyA+oRzP9k7cSwJlvDFiROO72uwD6i0= +google.golang.org/genproto v0.0.0-20231002182017-d307bd883b97/go.mod h1:t1VqOqqvce95G3hIDCT5FeO3YUc6Q4Oe24L/+rNMxRk= +google.golang.org/genproto/googleapis/api v0.0.0-20231002182017-d307bd883b97 h1:W18sezcAYs+3tDZX4F80yctqa12jcP1PUS2gQu1zTPU= +google.golang.org/genproto/googleapis/api v0.0.0-20231002182017-d307bd883b97/go.mod h1:iargEX0SFPm3xcfMI0d1domjg0ZF4Aa0p2awqyxhvF0= +google.golang.org/genproto/googleapis/rpc v0.0.0-20231009173412-8bfb1ae86b6c h1:jHkCUWkseRf+W+edG5hMzr/Uh1xkDREY4caybAq4dpY= +google.golang.org/genproto/googleapis/rpc v0.0.0-20231009173412-8bfb1ae86b6c/go.mod h1:4cYg8o5yUbm77w8ZX00LhMVNl/YVBFJRYWDc0uYWMs0= +google.golang.org/grpc v1.58.3 h1:BjnpXut1btbtgN/6sp+brB2Kbm2LjNXnidYujAVbSoQ= +google.golang.org/grpc v1.58.3/go.mod h1:tgX3ZQDlNJGU96V6yHh1T/JeoBQ2TXdr43YbYSsCJk0= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8= +google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +k8s.io/klog/v2 v2.100.1 h1:7WCHKK6K8fNhTqfBhISHQ97KrnJNFZMcQvKp7gP/tmg= +k8s.io/klog/v2 v2.100.1/go.mod h1:y1WjHnz7Dj687irZUWR/WLkLc5N1YHtjLdmgWjndZn0= diff --git a/tools/otel/traceserver/pb/jaeger/api/v2/model.pb.go b/tools/otel/traceserver/pb/jaeger/api/v2/model.pb.go new file mode 100644 index 0000000000000..b6dc02892b8d0 --- /dev/null +++ b/tools/otel/traceserver/pb/jaeger/api/v2/model.pb.go @@ -0,0 +1,1118 @@ +/* +Copyright The Kubernetes 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. +*/ + +// Copyright (c) 2018 Uber Technologies, Inc. +// +// 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. + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.28.0 +// protoc v3.21.12 +// source: jaeger/api/v2/model.proto + +package v2 + +import ( + reflect "reflect" + sync "sync" + + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + durationpb "google.golang.org/protobuf/types/known/durationpb" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type ValueType int32 + +const ( + ValueType_STRING ValueType = 0 + ValueType_BOOL ValueType = 1 + ValueType_INT64 ValueType = 2 + ValueType_FLOAT64 ValueType = 3 + ValueType_BINARY ValueType = 4 +) + +// Enum value maps for ValueType. +var ( + ValueType_name = map[int32]string{ + 0: "STRING", + 1: "BOOL", + 2: "INT64", + 3: "FLOAT64", + 4: "BINARY", + } + ValueType_value = map[string]int32{ + "STRING": 0, + "BOOL": 1, + "INT64": 2, + "FLOAT64": 3, + "BINARY": 4, + } +) + +func (x ValueType) Enum() *ValueType { + p := new(ValueType) + *p = x + return p +} + +func (x ValueType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ValueType) Descriptor() protoreflect.EnumDescriptor { + return file_jaeger_api_v2_model_proto_enumTypes[0].Descriptor() +} + +func (ValueType) Type() protoreflect.EnumType { + return &file_jaeger_api_v2_model_proto_enumTypes[0] +} + +func (x ValueType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use ValueType.Descriptor instead. +func (ValueType) EnumDescriptor() ([]byte, []int) { + return file_jaeger_api_v2_model_proto_rawDescGZIP(), []int{0} +} + +type SpanRefType int32 + +const ( + SpanRefType_CHILD_OF SpanRefType = 0 + SpanRefType_FOLLOWS_FROM SpanRefType = 1 +) + +// Enum value maps for SpanRefType. +var ( + SpanRefType_name = map[int32]string{ + 0: "CHILD_OF", + 1: "FOLLOWS_FROM", + } + SpanRefType_value = map[string]int32{ + "CHILD_OF": 0, + "FOLLOWS_FROM": 1, + } +) + +func (x SpanRefType) Enum() *SpanRefType { + p := new(SpanRefType) + *p = x + return p +} + +func (x SpanRefType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (SpanRefType) Descriptor() protoreflect.EnumDescriptor { + return file_jaeger_api_v2_model_proto_enumTypes[1].Descriptor() +} + +func (SpanRefType) Type() protoreflect.EnumType { + return &file_jaeger_api_v2_model_proto_enumTypes[1] +} + +func (x SpanRefType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use SpanRefType.Descriptor instead. +func (SpanRefType) EnumDescriptor() ([]byte, []int) { + return file_jaeger_api_v2_model_proto_rawDescGZIP(), []int{1} +} + +type KeyValue struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + VType ValueType `protobuf:"varint,2,opt,name=v_type,json=vType,proto3,enum=jaeger.api_v2.ValueType" json:"v_type,omitempty"` + VStr string `protobuf:"bytes,3,opt,name=v_str,json=vStr,proto3" json:"v_str,omitempty"` + VBool bool `protobuf:"varint,4,opt,name=v_bool,json=vBool,proto3" json:"v_bool,omitempty"` + VInt64 int64 `protobuf:"varint,5,opt,name=v_int64,json=vInt64,proto3" json:"v_int64,omitempty"` + VFloat64 float64 `protobuf:"fixed64,6,opt,name=v_float64,json=vFloat64,proto3" json:"v_float64,omitempty"` + VBinary []byte `protobuf:"bytes,7,opt,name=v_binary,json=vBinary,proto3" json:"v_binary,omitempty"` +} + +func (x *KeyValue) Reset() { + *x = KeyValue{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_api_v2_model_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *KeyValue) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*KeyValue) ProtoMessage() {} + +func (x *KeyValue) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_api_v2_model_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use KeyValue.ProtoReflect.Descriptor instead. +func (*KeyValue) Descriptor() ([]byte, []int) { + return file_jaeger_api_v2_model_proto_rawDescGZIP(), []int{0} +} + +func (x *KeyValue) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *KeyValue) GetVType() ValueType { + if x != nil { + return x.VType + } + return ValueType_STRING +} + +func (x *KeyValue) GetVStr() string { + if x != nil { + return x.VStr + } + return "" +} + +func (x *KeyValue) GetVBool() bool { + if x != nil { + return x.VBool + } + return false +} + +func (x *KeyValue) GetVInt64() int64 { + if x != nil { + return x.VInt64 + } + return 0 +} + +func (x *KeyValue) GetVFloat64() float64 { + if x != nil { + return x.VFloat64 + } + return 0 +} + +func (x *KeyValue) GetVBinary() []byte { + if x != nil { + return x.VBinary + } + return nil +} + +type Log struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Timestamp *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + Fields []*KeyValue `protobuf:"bytes,2,rep,name=fields,proto3" json:"fields,omitempty"` +} + +func (x *Log) Reset() { + *x = Log{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_api_v2_model_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Log) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Log) ProtoMessage() {} + +func (x *Log) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_api_v2_model_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Log.ProtoReflect.Descriptor instead. +func (*Log) Descriptor() ([]byte, []int) { + return file_jaeger_api_v2_model_proto_rawDescGZIP(), []int{1} +} + +func (x *Log) GetTimestamp() *timestamppb.Timestamp { + if x != nil { + return x.Timestamp + } + return nil +} + +func (x *Log) GetFields() []*KeyValue { + if x != nil { + return x.Fields + } + return nil +} + +type SpanRef struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TraceId []byte `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"` + SpanId []byte `protobuf:"bytes,2,opt,name=span_id,json=spanId,proto3" json:"span_id,omitempty"` + RefType SpanRefType `protobuf:"varint,3,opt,name=ref_type,json=refType,proto3,enum=jaeger.api_v2.SpanRefType" json:"ref_type,omitempty"` +} + +func (x *SpanRef) Reset() { + *x = SpanRef{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_api_v2_model_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SpanRef) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SpanRef) ProtoMessage() {} + +func (x *SpanRef) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_api_v2_model_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SpanRef.ProtoReflect.Descriptor instead. +func (*SpanRef) Descriptor() ([]byte, []int) { + return file_jaeger_api_v2_model_proto_rawDescGZIP(), []int{2} +} + +func (x *SpanRef) GetTraceId() []byte { + if x != nil { + return x.TraceId + } + return nil +} + +func (x *SpanRef) GetSpanId() []byte { + if x != nil { + return x.SpanId + } + return nil +} + +func (x *SpanRef) GetRefType() SpanRefType { + if x != nil { + return x.RefType + } + return SpanRefType_CHILD_OF +} + +type Process struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ServiceName string `protobuf:"bytes,1,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"` + Tags []*KeyValue `protobuf:"bytes,2,rep,name=tags,proto3" json:"tags,omitempty"` +} + +func (x *Process) Reset() { + *x = Process{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_api_v2_model_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Process) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Process) ProtoMessage() {} + +func (x *Process) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_api_v2_model_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Process.ProtoReflect.Descriptor instead. +func (*Process) Descriptor() ([]byte, []int) { + return file_jaeger_api_v2_model_proto_rawDescGZIP(), []int{3} +} + +func (x *Process) GetServiceName() string { + if x != nil { + return x.ServiceName + } + return "" +} + +func (x *Process) GetTags() []*KeyValue { + if x != nil { + return x.Tags + } + return nil +} + +type Span struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TraceId []byte `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"` + SpanId []byte `protobuf:"bytes,2,opt,name=span_id,json=spanId,proto3" json:"span_id,omitempty"` + OperationName string `protobuf:"bytes,3,opt,name=operation_name,json=operationName,proto3" json:"operation_name,omitempty"` + References []*SpanRef `protobuf:"bytes,4,rep,name=references,proto3" json:"references,omitempty"` + Flags uint32 `protobuf:"varint,5,opt,name=flags,proto3" json:"flags,omitempty"` + StartTime *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` + Duration *durationpb.Duration `protobuf:"bytes,7,opt,name=duration,proto3" json:"duration,omitempty"` + Tags []*KeyValue `protobuf:"bytes,8,rep,name=tags,proto3" json:"tags,omitempty"` + Logs []*Log `protobuf:"bytes,9,rep,name=logs,proto3" json:"logs,omitempty"` + Process *Process `protobuf:"bytes,10,opt,name=process,proto3" json:"process,omitempty"` + ProcessId string `protobuf:"bytes,11,opt,name=process_id,json=processId,proto3" json:"process_id,omitempty"` + Warnings []string `protobuf:"bytes,12,rep,name=warnings,proto3" json:"warnings,omitempty"` +} + +func (x *Span) Reset() { + *x = Span{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_api_v2_model_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Span) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Span) ProtoMessage() {} + +func (x *Span) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_api_v2_model_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Span.ProtoReflect.Descriptor instead. +func (*Span) Descriptor() ([]byte, []int) { + return file_jaeger_api_v2_model_proto_rawDescGZIP(), []int{4} +} + +func (x *Span) GetTraceId() []byte { + if x != nil { + return x.TraceId + } + return nil +} + +func (x *Span) GetSpanId() []byte { + if x != nil { + return x.SpanId + } + return nil +} + +func (x *Span) GetOperationName() string { + if x != nil { + return x.OperationName + } + return "" +} + +func (x *Span) GetReferences() []*SpanRef { + if x != nil { + return x.References + } + return nil +} + +func (x *Span) GetFlags() uint32 { + if x != nil { + return x.Flags + } + return 0 +} + +func (x *Span) GetStartTime() *timestamppb.Timestamp { + if x != nil { + return x.StartTime + } + return nil +} + +func (x *Span) GetDuration() *durationpb.Duration { + if x != nil { + return x.Duration + } + return nil +} + +func (x *Span) GetTags() []*KeyValue { + if x != nil { + return x.Tags + } + return nil +} + +func (x *Span) GetLogs() []*Log { + if x != nil { + return x.Logs + } + return nil +} + +func (x *Span) GetProcess() *Process { + if x != nil { + return x.Process + } + return nil +} + +func (x *Span) GetProcessId() string { + if x != nil { + return x.ProcessId + } + return "" +} + +func (x *Span) GetWarnings() []string { + if x != nil { + return x.Warnings + } + return nil +} + +type Trace struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Spans []*Span `protobuf:"bytes,1,rep,name=spans,proto3" json:"spans,omitempty"` + ProcessMap []*Trace_ProcessMapping `protobuf:"bytes,2,rep,name=process_map,json=processMap,proto3" json:"process_map,omitempty"` + Warnings []string `protobuf:"bytes,3,rep,name=warnings,proto3" json:"warnings,omitempty"` +} + +func (x *Trace) Reset() { + *x = Trace{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_api_v2_model_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Trace) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Trace) ProtoMessage() {} + +func (x *Trace) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_api_v2_model_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Trace.ProtoReflect.Descriptor instead. +func (*Trace) Descriptor() ([]byte, []int) { + return file_jaeger_api_v2_model_proto_rawDescGZIP(), []int{5} +} + +func (x *Trace) GetSpans() []*Span { + if x != nil { + return x.Spans + } + return nil +} + +func (x *Trace) GetProcessMap() []*Trace_ProcessMapping { + if x != nil { + return x.ProcessMap + } + return nil +} + +func (x *Trace) GetWarnings() []string { + if x != nil { + return x.Warnings + } + return nil +} + +// Note that both Span and Batch may contain a Process. +// This is different from the Thrift model which was only used +// for transport, because Proto model is also used by the backend +// as the domain model, where once a batch is received it is split +// into individual spans which are all processed independently, +// and therefore they all need a Process. As far as on-the-wire +// semantics, both Batch and Spans in the same message may contain +// their own instances of Process, with span.Process taking priority +// over batch.Process. +type Batch struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Spans []*Span `protobuf:"bytes,1,rep,name=spans,proto3" json:"spans,omitempty"` + Process *Process `protobuf:"bytes,2,opt,name=process,proto3" json:"process,omitempty"` +} + +func (x *Batch) Reset() { + *x = Batch{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_api_v2_model_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Batch) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Batch) ProtoMessage() {} + +func (x *Batch) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_api_v2_model_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Batch.ProtoReflect.Descriptor instead. +func (*Batch) Descriptor() ([]byte, []int) { + return file_jaeger_api_v2_model_proto_rawDescGZIP(), []int{6} +} + +func (x *Batch) GetSpans() []*Span { + if x != nil { + return x.Spans + } + return nil +} + +func (x *Batch) GetProcess() *Process { + if x != nil { + return x.Process + } + return nil +} + +type DependencyLink struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + 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"` +} + +func (x *DependencyLink) Reset() { + *x = DependencyLink{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_api_v2_model_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DependencyLink) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DependencyLink) ProtoMessage() {} + +func (x *DependencyLink) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_api_v2_model_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DependencyLink.ProtoReflect.Descriptor instead. +func (*DependencyLink) Descriptor() ([]byte, []int) { + return file_jaeger_api_v2_model_proto_rawDescGZIP(), []int{7} +} + +func (x *DependencyLink) GetParent() string { + if x != nil { + return x.Parent + } + return "" +} + +func (x *DependencyLink) GetChild() string { + if x != nil { + return x.Child + } + return "" +} + +func (x *DependencyLink) GetCallCount() uint64 { + if x != nil { + return x.CallCount + } + return 0 +} + +func (x *DependencyLink) GetSource() string { + if x != nil { + return x.Source + } + return "" +} + +type Trace_ProcessMapping struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ProcessId string `protobuf:"bytes,1,opt,name=process_id,json=processId,proto3" json:"process_id,omitempty"` + Process *Process `protobuf:"bytes,2,opt,name=process,proto3" json:"process,omitempty"` +} + +func (x *Trace_ProcessMapping) Reset() { + *x = Trace_ProcessMapping{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_api_v2_model_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Trace_ProcessMapping) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Trace_ProcessMapping) ProtoMessage() {} + +func (x *Trace_ProcessMapping) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_api_v2_model_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Trace_ProcessMapping.ProtoReflect.Descriptor instead. +func (*Trace_ProcessMapping) Descriptor() ([]byte, []int) { + return file_jaeger_api_v2_model_proto_rawDescGZIP(), []int{5, 0} +} + +func (x *Trace_ProcessMapping) GetProcessId() string { + if x != nil { + return x.ProcessId + } + return "" +} + +func (x *Trace_ProcessMapping) GetProcess() *Process { + if x != nil { + return x.Process + } + return nil +} + +var File_jaeger_api_v2_model_proto protoreflect.FileDescriptor + +var file_jaeger_api_v2_model_proto_rawDesc = []byte{ + 0x0a, 0x19, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x32, 0x2f, + 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0d, 0x6a, 0x61, 0x65, + 0x67, 0x65, 0x72, 0x2e, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x32, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xca, 0x01, 0x0a, 0x08, + 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2f, 0x0a, 0x06, 0x76, 0x5f, + 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x18, 0x2e, 0x6a, 0x61, 0x65, + 0x67, 0x65, 0x72, 0x2e, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x32, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, + 0x54, 0x79, 0x70, 0x65, 0x52, 0x05, 0x76, 0x54, 0x79, 0x70, 0x65, 0x12, 0x13, 0x0a, 0x05, 0x76, + 0x5f, 0x73, 0x74, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x76, 0x53, 0x74, 0x72, + 0x12, 0x15, 0x0a, 0x06, 0x76, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x05, 0x76, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x17, 0x0a, 0x07, 0x76, 0x5f, 0x69, 0x6e, 0x74, + 0x36, 0x34, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x76, 0x49, 0x6e, 0x74, 0x36, 0x34, + 0x12, 0x1b, 0x0a, 0x09, 0x76, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x36, 0x34, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x01, 0x52, 0x08, 0x76, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x36, 0x34, 0x12, 0x19, 0x0a, + 0x08, 0x76, 0x5f, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, + 0x07, 0x76, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x22, 0x70, 0x0a, 0x03, 0x4c, 0x6f, 0x67, 0x12, + 0x38, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, + 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x2f, 0x0a, 0x06, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6a, 0x61, 0x65, 0x67, + 0x65, 0x72, 0x2e, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x32, 0x2e, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x22, 0x74, 0x0a, 0x07, 0x53, 0x70, + 0x61, 0x6e, 0x52, 0x65, 0x66, 0x12, 0x19, 0x0a, 0x08, 0x74, 0x72, 0x61, 0x63, 0x65, 0x5f, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x74, 0x72, 0x61, 0x63, 0x65, 0x49, 0x64, + 0x12, 0x17, 0x0a, 0x07, 0x73, 0x70, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x06, 0x73, 0x70, 0x61, 0x6e, 0x49, 0x64, 0x12, 0x35, 0x0a, 0x08, 0x72, 0x65, 0x66, + 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x6a, 0x61, + 0x65, 0x67, 0x65, 0x72, 0x2e, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x32, 0x2e, 0x53, 0x70, 0x61, 0x6e, + 0x52, 0x65, 0x66, 0x54, 0x79, 0x70, 0x65, 0x52, 0x07, 0x72, 0x65, 0x66, 0x54, 0x79, 0x70, 0x65, + 0x22, 0x59, 0x0a, 0x07, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x73, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0b, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x2b, + 0x0a, 0x04, 0x74, 0x61, 0x67, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6a, + 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x32, 0x2e, 0x4b, 0x65, 0x79, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x04, 0x74, 0x61, 0x67, 0x73, 0x22, 0xe3, 0x03, 0x0a, 0x04, + 0x53, 0x70, 0x61, 0x6e, 0x12, 0x19, 0x0a, 0x08, 0x74, 0x72, 0x61, 0x63, 0x65, 0x5f, 0x69, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x74, 0x72, 0x61, 0x63, 0x65, 0x49, 0x64, 0x12, + 0x17, 0x0a, 0x07, 0x73, 0x70, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x06, 0x73, 0x70, 0x61, 0x6e, 0x49, 0x64, 0x12, 0x25, 0x0a, 0x0e, 0x6f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0d, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, + 0x36, 0x0a, 0x0a, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x04, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x61, 0x70, 0x69, + 0x5f, 0x76, 0x32, 0x2e, 0x53, 0x70, 0x61, 0x6e, 0x52, 0x65, 0x66, 0x52, 0x0a, 0x72, 0x65, 0x66, + 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6c, 0x61, 0x67, 0x73, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x12, 0x39, 0x0a, + 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x08, 0x64, 0x75, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x08, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x2b, 0x0a, 0x04, 0x74, 0x61, 0x67, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, + 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x32, 0x2e, 0x4b, 0x65, + 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x04, 0x74, 0x61, 0x67, 0x73, 0x12, 0x26, 0x0a, 0x04, + 0x6c, 0x6f, 0x67, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6a, 0x61, 0x65, + 0x67, 0x65, 0x72, 0x2e, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x32, 0x2e, 0x4c, 0x6f, 0x67, 0x52, 0x04, + 0x6c, 0x6f, 0x67, 0x73, 0x12, 0x30, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x18, + 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x61, + 0x70, 0x69, 0x5f, 0x76, 0x32, 0x2e, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x52, 0x07, 0x70, + 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, + 0x73, 0x5f, 0x69, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x63, + 0x65, 0x73, 0x73, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x61, 0x72, 0x6e, 0x69, 0x6e, 0x67, + 0x73, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x77, 0x61, 0x72, 0x6e, 0x69, 0x6e, 0x67, + 0x73, 0x22, 0xf7, 0x01, 0x0a, 0x05, 0x54, 0x72, 0x61, 0x63, 0x65, 0x12, 0x29, 0x0a, 0x05, 0x73, + 0x70, 0x61, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x6a, 0x61, 0x65, + 0x67, 0x65, 0x72, 0x2e, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x32, 0x2e, 0x53, 0x70, 0x61, 0x6e, 0x52, + 0x05, 0x73, 0x70, 0x61, 0x6e, 0x73, 0x12, 0x44, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, + 0x73, 0x5f, 0x6d, 0x61, 0x70, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x6a, 0x61, + 0x65, 0x67, 0x65, 0x72, 0x2e, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x32, 0x2e, 0x54, 0x72, 0x61, 0x63, + 0x65, 0x2e, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x4d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, + 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x4d, 0x61, 0x70, 0x12, 0x1a, 0x0a, 0x08, + 0x77, 0x61, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, + 0x77, 0x61, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x73, 0x1a, 0x61, 0x0a, 0x0e, 0x50, 0x72, 0x6f, 0x63, + 0x65, 0x73, 0x73, 0x4d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x72, + 0x6f, 0x63, 0x65, 0x73, 0x73, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x49, 0x64, 0x12, 0x30, 0x0a, 0x07, 0x70, 0x72, 0x6f, + 0x63, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x6a, 0x61, 0x65, + 0x67, 0x65, 0x72, 0x2e, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x32, 0x2e, 0x50, 0x72, 0x6f, 0x63, 0x65, + 0x73, 0x73, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x22, 0x64, 0x0a, 0x05, 0x42, + 0x61, 0x74, 0x63, 0x68, 0x12, 0x29, 0x0a, 0x05, 0x73, 0x70, 0x61, 0x6e, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x61, 0x70, 0x69, + 0x5f, 0x76, 0x32, 0x2e, 0x53, 0x70, 0x61, 0x6e, 0x52, 0x05, 0x73, 0x70, 0x61, 0x6e, 0x73, 0x12, + 0x30, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x16, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x32, + 0x2e, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, + 0x73, 0x22, 0x75, 0x0a, 0x0e, 0x44, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x4c, + 0x69, 0x6e, 0x6b, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x63, + 0x68, 0x69, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x63, 0x68, 0x69, 0x6c, + 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x61, 0x6c, 0x6c, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x63, 0x61, 0x6c, 0x6c, 0x43, 0x6f, 0x75, 0x6e, 0x74, + 0x12, 0x16, 0x0a, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2a, 0x45, 0x0a, 0x09, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0a, 0x0a, 0x06, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, + 0x00, 0x12, 0x08, 0x0a, 0x04, 0x42, 0x4f, 0x4f, 0x4c, 0x10, 0x01, 0x12, 0x09, 0x0a, 0x05, 0x49, + 0x4e, 0x54, 0x36, 0x34, 0x10, 0x02, 0x12, 0x0b, 0x0a, 0x07, 0x46, 0x4c, 0x4f, 0x41, 0x54, 0x36, + 0x34, 0x10, 0x03, 0x12, 0x0a, 0x0a, 0x06, 0x42, 0x49, 0x4e, 0x41, 0x52, 0x59, 0x10, 0x04, 0x2a, + 0x2d, 0x0a, 0x0b, 0x53, 0x70, 0x61, 0x6e, 0x52, 0x65, 0x66, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0c, + 0x0a, 0x08, 0x43, 0x48, 0x49, 0x4c, 0x44, 0x5f, 0x4f, 0x46, 0x10, 0x00, 0x12, 0x10, 0x0a, 0x0c, + 0x46, 0x4f, 0x4c, 0x4c, 0x4f, 0x57, 0x53, 0x5f, 0x46, 0x52, 0x4f, 0x4d, 0x10, 0x01, 0x42, 0x4e, + 0x0a, 0x17, 0x69, 0x6f, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x74, 0x72, 0x61, 0x63, 0x69, + 0x6e, 0x67, 0x2e, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x32, 0x5a, 0x33, 0x6b, 0x38, 0x73, 0x2e, 0x69, + 0x6f, 0x2f, 0x6b, 0x6f, 0x70, 0x73, 0x2f, 0x74, 0x6f, 0x6f, 0x6c, 0x73, 0x2f, 0x6f, 0x74, 0x65, + 0x6c, 0x2f, 0x74, 0x72, 0x61, 0x63, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2f, 0x70, 0x62, + 0x2f, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x32, 0x62, 0x06, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_jaeger_api_v2_model_proto_rawDescOnce sync.Once + file_jaeger_api_v2_model_proto_rawDescData = file_jaeger_api_v2_model_proto_rawDesc +) + +func file_jaeger_api_v2_model_proto_rawDescGZIP() []byte { + file_jaeger_api_v2_model_proto_rawDescOnce.Do(func() { + file_jaeger_api_v2_model_proto_rawDescData = protoimpl.X.CompressGZIP(file_jaeger_api_v2_model_proto_rawDescData) + }) + return file_jaeger_api_v2_model_proto_rawDescData +} + +var file_jaeger_api_v2_model_proto_enumTypes = make([]protoimpl.EnumInfo, 2) +var file_jaeger_api_v2_model_proto_msgTypes = make([]protoimpl.MessageInfo, 9) +var file_jaeger_api_v2_model_proto_goTypes = []interface{}{ + (ValueType)(0), // 0: jaeger.api_v2.ValueType + (SpanRefType)(0), // 1: jaeger.api_v2.SpanRefType + (*KeyValue)(nil), // 2: jaeger.api_v2.KeyValue + (*Log)(nil), // 3: jaeger.api_v2.Log + (*SpanRef)(nil), // 4: jaeger.api_v2.SpanRef + (*Process)(nil), // 5: jaeger.api_v2.Process + (*Span)(nil), // 6: jaeger.api_v2.Span + (*Trace)(nil), // 7: jaeger.api_v2.Trace + (*Batch)(nil), // 8: jaeger.api_v2.Batch + (*DependencyLink)(nil), // 9: jaeger.api_v2.DependencyLink + (*Trace_ProcessMapping)(nil), // 10: jaeger.api_v2.Trace.ProcessMapping + (*timestamppb.Timestamp)(nil), // 11: google.protobuf.Timestamp + (*durationpb.Duration)(nil), // 12: google.protobuf.Duration +} +var file_jaeger_api_v2_model_proto_depIdxs = []int32{ + 0, // 0: jaeger.api_v2.KeyValue.v_type:type_name -> jaeger.api_v2.ValueType + 11, // 1: jaeger.api_v2.Log.timestamp:type_name -> google.protobuf.Timestamp + 2, // 2: jaeger.api_v2.Log.fields:type_name -> jaeger.api_v2.KeyValue + 1, // 3: jaeger.api_v2.SpanRef.ref_type:type_name -> jaeger.api_v2.SpanRefType + 2, // 4: jaeger.api_v2.Process.tags:type_name -> jaeger.api_v2.KeyValue + 4, // 5: jaeger.api_v2.Span.references:type_name -> jaeger.api_v2.SpanRef + 11, // 6: jaeger.api_v2.Span.start_time:type_name -> google.protobuf.Timestamp + 12, // 7: jaeger.api_v2.Span.duration:type_name -> google.protobuf.Duration + 2, // 8: jaeger.api_v2.Span.tags:type_name -> jaeger.api_v2.KeyValue + 3, // 9: jaeger.api_v2.Span.logs:type_name -> jaeger.api_v2.Log + 5, // 10: jaeger.api_v2.Span.process:type_name -> jaeger.api_v2.Process + 6, // 11: jaeger.api_v2.Trace.spans:type_name -> jaeger.api_v2.Span + 10, // 12: jaeger.api_v2.Trace.process_map:type_name -> jaeger.api_v2.Trace.ProcessMapping + 6, // 13: jaeger.api_v2.Batch.spans:type_name -> jaeger.api_v2.Span + 5, // 14: jaeger.api_v2.Batch.process:type_name -> jaeger.api_v2.Process + 5, // 15: jaeger.api_v2.Trace.ProcessMapping.process:type_name -> jaeger.api_v2.Process + 16, // [16:16] is the sub-list for method output_type + 16, // [16:16] is the sub-list for method input_type + 16, // [16:16] is the sub-list for extension type_name + 16, // [16:16] is the sub-list for extension extendee + 0, // [0:16] is the sub-list for field type_name +} + +func init() { file_jaeger_api_v2_model_proto_init() } +func file_jaeger_api_v2_model_proto_init() { + if File_jaeger_api_v2_model_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_jaeger_api_v2_model_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*KeyValue); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_api_v2_model_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Log); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_api_v2_model_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SpanRef); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_api_v2_model_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Process); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_api_v2_model_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Span); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_api_v2_model_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Trace); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_api_v2_model_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Batch); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_api_v2_model_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DependencyLink); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_api_v2_model_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Trace_ProcessMapping); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_jaeger_api_v2_model_proto_rawDesc, + NumEnums: 2, + NumMessages: 9, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_jaeger_api_v2_model_proto_goTypes, + DependencyIndexes: file_jaeger_api_v2_model_proto_depIdxs, + EnumInfos: file_jaeger_api_v2_model_proto_enumTypes, + MessageInfos: file_jaeger_api_v2_model_proto_msgTypes, + }.Build() + File_jaeger_api_v2_model_proto = out.File + file_jaeger_api_v2_model_proto_rawDesc = nil + file_jaeger_api_v2_model_proto_goTypes = nil + file_jaeger_api_v2_model_proto_depIdxs = nil +} diff --git a/tools/otel/traceserver/pb/jaeger/api/v2/model.proto b/tools/otel/traceserver/pb/jaeger/api/v2/model.proto new file mode 100644 index 0000000000000..d05a99647b941 --- /dev/null +++ b/tools/otel/traceserver/pb/jaeger/api/v2/model.proto @@ -0,0 +1,118 @@ +// Copyright (c) 2018 Uber Technologies, Inc. +// +// 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.api_v2; + +import "google/protobuf/timestamp.proto"; +import "google/protobuf/duration.proto"; + +// TODO: document all types and fields + +// TODO: once this moves to jaeger-idl repo, we may want to change Go pkg to api_v2 +// and rewrite it to model only in this repo. That should make it easier to generate +// classes in other languages. +option go_package="k8s.io/kops/tools/otel/traceserver/pb/jaeger/api/v2"; // = "model"; +option java_package = "io.jaegertracing.api_v2"; + +// Enable custom Marshal method. +// Enable custom Unmarshal method. +// Enable custom Size method (Required by Marshal and Unmarshal). + +enum ValueType { + STRING = 0; + BOOL = 1; + INT64 = 2; + FLOAT64 = 3; + BINARY = 4; +}; + +message KeyValue { + + string key = 1; + ValueType v_type = 2; + string v_str = 3; + bool v_bool = 4; + int64 v_int64 = 5; + double v_float64 = 6; + bytes v_binary = 7; +} + +message Log { + google.protobuf.Timestamp timestamp = 1 ; + repeated KeyValue fields = 2 ; +} + +enum SpanRefType { + CHILD_OF = 0; + FOLLOWS_FROM = 1; +}; + +message SpanRef { + bytes trace_id = 1 ; + bytes span_id = 2 ; + SpanRefType ref_type = 3; +} + +message Process { + string service_name = 1; + repeated KeyValue tags = 2 ; +} + +message Span { + bytes trace_id = 1 ; + bytes span_id = 2 ; + string operation_name = 3; + repeated SpanRef references = 4 ; + uint32 flags = 5 ; + google.protobuf.Timestamp start_time = 6 ; + google.protobuf.Duration duration = 7 ; + repeated KeyValue tags = 8 ; + repeated Log logs = 9 ; + Process process = 10; + string process_id = 11 ; + repeated string warnings = 12; +} + +message Trace { + message ProcessMapping { + string process_id = 1 ; + Process process = 2 ; + } + repeated Span spans = 1; + repeated ProcessMapping process_map = 2 ; + repeated string warnings = 3; +} + +// Note that both Span and Batch may contain a Process. +// This is different from the Thrift model which was only used +// for transport, because Proto model is also used by the backend +// as the domain model, where once a batch is received it is split +// into individual spans which are all processed independently, +// and therefore they all need a Process. As far as on-the-wire +// semantics, both Batch and Spans in the same message may contain +// their own instances of Process, with span.Process taking priority +// over batch.Process. +message Batch { + repeated Span spans = 1; + Process process = 2 ; +} + +message DependencyLink { + string parent = 1; + string child = 2; + uint64 call_count = 3; + string source = 4; +} diff --git a/tools/otel/traceserver/pb/jaeger/storage/v1/storage.pb.go b/tools/otel/traceserver/pb/jaeger/storage/v1/storage.pb.go new file mode 100644 index 0000000000000..17f262f06f4f6 --- /dev/null +++ b/tools/otel/traceserver/pb/jaeger/storage/v1/storage.pb.go @@ -0,0 +1,1560 @@ +/* +Copyright The Kubernetes 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. +*/ + +// 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. + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.28.0 +// protoc v3.21.12 +// source: jaeger/storage/v1/storage.proto + +package v1 + +import ( + reflect "reflect" + sync "sync" + + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + durationpb "google.golang.org/protobuf/types/known/durationpb" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + v2 "k8s.io/kops/tools/otel/traceserver/pb/jaeger/api/v2" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type GetDependenciesRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + StartTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` + EndTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"` +} + +func (x *GetDependenciesRequest) Reset() { + *x = GetDependenciesRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetDependenciesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetDependenciesRequest) ProtoMessage() {} + +func (x *GetDependenciesRequest) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetDependenciesRequest.ProtoReflect.Descriptor instead. +func (*GetDependenciesRequest) Descriptor() ([]byte, []int) { + return file_jaeger_storage_v1_storage_proto_rawDescGZIP(), []int{0} +} + +func (x *GetDependenciesRequest) GetStartTime() *timestamppb.Timestamp { + if x != nil { + return x.StartTime + } + return nil +} + +func (x *GetDependenciesRequest) GetEndTime() *timestamppb.Timestamp { + if x != nil { + return x.EndTime + } + return nil +} + +type GetDependenciesResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Dependencies []*v2.DependencyLink `protobuf:"bytes,1,rep,name=dependencies,proto3" json:"dependencies,omitempty"` +} + +func (x *GetDependenciesResponse) Reset() { + *x = GetDependenciesResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetDependenciesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetDependenciesResponse) ProtoMessage() {} + +func (x *GetDependenciesResponse) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetDependenciesResponse.ProtoReflect.Descriptor instead. +func (*GetDependenciesResponse) Descriptor() ([]byte, []int) { + return file_jaeger_storage_v1_storage_proto_rawDescGZIP(), []int{1} +} + +func (x *GetDependenciesResponse) GetDependencies() []*v2.DependencyLink { + if x != nil { + return x.Dependencies + } + return nil +} + +type WriteSpanRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Span *v2.Span `protobuf:"bytes,1,opt,name=span,proto3" json:"span,omitempty"` +} + +func (x *WriteSpanRequest) Reset() { + *x = WriteSpanRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WriteSpanRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WriteSpanRequest) ProtoMessage() {} + +func (x *WriteSpanRequest) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WriteSpanRequest.ProtoReflect.Descriptor instead. +func (*WriteSpanRequest) Descriptor() ([]byte, []int) { + return file_jaeger_storage_v1_storage_proto_rawDescGZIP(), []int{2} +} + +func (x *WriteSpanRequest) GetSpan() *v2.Span { + if x != nil { + return x.Span + } + return nil +} + +// empty; extensible in the future +type WriteSpanResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *WriteSpanResponse) Reset() { + *x = WriteSpanResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WriteSpanResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WriteSpanResponse) ProtoMessage() {} + +func (x *WriteSpanResponse) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WriteSpanResponse.ProtoReflect.Descriptor instead. +func (*WriteSpanResponse) Descriptor() ([]byte, []int) { + return file_jaeger_storage_v1_storage_proto_rawDescGZIP(), []int{3} +} + +// empty; extensible in the future +type CloseWriterRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *CloseWriterRequest) Reset() { + *x = CloseWriterRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CloseWriterRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CloseWriterRequest) ProtoMessage() {} + +func (x *CloseWriterRequest) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CloseWriterRequest.ProtoReflect.Descriptor instead. +func (*CloseWriterRequest) Descriptor() ([]byte, []int) { + return file_jaeger_storage_v1_storage_proto_rawDescGZIP(), []int{4} +} + +// empty; extensible in the future +type CloseWriterResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *CloseWriterResponse) Reset() { + *x = CloseWriterResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CloseWriterResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CloseWriterResponse) ProtoMessage() {} + +func (x *CloseWriterResponse) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CloseWriterResponse.ProtoReflect.Descriptor instead. +func (*CloseWriterResponse) Descriptor() ([]byte, []int) { + return file_jaeger_storage_v1_storage_proto_rawDescGZIP(), []int{5} +} + +type GetTraceRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TraceId []byte `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"` +} + +func (x *GetTraceRequest) Reset() { + *x = GetTraceRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTraceRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTraceRequest) ProtoMessage() {} + +func (x *GetTraceRequest) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetTraceRequest.ProtoReflect.Descriptor instead. +func (*GetTraceRequest) Descriptor() ([]byte, []int) { + return file_jaeger_storage_v1_storage_proto_rawDescGZIP(), []int{6} +} + +func (x *GetTraceRequest) GetTraceId() []byte { + if x != nil { + return x.TraceId + } + return nil +} + +type GetServicesRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *GetServicesRequest) Reset() { + *x = GetServicesRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetServicesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetServicesRequest) ProtoMessage() {} + +func (x *GetServicesRequest) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetServicesRequest.ProtoReflect.Descriptor instead. +func (*GetServicesRequest) Descriptor() ([]byte, []int) { + return file_jaeger_storage_v1_storage_proto_rawDescGZIP(), []int{7} +} + +type GetServicesResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Services []string `protobuf:"bytes,1,rep,name=services,proto3" json:"services,omitempty"` +} + +func (x *GetServicesResponse) Reset() { + *x = GetServicesResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetServicesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetServicesResponse) ProtoMessage() {} + +func (x *GetServicesResponse) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetServicesResponse.ProtoReflect.Descriptor instead. +func (*GetServicesResponse) Descriptor() ([]byte, []int) { + return file_jaeger_storage_v1_storage_proto_rawDescGZIP(), []int{8} +} + +func (x *GetServicesResponse) GetServices() []string { + if x != nil { + return x.Services + } + return nil +} + +type GetOperationsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Service string `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"` + SpanKind string `protobuf:"bytes,2,opt,name=span_kind,json=spanKind,proto3" json:"span_kind,omitempty"` +} + +func (x *GetOperationsRequest) Reset() { + *x = GetOperationsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetOperationsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOperationsRequest) ProtoMessage() {} + +func (x *GetOperationsRequest) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetOperationsRequest.ProtoReflect.Descriptor instead. +func (*GetOperationsRequest) Descriptor() ([]byte, []int) { + return file_jaeger_storage_v1_storage_proto_rawDescGZIP(), []int{9} +} + +func (x *GetOperationsRequest) GetService() string { + if x != nil { + return x.Service + } + return "" +} + +func (x *GetOperationsRequest) GetSpanKind() string { + if x != nil { + return x.SpanKind + } + return "" +} + +type Operation struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + SpanKind string `protobuf:"bytes,2,opt,name=span_kind,json=spanKind,proto3" json:"span_kind,omitempty"` +} + +func (x *Operation) Reset() { + *x = Operation{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Operation) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Operation) ProtoMessage() {} + +func (x *Operation) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Operation.ProtoReflect.Descriptor instead. +func (*Operation) Descriptor() ([]byte, []int) { + return file_jaeger_storage_v1_storage_proto_rawDescGZIP(), []int{10} +} + +func (x *Operation) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Operation) GetSpanKind() string { + if x != nil { + return x.SpanKind + } + return "" +} + +type GetOperationsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OperationNames []string `protobuf:"bytes,1,rep,name=operationNames,proto3" json:"operationNames,omitempty"` // deprecated + Operations []*Operation `protobuf:"bytes,2,rep,name=operations,proto3" json:"operations,omitempty"` +} + +func (x *GetOperationsResponse) Reset() { + *x = GetOperationsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetOperationsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOperationsResponse) ProtoMessage() {} + +func (x *GetOperationsResponse) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetOperationsResponse.ProtoReflect.Descriptor instead. +func (*GetOperationsResponse) Descriptor() ([]byte, []int) { + return file_jaeger_storage_v1_storage_proto_rawDescGZIP(), []int{11} +} + +func (x *GetOperationsResponse) GetOperationNames() []string { + if x != nil { + return x.OperationNames + } + return nil +} + +func (x *GetOperationsResponse) GetOperations() []*Operation { + if x != nil { + return x.Operations + } + return nil +} + +type TraceQueryParameters struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + 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 *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=start_time_min,json=startTimeMin,proto3" json:"start_time_min,omitempty"` + StartTimeMax *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=start_time_max,json=startTimeMax,proto3" json:"start_time_max,omitempty"` + DurationMin *durationpb.Duration `protobuf:"bytes,6,opt,name=duration_min,json=durationMin,proto3" json:"duration_min,omitempty"` + DurationMax *durationpb.Duration `protobuf:"bytes,7,opt,name=duration_max,json=durationMax,proto3" json:"duration_max,omitempty"` + NumTraces int32 `protobuf:"varint,8,opt,name=num_traces,json=numTraces,proto3" json:"num_traces,omitempty"` +} + +func (x *TraceQueryParameters) Reset() { + *x = TraceQueryParameters{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TraceQueryParameters) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TraceQueryParameters) ProtoMessage() {} + +func (x *TraceQueryParameters) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TraceQueryParameters.ProtoReflect.Descriptor instead. +func (*TraceQueryParameters) Descriptor() ([]byte, []int) { + return file_jaeger_storage_v1_storage_proto_rawDescGZIP(), []int{12} +} + +func (x *TraceQueryParameters) GetServiceName() string { + if x != nil { + return x.ServiceName + } + return "" +} + +func (x *TraceQueryParameters) GetOperationName() string { + if x != nil { + return x.OperationName + } + return "" +} + +func (x *TraceQueryParameters) GetTags() map[string]string { + if x != nil { + return x.Tags + } + return nil +} + +func (x *TraceQueryParameters) GetStartTimeMin() *timestamppb.Timestamp { + if x != nil { + return x.StartTimeMin + } + return nil +} + +func (x *TraceQueryParameters) GetStartTimeMax() *timestamppb.Timestamp { + if x != nil { + return x.StartTimeMax + } + return nil +} + +func (x *TraceQueryParameters) GetDurationMin() *durationpb.Duration { + if x != nil { + return x.DurationMin + } + return nil +} + +func (x *TraceQueryParameters) GetDurationMax() *durationpb.Duration { + if x != nil { + return x.DurationMax + } + return nil +} + +func (x *TraceQueryParameters) GetNumTraces() int32 { + if x != nil { + return x.NumTraces + } + return 0 +} + +type FindTracesRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Query *TraceQueryParameters `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"` +} + +func (x *FindTracesRequest) Reset() { + *x = FindTracesRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FindTracesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FindTracesRequest) ProtoMessage() {} + +func (x *FindTracesRequest) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FindTracesRequest.ProtoReflect.Descriptor instead. +func (*FindTracesRequest) Descriptor() ([]byte, []int) { + return file_jaeger_storage_v1_storage_proto_rawDescGZIP(), []int{13} +} + +func (x *FindTracesRequest) GetQuery() *TraceQueryParameters { + if x != nil { + return x.Query + } + return nil +} + +type SpansResponseChunk struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Spans []*v2.Span `protobuf:"bytes,1,rep,name=spans,proto3" json:"spans,omitempty"` +} + +func (x *SpansResponseChunk) Reset() { + *x = SpansResponseChunk{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SpansResponseChunk) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SpansResponseChunk) ProtoMessage() {} + +func (x *SpansResponseChunk) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SpansResponseChunk.ProtoReflect.Descriptor instead. +func (*SpansResponseChunk) Descriptor() ([]byte, []int) { + return file_jaeger_storage_v1_storage_proto_rawDescGZIP(), []int{14} +} + +func (x *SpansResponseChunk) GetSpans() []*v2.Span { + if x != nil { + return x.Spans + } + return nil +} + +type FindTraceIDsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Query *TraceQueryParameters `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"` +} + +func (x *FindTraceIDsRequest) Reset() { + *x = FindTraceIDsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FindTraceIDsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FindTraceIDsRequest) ProtoMessage() {} + +func (x *FindTraceIDsRequest) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FindTraceIDsRequest.ProtoReflect.Descriptor instead. +func (*FindTraceIDsRequest) Descriptor() ([]byte, []int) { + return file_jaeger_storage_v1_storage_proto_rawDescGZIP(), []int{15} +} + +func (x *FindTraceIDsRequest) GetQuery() *TraceQueryParameters { + if x != nil { + return x.Query + } + return nil +} + +type FindTraceIDsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TraceIds [][]byte `protobuf:"bytes,1,rep,name=trace_ids,json=traceIds,proto3" json:"trace_ids,omitempty"` +} + +func (x *FindTraceIDsResponse) Reset() { + *x = FindTraceIDsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FindTraceIDsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FindTraceIDsResponse) ProtoMessage() {} + +func (x *FindTraceIDsResponse) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[16] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FindTraceIDsResponse.ProtoReflect.Descriptor instead. +func (*FindTraceIDsResponse) Descriptor() ([]byte, []int) { + return file_jaeger_storage_v1_storage_proto_rawDescGZIP(), []int{16} +} + +func (x *FindTraceIDsResponse) GetTraceIds() [][]byte { + if x != nil { + return x.TraceIds + } + return nil +} + +// empty; extensible in the future +type CapabilitiesRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *CapabilitiesRequest) Reset() { + *x = CapabilitiesRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CapabilitiesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CapabilitiesRequest) ProtoMessage() {} + +func (x *CapabilitiesRequest) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[17] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CapabilitiesRequest.ProtoReflect.Descriptor instead. +func (*CapabilitiesRequest) Descriptor() ([]byte, []int) { + return file_jaeger_storage_v1_storage_proto_rawDescGZIP(), []int{17} +} + +type CapabilitiesResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ArchiveSpanReader bool `protobuf:"varint,1,opt,name=archiveSpanReader,proto3" json:"archiveSpanReader,omitempty"` + ArchiveSpanWriter bool `protobuf:"varint,2,opt,name=archiveSpanWriter,proto3" json:"archiveSpanWriter,omitempty"` + StreamingSpanWriter bool `protobuf:"varint,3,opt,name=streamingSpanWriter,proto3" json:"streamingSpanWriter,omitempty"` +} + +func (x *CapabilitiesResponse) Reset() { + *x = CapabilitiesResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CapabilitiesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CapabilitiesResponse) ProtoMessage() {} + +func (x *CapabilitiesResponse) ProtoReflect() protoreflect.Message { + mi := &file_jaeger_storage_v1_storage_proto_msgTypes[18] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CapabilitiesResponse.ProtoReflect.Descriptor instead. +func (*CapabilitiesResponse) Descriptor() ([]byte, []int) { + return file_jaeger_storage_v1_storage_proto_rawDescGZIP(), []int{18} +} + +func (x *CapabilitiesResponse) GetArchiveSpanReader() bool { + if x != nil { + return x.ArchiveSpanReader + } + return false +} + +func (x *CapabilitiesResponse) GetArchiveSpanWriter() bool { + if x != nil { + return x.ArchiveSpanWriter + } + return false +} + +func (x *CapabilitiesResponse) GetStreamingSpanWriter() bool { + if x != nil { + return x.StreamingSpanWriter + } + return false +} + +var File_jaeger_storage_v1_storage_proto protoreflect.FileDescriptor + +var file_jaeger_storage_v1_storage_proto_rawDesc = []byte{ + 0x0a, 0x1f, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2f, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, + 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x11, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, + 0x65, 0x2e, 0x76, 0x31, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x19, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2f, 0x61, 0x70, + 0x69, 0x2f, 0x76, 0x32, 0x2f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x22, 0x8a, 0x01, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x44, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, + 0x63, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x39, 0x0a, 0x0a, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, + 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x5c, 0x0a, + 0x17, 0x47, 0x65, 0x74, 0x44, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x69, 0x65, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x41, 0x0a, 0x0c, 0x64, 0x65, 0x70, 0x65, + 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x69, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, + 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x32, 0x2e, 0x44, + 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x4c, 0x69, 0x6e, 0x6b, 0x52, 0x0c, 0x64, + 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x69, 0x65, 0x73, 0x22, 0x3b, 0x0a, 0x10, 0x57, + 0x72, 0x69, 0x74, 0x65, 0x53, 0x70, 0x61, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x27, 0x0a, 0x04, 0x73, 0x70, 0x61, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, + 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x32, 0x2e, 0x53, 0x70, + 0x61, 0x6e, 0x52, 0x04, 0x73, 0x70, 0x61, 0x6e, 0x22, 0x13, 0x0a, 0x11, 0x57, 0x72, 0x69, 0x74, + 0x65, 0x53, 0x70, 0x61, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x14, 0x0a, + 0x12, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x57, 0x72, 0x69, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x22, 0x15, 0x0a, 0x13, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x57, 0x72, 0x69, 0x74, + 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2c, 0x0a, 0x0f, 0x47, 0x65, + 0x74, 0x54, 0x72, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, + 0x08, 0x74, 0x72, 0x61, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, + 0x07, 0x74, 0x72, 0x61, 0x63, 0x65, 0x49, 0x64, 0x22, 0x14, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x53, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x31, + 0x0a, 0x13, 0x47, 0x65, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x73, 0x22, 0x4d, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x65, 0x72, + 0x76, 0x69, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x70, 0x61, 0x6e, 0x5f, 0x6b, 0x69, 0x6e, 0x64, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x73, 0x70, 0x61, 0x6e, 0x4b, 0x69, 0x6e, 0x64, + 0x22, 0x3c, 0x0a, 0x09, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x70, 0x61, 0x6e, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x73, 0x70, 0x61, 0x6e, 0x4b, 0x69, 0x6e, 0x64, 0x22, 0x7d, + 0x0a, 0x15, 0x47, 0x65, 0x74, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, 0x0e, 0x6f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, + 0x0e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, + 0x3c, 0x0a, 0x0a, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, + 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x0a, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xff, 0x03, + 0x0a, 0x14, 0x54, 0x72, 0x61, 0x63, 0x65, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, + 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x6f, 0x70, 0x65, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0d, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x61, 0x6d, 0x65, + 0x12, 0x45, 0x0a, 0x04, 0x74, 0x61, 0x67, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x31, + 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, + 0x76, 0x31, 0x2e, 0x54, 0x72, 0x61, 0x63, 0x65, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, + 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x2e, 0x54, 0x61, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x52, 0x04, 0x74, 0x61, 0x67, 0x73, 0x12, 0x40, 0x0a, 0x0e, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6d, 0x69, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x4d, 0x69, 0x6e, 0x12, 0x40, 0x0a, 0x0e, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6d, 0x61, 0x78, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x4d, 0x61, 0x78, 0x12, 0x3c, 0x0a, 0x0c, 0x64, + 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x64, 0x75, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x69, 0x6e, 0x12, 0x3c, 0x0a, 0x0c, 0x64, 0x75, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x61, 0x78, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x64, 0x75, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x61, 0x78, 0x12, 0x1d, 0x0a, 0x0a, 0x6e, 0x75, 0x6d, 0x5f, 0x74, + 0x72, 0x61, 0x63, 0x65, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x6e, 0x75, 0x6d, + 0x54, 0x72, 0x61, 0x63, 0x65, 0x73, 0x1a, 0x37, 0x0a, 0x09, 0x54, 0x61, 0x67, 0x73, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, + 0x52, 0x0a, 0x11, 0x46, 0x69, 0x6e, 0x64, 0x54, 0x72, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x3d, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, + 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x72, 0x61, 0x63, 0x65, 0x51, 0x75, 0x65, + 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x52, 0x05, 0x71, 0x75, + 0x65, 0x72, 0x79, 0x22, 0x3f, 0x0a, 0x12, 0x53, 0x70, 0x61, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x12, 0x29, 0x0a, 0x05, 0x73, 0x70, 0x61, + 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, + 0x72, 0x2e, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x32, 0x2e, 0x53, 0x70, 0x61, 0x6e, 0x52, 0x05, 0x73, + 0x70, 0x61, 0x6e, 0x73, 0x22, 0x54, 0x0a, 0x13, 0x46, 0x69, 0x6e, 0x64, 0x54, 0x72, 0x61, 0x63, + 0x65, 0x49, 0x44, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3d, 0x0a, 0x05, 0x71, + 0x75, 0x65, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x6a, 0x61, 0x65, + 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, + 0x72, 0x61, 0x63, 0x65, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, + 0x65, 0x72, 0x73, 0x52, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x22, 0x33, 0x0a, 0x14, 0x46, 0x69, + 0x6e, 0x64, 0x54, 0x72, 0x61, 0x63, 0x65, 0x49, 0x44, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x72, 0x61, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x08, 0x74, 0x72, 0x61, 0x63, 0x65, 0x49, 0x64, 0x73, 0x22, + 0x15, 0x0a, 0x13, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xa4, 0x01, 0x0a, 0x14, 0x43, 0x61, 0x70, 0x61, 0x62, + 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x2c, 0x0a, 0x11, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x53, 0x70, 0x61, 0x6e, 0x52, 0x65, + 0x61, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x11, 0x61, 0x72, 0x63, 0x68, + 0x69, 0x76, 0x65, 0x53, 0x70, 0x61, 0x6e, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x2c, 0x0a, + 0x11, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x53, 0x70, 0x61, 0x6e, 0x57, 0x72, 0x69, 0x74, + 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x11, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76, + 0x65, 0x53, 0x70, 0x61, 0x6e, 0x57, 0x72, 0x69, 0x74, 0x65, 0x72, 0x12, 0x30, 0x0a, 0x13, 0x73, + 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, 0x6e, 0x67, 0x53, 0x70, 0x61, 0x6e, 0x57, 0x72, 0x69, 0x74, + 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x13, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, + 0x69, 0x6e, 0x67, 0x53, 0x70, 0x61, 0x6e, 0x57, 0x72, 0x69, 0x74, 0x65, 0x72, 0x32, 0xc2, 0x01, + 0x0a, 0x10, 0x53, 0x70, 0x61, 0x6e, 0x57, 0x72, 0x69, 0x74, 0x65, 0x72, 0x50, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x12, 0x56, 0x0a, 0x09, 0x57, 0x72, 0x69, 0x74, 0x65, 0x53, 0x70, 0x61, 0x6e, 0x12, + 0x23, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, + 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x72, 0x69, 0x74, 0x65, 0x53, 0x70, 0x61, 0x6e, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, + 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x72, 0x69, 0x74, 0x65, 0x53, 0x70, + 0x61, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x56, 0x0a, 0x05, 0x43, 0x6c, + 0x6f, 0x73, 0x65, 0x12, 0x25, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, + 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x57, 0x72, 0x69, + 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6a, 0x61, 0x65, + 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x43, + 0x6c, 0x6f, 0x73, 0x65, 0x57, 0x72, 0x69, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x32, 0x7b, 0x0a, 0x19, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, 0x6e, 0x67, 0x53, + 0x70, 0x61, 0x6e, 0x57, 0x72, 0x69, 0x74, 0x65, 0x72, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x12, + 0x5e, 0x0a, 0x0f, 0x57, 0x72, 0x69, 0x74, 0x65, 0x53, 0x70, 0x61, 0x6e, 0x53, 0x74, 0x72, 0x65, + 0x61, 0x6d, 0x12, 0x23, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, 0x72, + 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x72, 0x69, 0x74, 0x65, 0x53, 0x70, 0x61, 0x6e, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, + 0x2e, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x72, 0x69, 0x74, + 0x65, 0x53, 0x70, 0x61, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x28, 0x01, 0x32, + 0xeb, 0x03, 0x0a, 0x10, 0x53, 0x70, 0x61, 0x6e, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x50, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x12, 0x57, 0x0a, 0x08, 0x47, 0x65, 0x74, 0x54, 0x72, 0x61, 0x63, 0x65, + 0x12, 0x22, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, + 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x72, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, + 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x70, 0x61, 0x6e, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x30, 0x01, 0x12, 0x5c, 0x0a, + 0x0b, 0x47, 0x65, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x25, 0x2e, 0x6a, + 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, + 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, + 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x62, 0x0a, 0x0d, 0x47, + 0x65, 0x74, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x27, 0x2e, 0x6a, + 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, + 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, + 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x70, 0x65, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x5b, 0x0a, 0x0a, 0x46, 0x69, 0x6e, 0x64, 0x54, 0x72, 0x61, 0x63, 0x65, 0x73, 0x12, 0x24, 0x2e, + 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, + 0x31, 0x2e, 0x46, 0x69, 0x6e, 0x64, 0x54, 0x72, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, + 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x70, 0x61, 0x6e, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x30, 0x01, 0x12, 0x5f, 0x0a, 0x0c, + 0x46, 0x69, 0x6e, 0x64, 0x54, 0x72, 0x61, 0x63, 0x65, 0x49, 0x44, 0x73, 0x12, 0x26, 0x2e, 0x6a, + 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, + 0x2e, 0x46, 0x69, 0x6e, 0x64, 0x54, 0x72, 0x61, 0x63, 0x65, 0x49, 0x44, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, + 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x69, 0x6e, 0x64, 0x54, 0x72, 0x61, + 0x63, 0x65, 0x49, 0x44, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0x78, 0x0a, + 0x17, 0x41, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x53, 0x70, 0x61, 0x6e, 0x57, 0x72, 0x69, 0x74, + 0x65, 0x72, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x12, 0x5d, 0x0a, 0x10, 0x57, 0x72, 0x69, 0x74, + 0x65, 0x41, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x53, 0x70, 0x61, 0x6e, 0x12, 0x23, 0x2e, 0x6a, + 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, + 0x2e, 0x57, 0x72, 0x69, 0x74, 0x65, 0x53, 0x70, 0x61, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x24, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, 0x72, 0x61, + 0x67, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x72, 0x69, 0x74, 0x65, 0x53, 0x70, 0x61, 0x6e, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0x79, 0x0a, 0x17, 0x41, 0x72, 0x63, 0x68, 0x69, + 0x76, 0x65, 0x53, 0x70, 0x61, 0x6e, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x50, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x12, 0x5e, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x41, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, + 0x54, 0x72, 0x61, 0x63, 0x65, 0x12, 0x22, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, + 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x72, 0x61, + 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6a, 0x61, 0x65, 0x67, + 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x70, + 0x61, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x43, 0x68, 0x75, 0x6e, 0x6b, + 0x30, 0x01, 0x32, 0x84, 0x01, 0x0a, 0x18, 0x44, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, + 0x69, 0x65, 0x73, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x12, + 0x68, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x44, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x69, + 0x65, 0x73, 0x12, 0x29, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, 0x72, + 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x44, 0x65, 0x70, 0x65, 0x6e, 0x64, + 0x65, 0x6e, 0x63, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, + 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, + 0x31, 0x2e, 0x47, 0x65, 0x74, 0x44, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x69, 0x65, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0x75, 0x0a, 0x12, 0x50, 0x6c, 0x75, + 0x67, 0x69, 0x6e, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x12, + 0x5f, 0x0a, 0x0c, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x12, + 0x26, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, + 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, + 0x2e, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x61, 0x70, 0x61, + 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x42, 0x39, 0x5a, 0x37, 0x6b, 0x38, 0x73, 0x2e, 0x69, 0x6f, 0x2f, 0x6b, 0x6f, 0x70, 0x73, 0x2f, + 0x74, 0x6f, 0x6f, 0x6c, 0x73, 0x2f, 0x6f, 0x74, 0x65, 0x6c, 0x2f, 0x74, 0x72, 0x61, 0x63, 0x65, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2f, 0x70, 0x62, 0x2f, 0x6a, 0x61, 0x65, 0x67, 0x65, 0x72, + 0x2f, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, +} + +var ( + file_jaeger_storage_v1_storage_proto_rawDescOnce sync.Once + file_jaeger_storage_v1_storage_proto_rawDescData = file_jaeger_storage_v1_storage_proto_rawDesc +) + +func file_jaeger_storage_v1_storage_proto_rawDescGZIP() []byte { + file_jaeger_storage_v1_storage_proto_rawDescOnce.Do(func() { + file_jaeger_storage_v1_storage_proto_rawDescData = protoimpl.X.CompressGZIP(file_jaeger_storage_v1_storage_proto_rawDescData) + }) + return file_jaeger_storage_v1_storage_proto_rawDescData +} + +var file_jaeger_storage_v1_storage_proto_msgTypes = make([]protoimpl.MessageInfo, 20) +var file_jaeger_storage_v1_storage_proto_goTypes = []interface{}{ + (*GetDependenciesRequest)(nil), // 0: jaeger.storage.v1.GetDependenciesRequest + (*GetDependenciesResponse)(nil), // 1: jaeger.storage.v1.GetDependenciesResponse + (*WriteSpanRequest)(nil), // 2: jaeger.storage.v1.WriteSpanRequest + (*WriteSpanResponse)(nil), // 3: jaeger.storage.v1.WriteSpanResponse + (*CloseWriterRequest)(nil), // 4: jaeger.storage.v1.CloseWriterRequest + (*CloseWriterResponse)(nil), // 5: jaeger.storage.v1.CloseWriterResponse + (*GetTraceRequest)(nil), // 6: jaeger.storage.v1.GetTraceRequest + (*GetServicesRequest)(nil), // 7: jaeger.storage.v1.GetServicesRequest + (*GetServicesResponse)(nil), // 8: jaeger.storage.v1.GetServicesResponse + (*GetOperationsRequest)(nil), // 9: jaeger.storage.v1.GetOperationsRequest + (*Operation)(nil), // 10: jaeger.storage.v1.Operation + (*GetOperationsResponse)(nil), // 11: jaeger.storage.v1.GetOperationsResponse + (*TraceQueryParameters)(nil), // 12: jaeger.storage.v1.TraceQueryParameters + (*FindTracesRequest)(nil), // 13: jaeger.storage.v1.FindTracesRequest + (*SpansResponseChunk)(nil), // 14: jaeger.storage.v1.SpansResponseChunk + (*FindTraceIDsRequest)(nil), // 15: jaeger.storage.v1.FindTraceIDsRequest + (*FindTraceIDsResponse)(nil), // 16: jaeger.storage.v1.FindTraceIDsResponse + (*CapabilitiesRequest)(nil), // 17: jaeger.storage.v1.CapabilitiesRequest + (*CapabilitiesResponse)(nil), // 18: jaeger.storage.v1.CapabilitiesResponse + nil, // 19: jaeger.storage.v1.TraceQueryParameters.TagsEntry + (*timestamppb.Timestamp)(nil), // 20: google.protobuf.Timestamp + (*v2.DependencyLink)(nil), // 21: jaeger.api_v2.DependencyLink + (*v2.Span)(nil), // 22: jaeger.api_v2.Span + (*durationpb.Duration)(nil), // 23: google.protobuf.Duration +} +var file_jaeger_storage_v1_storage_proto_depIdxs = []int32{ + 20, // 0: jaeger.storage.v1.GetDependenciesRequest.start_time:type_name -> google.protobuf.Timestamp + 20, // 1: jaeger.storage.v1.GetDependenciesRequest.end_time:type_name -> google.protobuf.Timestamp + 21, // 2: jaeger.storage.v1.GetDependenciesResponse.dependencies:type_name -> jaeger.api_v2.DependencyLink + 22, // 3: jaeger.storage.v1.WriteSpanRequest.span:type_name -> jaeger.api_v2.Span + 10, // 4: jaeger.storage.v1.GetOperationsResponse.operations:type_name -> jaeger.storage.v1.Operation + 19, // 5: jaeger.storage.v1.TraceQueryParameters.tags:type_name -> jaeger.storage.v1.TraceQueryParameters.TagsEntry + 20, // 6: jaeger.storage.v1.TraceQueryParameters.start_time_min:type_name -> google.protobuf.Timestamp + 20, // 7: jaeger.storage.v1.TraceQueryParameters.start_time_max:type_name -> google.protobuf.Timestamp + 23, // 8: jaeger.storage.v1.TraceQueryParameters.duration_min:type_name -> google.protobuf.Duration + 23, // 9: jaeger.storage.v1.TraceQueryParameters.duration_max:type_name -> google.protobuf.Duration + 12, // 10: jaeger.storage.v1.FindTracesRequest.query:type_name -> jaeger.storage.v1.TraceQueryParameters + 22, // 11: jaeger.storage.v1.SpansResponseChunk.spans:type_name -> jaeger.api_v2.Span + 12, // 12: jaeger.storage.v1.FindTraceIDsRequest.query:type_name -> jaeger.storage.v1.TraceQueryParameters + 2, // 13: jaeger.storage.v1.SpanWriterPlugin.WriteSpan:input_type -> jaeger.storage.v1.WriteSpanRequest + 4, // 14: jaeger.storage.v1.SpanWriterPlugin.Close:input_type -> jaeger.storage.v1.CloseWriterRequest + 2, // 15: jaeger.storage.v1.StreamingSpanWriterPlugin.WriteSpanStream:input_type -> jaeger.storage.v1.WriteSpanRequest + 6, // 16: jaeger.storage.v1.SpanReaderPlugin.GetTrace:input_type -> jaeger.storage.v1.GetTraceRequest + 7, // 17: jaeger.storage.v1.SpanReaderPlugin.GetServices:input_type -> jaeger.storage.v1.GetServicesRequest + 9, // 18: jaeger.storage.v1.SpanReaderPlugin.GetOperations:input_type -> jaeger.storage.v1.GetOperationsRequest + 13, // 19: jaeger.storage.v1.SpanReaderPlugin.FindTraces:input_type -> jaeger.storage.v1.FindTracesRequest + 15, // 20: jaeger.storage.v1.SpanReaderPlugin.FindTraceIDs:input_type -> jaeger.storage.v1.FindTraceIDsRequest + 2, // 21: jaeger.storage.v1.ArchiveSpanWriterPlugin.WriteArchiveSpan:input_type -> jaeger.storage.v1.WriteSpanRequest + 6, // 22: jaeger.storage.v1.ArchiveSpanReaderPlugin.GetArchiveTrace:input_type -> jaeger.storage.v1.GetTraceRequest + 0, // 23: jaeger.storage.v1.DependenciesReaderPlugin.GetDependencies:input_type -> jaeger.storage.v1.GetDependenciesRequest + 17, // 24: jaeger.storage.v1.PluginCapabilities.Capabilities:input_type -> jaeger.storage.v1.CapabilitiesRequest + 3, // 25: jaeger.storage.v1.SpanWriterPlugin.WriteSpan:output_type -> jaeger.storage.v1.WriteSpanResponse + 5, // 26: jaeger.storage.v1.SpanWriterPlugin.Close:output_type -> jaeger.storage.v1.CloseWriterResponse + 3, // 27: jaeger.storage.v1.StreamingSpanWriterPlugin.WriteSpanStream:output_type -> jaeger.storage.v1.WriteSpanResponse + 14, // 28: jaeger.storage.v1.SpanReaderPlugin.GetTrace:output_type -> jaeger.storage.v1.SpansResponseChunk + 8, // 29: jaeger.storage.v1.SpanReaderPlugin.GetServices:output_type -> jaeger.storage.v1.GetServicesResponse + 11, // 30: jaeger.storage.v1.SpanReaderPlugin.GetOperations:output_type -> jaeger.storage.v1.GetOperationsResponse + 14, // 31: jaeger.storage.v1.SpanReaderPlugin.FindTraces:output_type -> jaeger.storage.v1.SpansResponseChunk + 16, // 32: jaeger.storage.v1.SpanReaderPlugin.FindTraceIDs:output_type -> jaeger.storage.v1.FindTraceIDsResponse + 3, // 33: jaeger.storage.v1.ArchiveSpanWriterPlugin.WriteArchiveSpan:output_type -> jaeger.storage.v1.WriteSpanResponse + 14, // 34: jaeger.storage.v1.ArchiveSpanReaderPlugin.GetArchiveTrace:output_type -> jaeger.storage.v1.SpansResponseChunk + 1, // 35: jaeger.storage.v1.DependenciesReaderPlugin.GetDependencies:output_type -> jaeger.storage.v1.GetDependenciesResponse + 18, // 36: jaeger.storage.v1.PluginCapabilities.Capabilities:output_type -> jaeger.storage.v1.CapabilitiesResponse + 25, // [25:37] is the sub-list for method output_type + 13, // [13:25] is the sub-list for method input_type + 13, // [13:13] is the sub-list for extension type_name + 13, // [13:13] is the sub-list for extension extendee + 0, // [0:13] is the sub-list for field type_name +} + +func init() { file_jaeger_storage_v1_storage_proto_init() } +func file_jaeger_storage_v1_storage_proto_init() { + if File_jaeger_storage_v1_storage_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_jaeger_storage_v1_storage_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetDependenciesRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_storage_v1_storage_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetDependenciesResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_storage_v1_storage_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WriteSpanRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_storage_v1_storage_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WriteSpanResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_storage_v1_storage_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CloseWriterRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_storage_v1_storage_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CloseWriterResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_storage_v1_storage_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTraceRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_storage_v1_storage_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetServicesRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_storage_v1_storage_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetServicesResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_storage_v1_storage_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetOperationsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_storage_v1_storage_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Operation); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_storage_v1_storage_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetOperationsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_storage_v1_storage_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TraceQueryParameters); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_storage_v1_storage_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FindTracesRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_storage_v1_storage_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SpansResponseChunk); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_storage_v1_storage_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FindTraceIDsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_storage_v1_storage_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FindTraceIDsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_storage_v1_storage_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CapabilitiesRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_jaeger_storage_v1_storage_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CapabilitiesResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_jaeger_storage_v1_storage_proto_rawDesc, + NumEnums: 0, + NumMessages: 20, + NumExtensions: 0, + NumServices: 7, + }, + GoTypes: file_jaeger_storage_v1_storage_proto_goTypes, + DependencyIndexes: file_jaeger_storage_v1_storage_proto_depIdxs, + MessageInfos: file_jaeger_storage_v1_storage_proto_msgTypes, + }.Build() + File_jaeger_storage_v1_storage_proto = out.File + file_jaeger_storage_v1_storage_proto_rawDesc = nil + file_jaeger_storage_v1_storage_proto_goTypes = nil + file_jaeger_storage_v1_storage_proto_depIdxs = nil +} diff --git a/tools/otel/traceserver/pb/jaeger/storage/v1/storage.proto b/tools/otel/traceserver/pb/jaeger/storage/v1/storage.proto new file mode 100644 index 0000000000000..ed1822ae6ef5f --- /dev/null +++ b/tools/otel/traceserver/pb/jaeger/storage/v1/storage.proto @@ -0,0 +1,155 @@ +// 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="k8s.io/kops/tools/otel/traceserver/pb/jaeger/storage/v1"; // = "storage_v1"; + +import "google/protobuf/timestamp.proto"; +import "google/protobuf/duration.proto"; + +import "jaeger/api/v2/model.proto"; + +// Enable custom Marshal method. +// Enable custom Unmarshal method. +// Enable custom Size method (Required by Marshal and Unmarshal). + +message GetDependenciesRequest { + google.protobuf.Timestamp start_time = 1 ; + google.protobuf.Timestamp end_time = 2 ; +} + +message GetDependenciesResponse { + repeated jaeger.api_v2.DependencyLink dependencies = 1 ; +} + +message WriteSpanRequest { + jaeger.api_v2.Span span = 1; +} + +// empty; extensible in the future +message WriteSpanResponse { + +} + +// empty; extensible in the future +message CloseWriterRequest { +} + +// empty; extensible in the future +message CloseWriterResponse { +} + +message GetTraceRequest { + bytes trace_id = 1 ; +} + +message GetServicesRequest {} + +message GetServicesResponse { + repeated string services = 1; +} + +message GetOperationsRequest { + string service = 1; + string span_kind = 2; +} + +message Operation { + string name = 1; + string span_kind = 2; +} + +message GetOperationsResponse { + repeated string operationNames = 1; // deprecated + repeated Operation operations = 2; +} + +message TraceQueryParameters { + string service_name = 1; + string operation_name = 2; + map tags = 3; + google.protobuf.Timestamp start_time_min = 4 ; + google.protobuf.Timestamp start_time_max = 5 ; + google.protobuf.Duration duration_min = 6 ; + google.protobuf.Duration duration_max = 7 ; + int32 num_traces = 8; +} + +message FindTracesRequest { + TraceQueryParameters query = 1; +} + +message SpansResponseChunk { + repeated jaeger.api_v2.Span spans = 1 ; +} + +message FindTraceIDsRequest { + TraceQueryParameters query = 1; +} + +message FindTraceIDsResponse { + repeated bytes trace_ids = 1 ; +} + +service SpanWriterPlugin { + // spanstore/Writer + rpc WriteSpan(WriteSpanRequest) returns (WriteSpanResponse); + rpc Close(CloseWriterRequest) returns (CloseWriterResponse); +} + +service StreamingSpanWriterPlugin { + rpc WriteSpanStream(stream 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 ArchiveSpanWriterPlugin { + // spanstore/Writer + rpc WriteArchiveSpan(WriteSpanRequest) returns (WriteSpanResponse); +} + +service ArchiveSpanReaderPlugin { + // spanstore/Reader + rpc GetArchiveTrace(GetTraceRequest) returns (stream SpansResponseChunk); +} + +service DependenciesReaderPlugin { + // dependencystore/Reader + rpc GetDependencies(GetDependenciesRequest) returns (GetDependenciesResponse); +} + +// empty; extensible in the future +message CapabilitiesRequest { + +} + +message CapabilitiesResponse { + bool archiveSpanReader = 1; + bool archiveSpanWriter = 2; + bool streamingSpanWriter = 3; +} + +service PluginCapabilities { + rpc Capabilities(CapabilitiesRequest) returns (CapabilitiesResponse); +} \ No newline at end of file diff --git a/tools/otel/traceserver/pb/jaeger/storage/v1/storage_grpc.pb.go b/tools/otel/traceserver/pb/jaeger/storage/v1/storage_grpc.pb.go new file mode 100644 index 0000000000000..4a57fb936e121 --- /dev/null +++ b/tools/otel/traceserver/pb/jaeger/storage/v1/storage_grpc.pb.go @@ -0,0 +1,944 @@ +/* +Copyright The Kubernetes 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. +*/ + +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. + +package v1 + +import ( + context "context" + + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +// SpanWriterPluginClient is the client API for SpanWriterPlugin service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type SpanWriterPluginClient interface { + // spanstore/Writer + WriteSpan(ctx context.Context, in *WriteSpanRequest, opts ...grpc.CallOption) (*WriteSpanResponse, error) + Close(ctx context.Context, in *CloseWriterRequest, opts ...grpc.CallOption) (*CloseWriterResponse, error) +} + +type spanWriterPluginClient struct { + cc grpc.ClientConnInterface +} + +func NewSpanWriterPluginClient(cc grpc.ClientConnInterface) SpanWriterPluginClient { + return &spanWriterPluginClient{cc} +} + +func (c *spanWriterPluginClient) WriteSpan(ctx context.Context, in *WriteSpanRequest, opts ...grpc.CallOption) (*WriteSpanResponse, error) { + out := new(WriteSpanResponse) + err := c.cc.Invoke(ctx, "/jaeger.storage.v1.SpanWriterPlugin/WriteSpan", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *spanWriterPluginClient) Close(ctx context.Context, in *CloseWriterRequest, opts ...grpc.CallOption) (*CloseWriterResponse, error) { + out := new(CloseWriterResponse) + err := c.cc.Invoke(ctx, "/jaeger.storage.v1.SpanWriterPlugin/Close", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// SpanWriterPluginServer is the server API for SpanWriterPlugin service. +// All implementations must embed UnimplementedSpanWriterPluginServer +// for forward compatibility +type SpanWriterPluginServer interface { + // spanstore/Writer + WriteSpan(context.Context, *WriteSpanRequest) (*WriteSpanResponse, error) + Close(context.Context, *CloseWriterRequest) (*CloseWriterResponse, error) + mustEmbedUnimplementedSpanWriterPluginServer() +} + +// UnimplementedSpanWriterPluginServer must be embedded to have forward compatible implementations. +type UnimplementedSpanWriterPluginServer struct { +} + +func (UnimplementedSpanWriterPluginServer) WriteSpan(context.Context, *WriteSpanRequest) (*WriteSpanResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method WriteSpan not implemented") +} +func (UnimplementedSpanWriterPluginServer) Close(context.Context, *CloseWriterRequest) (*CloseWriterResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Close not implemented") +} +func (UnimplementedSpanWriterPluginServer) mustEmbedUnimplementedSpanWriterPluginServer() {} + +// UnsafeSpanWriterPluginServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to SpanWriterPluginServer will +// result in compilation errors. +type UnsafeSpanWriterPluginServer interface { + mustEmbedUnimplementedSpanWriterPluginServer() +} + +func RegisterSpanWriterPluginServer(s grpc.ServiceRegistrar, 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) +} + +func _SpanWriterPlugin_Close_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CloseWriterRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SpanWriterPluginServer).Close(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/jaeger.storage.v1.SpanWriterPlugin/Close", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SpanWriterPluginServer).Close(ctx, req.(*CloseWriterRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// SpanWriterPlugin_ServiceDesc is the grpc.ServiceDesc for SpanWriterPlugin service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var SpanWriterPlugin_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "jaeger.storage.v1.SpanWriterPlugin", + HandlerType: (*SpanWriterPluginServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "WriteSpan", + Handler: _SpanWriterPlugin_WriteSpan_Handler, + }, + { + MethodName: "Close", + Handler: _SpanWriterPlugin_Close_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "jaeger/storage/v1/storage.proto", +} + +// StreamingSpanWriterPluginClient is the client API for StreamingSpanWriterPlugin service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type StreamingSpanWriterPluginClient interface { + WriteSpanStream(ctx context.Context, opts ...grpc.CallOption) (StreamingSpanWriterPlugin_WriteSpanStreamClient, error) +} + +type streamingSpanWriterPluginClient struct { + cc grpc.ClientConnInterface +} + +func NewStreamingSpanWriterPluginClient(cc grpc.ClientConnInterface) StreamingSpanWriterPluginClient { + return &streamingSpanWriterPluginClient{cc} +} + +func (c *streamingSpanWriterPluginClient) WriteSpanStream(ctx context.Context, opts ...grpc.CallOption) (StreamingSpanWriterPlugin_WriteSpanStreamClient, error) { + stream, err := c.cc.NewStream(ctx, &StreamingSpanWriterPlugin_ServiceDesc.Streams[0], "/jaeger.storage.v1.StreamingSpanWriterPlugin/WriteSpanStream", opts...) + if err != nil { + return nil, err + } + x := &streamingSpanWriterPluginWriteSpanStreamClient{stream} + return x, nil +} + +type StreamingSpanWriterPlugin_WriteSpanStreamClient interface { + Send(*WriteSpanRequest) error + CloseAndRecv() (*WriteSpanResponse, error) + grpc.ClientStream +} + +type streamingSpanWriterPluginWriteSpanStreamClient struct { + grpc.ClientStream +} + +func (x *streamingSpanWriterPluginWriteSpanStreamClient) Send(m *WriteSpanRequest) error { + return x.ClientStream.SendMsg(m) +} + +func (x *streamingSpanWriterPluginWriteSpanStreamClient) CloseAndRecv() (*WriteSpanResponse, error) { + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + m := new(WriteSpanResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// StreamingSpanWriterPluginServer is the server API for StreamingSpanWriterPlugin service. +// All implementations must embed UnimplementedStreamingSpanWriterPluginServer +// for forward compatibility +type StreamingSpanWriterPluginServer interface { + WriteSpanStream(StreamingSpanWriterPlugin_WriteSpanStreamServer) error + mustEmbedUnimplementedStreamingSpanWriterPluginServer() +} + +// UnimplementedStreamingSpanWriterPluginServer must be embedded to have forward compatible implementations. +type UnimplementedStreamingSpanWriterPluginServer struct { +} + +func (UnimplementedStreamingSpanWriterPluginServer) WriteSpanStream(StreamingSpanWriterPlugin_WriteSpanStreamServer) error { + return status.Errorf(codes.Unimplemented, "method WriteSpanStream not implemented") +} +func (UnimplementedStreamingSpanWriterPluginServer) mustEmbedUnimplementedStreamingSpanWriterPluginServer() { +} + +// UnsafeStreamingSpanWriterPluginServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to StreamingSpanWriterPluginServer will +// result in compilation errors. +type UnsafeStreamingSpanWriterPluginServer interface { + mustEmbedUnimplementedStreamingSpanWriterPluginServer() +} + +func RegisterStreamingSpanWriterPluginServer(s grpc.ServiceRegistrar, srv StreamingSpanWriterPluginServer) { + s.RegisterService(&StreamingSpanWriterPlugin_ServiceDesc, srv) +} + +func _StreamingSpanWriterPlugin_WriteSpanStream_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(StreamingSpanWriterPluginServer).WriteSpanStream(&streamingSpanWriterPluginWriteSpanStreamServer{stream}) +} + +type StreamingSpanWriterPlugin_WriteSpanStreamServer interface { + SendAndClose(*WriteSpanResponse) error + Recv() (*WriteSpanRequest, error) + grpc.ServerStream +} + +type streamingSpanWriterPluginWriteSpanStreamServer struct { + grpc.ServerStream +} + +func (x *streamingSpanWriterPluginWriteSpanStreamServer) SendAndClose(m *WriteSpanResponse) error { + return x.ServerStream.SendMsg(m) +} + +func (x *streamingSpanWriterPluginWriteSpanStreamServer) Recv() (*WriteSpanRequest, error) { + m := new(WriteSpanRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// StreamingSpanWriterPlugin_ServiceDesc is the grpc.ServiceDesc for StreamingSpanWriterPlugin service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var StreamingSpanWriterPlugin_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "jaeger.storage.v1.StreamingSpanWriterPlugin", + HandlerType: (*StreamingSpanWriterPluginServer)(nil), + Methods: []grpc.MethodDesc{}, + Streams: []grpc.StreamDesc{ + { + StreamName: "WriteSpanStream", + Handler: _StreamingSpanWriterPlugin_WriteSpanStream_Handler, + ClientStreams: true, + }, + }, + Metadata: "jaeger/storage/v1/storage.proto", +} + +// SpanReaderPluginClient is the client API for SpanReaderPlugin service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#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.ClientConnInterface +} + +func NewSpanReaderPluginClient(cc grpc.ClientConnInterface) 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. +// All implementations must embed UnimplementedSpanReaderPluginServer +// for forward compatibility +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) + mustEmbedUnimplementedSpanReaderPluginServer() +} + +// UnimplementedSpanReaderPluginServer must be embedded to have forward compatible implementations. +type UnimplementedSpanReaderPluginServer struct { +} + +func (UnimplementedSpanReaderPluginServer) GetTrace(*GetTraceRequest, SpanReaderPlugin_GetTraceServer) error { + return status.Errorf(codes.Unimplemented, "method GetTrace not implemented") +} +func (UnimplementedSpanReaderPluginServer) GetServices(context.Context, *GetServicesRequest) (*GetServicesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetServices not implemented") +} +func (UnimplementedSpanReaderPluginServer) GetOperations(context.Context, *GetOperationsRequest) (*GetOperationsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetOperations not implemented") +} +func (UnimplementedSpanReaderPluginServer) FindTraces(*FindTracesRequest, SpanReaderPlugin_FindTracesServer) error { + return status.Errorf(codes.Unimplemented, "method FindTraces not implemented") +} +func (UnimplementedSpanReaderPluginServer) FindTraceIDs(context.Context, *FindTraceIDsRequest) (*FindTraceIDsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method FindTraceIDs not implemented") +} +func (UnimplementedSpanReaderPluginServer) mustEmbedUnimplementedSpanReaderPluginServer() {} + +// UnsafeSpanReaderPluginServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to SpanReaderPluginServer will +// result in compilation errors. +type UnsafeSpanReaderPluginServer interface { + mustEmbedUnimplementedSpanReaderPluginServer() +} + +func RegisterSpanReaderPluginServer(s grpc.ServiceRegistrar, 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) +} + +// SpanReaderPlugin_ServiceDesc is the grpc.ServiceDesc for SpanReaderPlugin service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +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: "jaeger/storage/v1/storage.proto", +} + +// ArchiveSpanWriterPluginClient is the client API for ArchiveSpanWriterPlugin service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type ArchiveSpanWriterPluginClient interface { + // spanstore/Writer + WriteArchiveSpan(ctx context.Context, in *WriteSpanRequest, opts ...grpc.CallOption) (*WriteSpanResponse, error) +} + +type archiveSpanWriterPluginClient struct { + cc grpc.ClientConnInterface +} + +func NewArchiveSpanWriterPluginClient(cc grpc.ClientConnInterface) ArchiveSpanWriterPluginClient { + return &archiveSpanWriterPluginClient{cc} +} + +func (c *archiveSpanWriterPluginClient) WriteArchiveSpan(ctx context.Context, in *WriteSpanRequest, opts ...grpc.CallOption) (*WriteSpanResponse, error) { + out := new(WriteSpanResponse) + err := c.cc.Invoke(ctx, "/jaeger.storage.v1.ArchiveSpanWriterPlugin/WriteArchiveSpan", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// ArchiveSpanWriterPluginServer is the server API for ArchiveSpanWriterPlugin service. +// All implementations must embed UnimplementedArchiveSpanWriterPluginServer +// for forward compatibility +type ArchiveSpanWriterPluginServer interface { + // spanstore/Writer + WriteArchiveSpan(context.Context, *WriteSpanRequest) (*WriteSpanResponse, error) + mustEmbedUnimplementedArchiveSpanWriterPluginServer() +} + +// UnimplementedArchiveSpanWriterPluginServer must be embedded to have forward compatible implementations. +type UnimplementedArchiveSpanWriterPluginServer struct { +} + +func (UnimplementedArchiveSpanWriterPluginServer) WriteArchiveSpan(context.Context, *WriteSpanRequest) (*WriteSpanResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method WriteArchiveSpan not implemented") +} +func (UnimplementedArchiveSpanWriterPluginServer) mustEmbedUnimplementedArchiveSpanWriterPluginServer() { +} + +// UnsafeArchiveSpanWriterPluginServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to ArchiveSpanWriterPluginServer will +// result in compilation errors. +type UnsafeArchiveSpanWriterPluginServer interface { + mustEmbedUnimplementedArchiveSpanWriterPluginServer() +} + +func RegisterArchiveSpanWriterPluginServer(s grpc.ServiceRegistrar, srv ArchiveSpanWriterPluginServer) { + s.RegisterService(&ArchiveSpanWriterPlugin_ServiceDesc, srv) +} + +func _ArchiveSpanWriterPlugin_WriteArchiveSpan_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(WriteSpanRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ArchiveSpanWriterPluginServer).WriteArchiveSpan(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/jaeger.storage.v1.ArchiveSpanWriterPlugin/WriteArchiveSpan", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ArchiveSpanWriterPluginServer).WriteArchiveSpan(ctx, req.(*WriteSpanRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// ArchiveSpanWriterPlugin_ServiceDesc is the grpc.ServiceDesc for ArchiveSpanWriterPlugin service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var ArchiveSpanWriterPlugin_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "jaeger.storage.v1.ArchiveSpanWriterPlugin", + HandlerType: (*ArchiveSpanWriterPluginServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "WriteArchiveSpan", + Handler: _ArchiveSpanWriterPlugin_WriteArchiveSpan_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "jaeger/storage/v1/storage.proto", +} + +// ArchiveSpanReaderPluginClient is the client API for ArchiveSpanReaderPlugin service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type ArchiveSpanReaderPluginClient interface { + // spanstore/Reader + GetArchiveTrace(ctx context.Context, in *GetTraceRequest, opts ...grpc.CallOption) (ArchiveSpanReaderPlugin_GetArchiveTraceClient, error) +} + +type archiveSpanReaderPluginClient struct { + cc grpc.ClientConnInterface +} + +func NewArchiveSpanReaderPluginClient(cc grpc.ClientConnInterface) ArchiveSpanReaderPluginClient { + return &archiveSpanReaderPluginClient{cc} +} + +func (c *archiveSpanReaderPluginClient) GetArchiveTrace(ctx context.Context, in *GetTraceRequest, opts ...grpc.CallOption) (ArchiveSpanReaderPlugin_GetArchiveTraceClient, error) { + stream, err := c.cc.NewStream(ctx, &ArchiveSpanReaderPlugin_ServiceDesc.Streams[0], "/jaeger.storage.v1.ArchiveSpanReaderPlugin/GetArchiveTrace", opts...) + if err != nil { + return nil, err + } + x := &archiveSpanReaderPluginGetArchiveTraceClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type ArchiveSpanReaderPlugin_GetArchiveTraceClient interface { + Recv() (*SpansResponseChunk, error) + grpc.ClientStream +} + +type archiveSpanReaderPluginGetArchiveTraceClient struct { + grpc.ClientStream +} + +func (x *archiveSpanReaderPluginGetArchiveTraceClient) Recv() (*SpansResponseChunk, error) { + m := new(SpansResponseChunk) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// ArchiveSpanReaderPluginServer is the server API for ArchiveSpanReaderPlugin service. +// All implementations must embed UnimplementedArchiveSpanReaderPluginServer +// for forward compatibility +type ArchiveSpanReaderPluginServer interface { + // spanstore/Reader + GetArchiveTrace(*GetTraceRequest, ArchiveSpanReaderPlugin_GetArchiveTraceServer) error + mustEmbedUnimplementedArchiveSpanReaderPluginServer() +} + +// UnimplementedArchiveSpanReaderPluginServer must be embedded to have forward compatible implementations. +type UnimplementedArchiveSpanReaderPluginServer struct { +} + +func (UnimplementedArchiveSpanReaderPluginServer) GetArchiveTrace(*GetTraceRequest, ArchiveSpanReaderPlugin_GetArchiveTraceServer) error { + return status.Errorf(codes.Unimplemented, "method GetArchiveTrace not implemented") +} +func (UnimplementedArchiveSpanReaderPluginServer) mustEmbedUnimplementedArchiveSpanReaderPluginServer() { +} + +// UnsafeArchiveSpanReaderPluginServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to ArchiveSpanReaderPluginServer will +// result in compilation errors. +type UnsafeArchiveSpanReaderPluginServer interface { + mustEmbedUnimplementedArchiveSpanReaderPluginServer() +} + +func RegisterArchiveSpanReaderPluginServer(s grpc.ServiceRegistrar, srv ArchiveSpanReaderPluginServer) { + s.RegisterService(&ArchiveSpanReaderPlugin_ServiceDesc, srv) +} + +func _ArchiveSpanReaderPlugin_GetArchiveTrace_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(GetTraceRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(ArchiveSpanReaderPluginServer).GetArchiveTrace(m, &archiveSpanReaderPluginGetArchiveTraceServer{stream}) +} + +type ArchiveSpanReaderPlugin_GetArchiveTraceServer interface { + Send(*SpansResponseChunk) error + grpc.ServerStream +} + +type archiveSpanReaderPluginGetArchiveTraceServer struct { + grpc.ServerStream +} + +func (x *archiveSpanReaderPluginGetArchiveTraceServer) Send(m *SpansResponseChunk) error { + return x.ServerStream.SendMsg(m) +} + +// ArchiveSpanReaderPlugin_ServiceDesc is the grpc.ServiceDesc for ArchiveSpanReaderPlugin service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var ArchiveSpanReaderPlugin_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "jaeger.storage.v1.ArchiveSpanReaderPlugin", + HandlerType: (*ArchiveSpanReaderPluginServer)(nil), + Methods: []grpc.MethodDesc{}, + Streams: []grpc.StreamDesc{ + { + StreamName: "GetArchiveTrace", + Handler: _ArchiveSpanReaderPlugin_GetArchiveTrace_Handler, + ServerStreams: true, + }, + }, + Metadata: "jaeger/storage/v1/storage.proto", +} + +// DependenciesReaderPluginClient is the client API for DependenciesReaderPlugin service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type DependenciesReaderPluginClient interface { + // dependencystore/Reader + GetDependencies(ctx context.Context, in *GetDependenciesRequest, opts ...grpc.CallOption) (*GetDependenciesResponse, error) +} + +type dependenciesReaderPluginClient struct { + cc grpc.ClientConnInterface +} + +func NewDependenciesReaderPluginClient(cc grpc.ClientConnInterface) 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. +// All implementations must embed UnimplementedDependenciesReaderPluginServer +// for forward compatibility +type DependenciesReaderPluginServer interface { + // dependencystore/Reader + GetDependencies(context.Context, *GetDependenciesRequest) (*GetDependenciesResponse, error) + mustEmbedUnimplementedDependenciesReaderPluginServer() +} + +// UnimplementedDependenciesReaderPluginServer must be embedded to have forward compatible implementations. +type UnimplementedDependenciesReaderPluginServer struct { +} + +func (UnimplementedDependenciesReaderPluginServer) GetDependencies(context.Context, *GetDependenciesRequest) (*GetDependenciesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetDependencies not implemented") +} +func (UnimplementedDependenciesReaderPluginServer) mustEmbedUnimplementedDependenciesReaderPluginServer() { +} + +// UnsafeDependenciesReaderPluginServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to DependenciesReaderPluginServer will +// result in compilation errors. +type UnsafeDependenciesReaderPluginServer interface { + mustEmbedUnimplementedDependenciesReaderPluginServer() +} + +func RegisterDependenciesReaderPluginServer(s grpc.ServiceRegistrar, 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) +} + +// DependenciesReaderPlugin_ServiceDesc is the grpc.ServiceDesc for DependenciesReaderPlugin service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +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: "jaeger/storage/v1/storage.proto", +} + +// PluginCapabilitiesClient is the client API for PluginCapabilities service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type PluginCapabilitiesClient interface { + Capabilities(ctx context.Context, in *CapabilitiesRequest, opts ...grpc.CallOption) (*CapabilitiesResponse, error) +} + +type pluginCapabilitiesClient struct { + cc grpc.ClientConnInterface +} + +func NewPluginCapabilitiesClient(cc grpc.ClientConnInterface) PluginCapabilitiesClient { + return &pluginCapabilitiesClient{cc} +} + +func (c *pluginCapabilitiesClient) Capabilities(ctx context.Context, in *CapabilitiesRequest, opts ...grpc.CallOption) (*CapabilitiesResponse, error) { + out := new(CapabilitiesResponse) + err := c.cc.Invoke(ctx, "/jaeger.storage.v1.PluginCapabilities/Capabilities", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// PluginCapabilitiesServer is the server API for PluginCapabilities service. +// All implementations must embed UnimplementedPluginCapabilitiesServer +// for forward compatibility +type PluginCapabilitiesServer interface { + Capabilities(context.Context, *CapabilitiesRequest) (*CapabilitiesResponse, error) + mustEmbedUnimplementedPluginCapabilitiesServer() +} + +// UnimplementedPluginCapabilitiesServer must be embedded to have forward compatible implementations. +type UnimplementedPluginCapabilitiesServer struct { +} + +func (UnimplementedPluginCapabilitiesServer) Capabilities(context.Context, *CapabilitiesRequest) (*CapabilitiesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Capabilities not implemented") +} +func (UnimplementedPluginCapabilitiesServer) mustEmbedUnimplementedPluginCapabilitiesServer() {} + +// UnsafePluginCapabilitiesServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to PluginCapabilitiesServer will +// result in compilation errors. +type UnsafePluginCapabilitiesServer interface { + mustEmbedUnimplementedPluginCapabilitiesServer() +} + +func RegisterPluginCapabilitiesServer(s grpc.ServiceRegistrar, srv PluginCapabilitiesServer) { + s.RegisterService(&PluginCapabilities_ServiceDesc, srv) +} + +func _PluginCapabilities_Capabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CapabilitiesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(PluginCapabilitiesServer).Capabilities(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/jaeger.storage.v1.PluginCapabilities/Capabilities", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PluginCapabilitiesServer).Capabilities(ctx, req.(*CapabilitiesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// PluginCapabilities_ServiceDesc is the grpc.ServiceDesc for PluginCapabilities service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var PluginCapabilities_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "jaeger.storage.v1.PluginCapabilities", + HandlerType: (*PluginCapabilitiesServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Capabilities", + Handler: _PluginCapabilities_Capabilities_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "jaeger/storage/v1/storage.proto", +}