diff --git a/.github/workflows/ci-protogen-tests.yml b/.github/workflows/ci-protogen-tests.yml index 5baf1767ee5..5385a0339cd 100644 --- a/.github/workflows/ci-protogen-tests.yml +++ b/.github/workflows/ci-protogen-tests.yml @@ -33,4 +33,4 @@ jobs: go-version: 1.21.x - name: Run protogen validation - run: make proto && git diff --name-status --exit-code + run: make init-submodules && make proto && git diff --name-status --exit-code diff --git a/Makefile b/Makefile index c6d38b241b9..b6191a027da 100644 --- a/Makefile +++ b/Makefile @@ -464,7 +464,7 @@ PROTO_GOGO_MAPPINGS := $(shell echo \ | sed 's/ //g') .PHONY: proto -proto: init-submodules proto-prepare-otel +proto: proto-prepare-otel # Generate gogo, swagger, go-validators, gRPC-storage-plugin output. # # -I declares import folders, in order of importance diff --git a/cmd/query/app/apiv3/grpc_gateway_test.go b/cmd/query/app/apiv3/grpc_gateway_test.go index eb11a885ca9..d1d5a39ff8a 100644 --- a/cmd/query/app/apiv3/grpc_gateway_test.go +++ b/cmd/query/app/apiv3/grpc_gateway_test.go @@ -143,7 +143,15 @@ func testGRPCGatewayWithTenancy(t *testing.T, basePath string, serverTLS tlscfg. err = jsonpb.Unmarshal(envelope.Result, &spansResponse) require.NoError(t, err) assert.Equal(t, 1, len(spansResponse.GetResourceSpans())) - assert.Equal(t, uint64ToTraceID(traceID.High, traceID.Low), spansResponse.GetResourceSpans()[0].GetInstrumentationLibrarySpans()[0].GetSpans()[0].GetTraceId()) + assert.Equal(t, uint64ToTraceID(t, traceID.High, traceID.Low), spansResponse.GetResourceSpans()[0].GetScopeSpans()[0].GetSpans()[0].GetTraceId()) +} + +func uint64ToTraceID(t *testing.T, high, low uint64) []byte { + traceID := model.NewTraceID(high, low) + buf := make([]byte, 16) + _, err := traceID.MarshalTo(buf) + require.NoError(t, err) + return buf } func TestGRPCGateway(t *testing.T) { diff --git a/cmd/query/app/apiv3/grpc_handler.go b/cmd/query/app/apiv3/grpc_handler.go index a9659f1e84d..12136b0a308 100644 --- a/cmd/query/app/apiv3/grpc_handler.go +++ b/cmd/query/app/apiv3/grpc_handler.go @@ -39,14 +39,17 @@ var _ api_v3.QueryServiceServer = (*Handler)(nil) func (h *Handler) GetTrace(request *api_v3.GetTraceRequest, stream api_v3.QueryService_GetTraceServer) error { traceID, err := model.TraceIDFromString(request.GetTraceId()) if err != nil { - return err + return fmt.Errorf("malform trace ID: %w", err) } trace, err := h.QueryService.GetTrace(stream.Context(), traceID) + if err != nil { + return fmt.Errorf("cannot retrieve trace: %w", err) + } + resourceSpans, err := modelToOTLP(trace.GetSpans()) if err != nil { return err } - resourceSpans := jaegerSpansToOTLP(trace.GetSpans()) return stream.Send(&api_v3.SpansResponseChunk{ ResourceSpans: resourceSpans, }) @@ -103,7 +106,10 @@ func (h *Handler) FindTraces(request *api_v3.FindTracesRequest, stream api_v3.Qu return err } for _, t := range traces { - resourceSpans := jaegerSpansToOTLP(t.GetSpans()) + resourceSpans, err := modelToOTLP(t.GetSpans()) + if err != nil { + return err + } stream.Send(&api_v3.SpansResponseChunk{ ResourceSpans: resourceSpans, }) diff --git a/cmd/query/app/apiv3/grpc_handler_test.go b/cmd/query/app/apiv3/grpc_handler_test.go index d22f3f89c18..b2a0ad2ff55 100644 --- a/cmd/query/app/apiv3/grpc_handler_test.go +++ b/cmd/query/app/apiv3/grpc_handler_test.go @@ -78,7 +78,7 @@ func TestGetTrace(t *testing.T) { spansChunk, err := getTraceStream.Recv() require.NoError(t, err) require.Equal(t, 1, len(spansChunk.GetResourceSpans())) - assert.Equal(t, "foobar", spansChunk.GetResourceSpans()[0].GetInstrumentationLibrarySpans()[0].GetSpans()[0].GetName()) + assert.Equal(t, "foobar", spansChunk.GetResourceSpans()[0].GetScopeSpans()[0].GetSpans()[0].GetName()) } func TestGetTrace_storage_error(t *testing.T) { diff --git a/cmd/query/app/apiv3/otlp_translator.go b/cmd/query/app/apiv3/otlp_translator.go index 66524717c72..b7daf1b5567 100644 --- a/cmd/query/app/apiv3/otlp_translator.go +++ b/cmd/query/app/apiv3/otlp_translator.go @@ -15,369 +15,33 @@ package apiv3 import ( - "encoding/binary" "fmt" - "hash/fnv" - "math" - "sort" - "strconv" - "strings" - "go.opentelemetry.io/collector/pdata/ptrace" - semconv "go.opentelemetry.io/collector/semconv/v1.5.0" - "go.opentelemetry.io/otel/trace" + "github.com/gogo/protobuf/proto" + model2otel "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/translator/jaeger" + "go.opentelemetry.io/collector/pdata/ptrace/ptraceotlp" "github.com/jaegertracing/jaeger/model" - commonv1 "github.com/jaegertracing/jaeger/proto-gen/otel/common/v1" - resourcev1 "github.com/jaegertracing/jaeger/proto-gen/otel/resource/v1" + "github.com/jaegertracing/jaeger/proto-gen/api_v3" tracev1 "github.com/jaegertracing/jaeger/proto-gen/otel/trace/v1" ) -const ( - tagStatusCode = "status.code" - tagStatusMsg = "status.message" - - tagSpanKind = "span.kind" - tagError = "error" - tagMessage = "message" - tagHTTPStatusMsg = "http.status_message" - tagW3CTraceState = "w3c.tracestate" -) - -// OpenTelemetry collector implements translator from Jaeger model to pdata (wrapper around OTLP). -// However, it cannot be used because the imported OTLP in the translator is in the collector's private package. -func jaegerSpansToOTLP(spans []*model.Span) []*tracev1.ResourceSpans { - spansByLibrary := make(map[resource]map[instrumentationLibrary]*tracev1.InstrumentationLibrarySpans) - for _, s := range spans { - otlpSpan, res, library := jSpanToOTLP(s) - resourceSpans, ok := spansByLibrary[res] - if !ok { - resourceSpans = map[instrumentationLibrary]*tracev1.InstrumentationLibrarySpans{} - resourceSpans[library] = &tracev1.InstrumentationLibrarySpans{ - InstrumentationLibrary: &commonv1.InstrumentationLibrary{ - Name: library.name, - Version: library.version, - }, - } - spansByLibrary[res] = resourceSpans - } - resourceSpans[library].Spans = append(resourceSpans[library].GetSpans(), otlpSpan) - } - - var rss []*tracev1.ResourceSpans - for res, libMap := range spansByLibrary { - rs := &tracev1.ResourceSpans{ - Resource: res.resource, - } - for _, v := range libMap { - rs.InstrumentationLibrarySpans = append(rs.InstrumentationLibrarySpans, v) - } - rss = append(rss, rs) - } - return rss -} - -type instrumentationLibrary struct { - name, version string -} - -// helper type used as a map key -type resource struct { - serviceName string - // concatenated and hashed string tags - // to make sure services are uniquely grouped - tagsHash uint32 - resource *resourcev1.Resource -} - -func jSpanToOTLP(jSpan *model.Span) (*tracev1.Span, resource, instrumentationLibrary) { - tags := model.KeyValues(jSpan.GetTags()) - status, ignoreKeys := getSpanStatus(tags) - - traceState := getTraceStateFromAttrs(tags) - if traceState != "" { - ignoreKeys[tagW3CTraceState] = true - } - - s := &tracev1.Span{ - TraceId: uint64ToTraceID(jSpan.TraceID.High, jSpan.TraceID.Low), - SpanId: uint64ToSpanID(uint64(jSpan.SpanID)), - ParentSpanId: uint64ToSpanID(uint64(jSpan.ParentSpanID())), - TraceState: traceState, - Name: jSpan.GetOperationName(), - StartTimeUnixNano: uint64(jSpan.GetStartTime().UnixNano()), - EndTimeUnixNano: uint64(jSpan.GetStartTime().Add(jSpan.GetDuration()).UnixNano()), - Events: jLogsToOTLP(jSpan.GetLogs()), - Links: jReferencesToOTLP(jSpan.GetReferences(), jSpan.ParentSpanID()), - Status: status, - Kind: tracev1.Span_SPAN_KIND_UNSPECIFIED, - } - if kind, found := jSpan.GetSpanKind(); found { - s.Kind = jSpanKindToInternal(kind) - ignoreKeys[tagSpanKind] = true - } - - il := instrumentationLibrary{} - if libraryName, ok := tags.FindByKey(semconv.InstrumentationLibraryName); ok { - il.name = libraryName.GetVStr() - ignoreKeys[semconv.InstrumentationLibraryName] = true - if libraryVersion, ok := tags.FindByKey(semconv.InstrumentationLibraryVersion); ok { - il.version = libraryVersion.GetVStr() - ignoreKeys[semconv.InstrumentationLibraryVersion] = true - } - } - // convert to attributes at the end once not needed attrs are removed - attrs := jTagsToOTLP(tags, ignoreKeys) - s.Attributes = attrs - - res := resource{} - if jSpan.GetProcess() != nil { - tags := concatStringTags(jSpan.GetProcess().GetTags()) - fnva := fnv.New32a() - fnva.Write([]byte(tags)) - - res.serviceName = jSpan.GetProcess().GetServiceName() - res.tagsHash = fnva.Sum32() - res.resource = jProcessToInternalResource(jSpan.GetProcess()) - } - return s, res, il -} - -// concatStringTags returns key sorted concatenated string tags -// e.g. keyB=val1,keyA=val2 becomes keyAval2KeyBval1 -func concatStringTags(tags []model.KeyValue) string { - keys := make([]string, len(tags)) - tagMap := make(map[string]string, len(tags)) - stringTagsLen := 0 - for i, t := range tags { - if t.GetVType() == model.ValueType_STRING { - keys[i] = t.GetKey() - tagMap[t.GetKey()] = t.GetVStr() - stringTagsLen += len(t.GetKey()) + len(t.GetVStr()) - } - } - sort.Strings(keys) - sBuilder := strings.Builder{} - sBuilder.Grow(stringTagsLen) - for k, v := range tagMap { - sBuilder.WriteString(k) - sBuilder.WriteString(v) - } - return sBuilder.String() -} - -func jProcessToInternalResource(process *model.Process) *resourcev1.Resource { - if process == nil { - return nil - } - tags := process.GetTags() - if process.GetServiceName() != "" { - tags = append(tags, model.String(semconv.AttributeServiceName, process.GetServiceName())) - } - return &resourcev1.Resource{ - Attributes: jTagsToOTLP(tags, nil), - } -} - -func jTagsToOTLP(tags []model.KeyValue, ignoreKeys map[string]bool) []*commonv1.KeyValue { - var kvs []*commonv1.KeyValue - for _, tag := range tags { - if ignoreKeys[tag.GetKey()] { - continue - } - - kv := &commonv1.KeyValue{ - Key: tag.GetKey(), - Value: &commonv1.AnyValue{}, - } - switch tag.GetVType() { - case model.ValueType_STRING: - kv.Value.Value = &commonv1.AnyValue_StringValue{ - StringValue: tag.GetVStr(), - } - case model.ValueType_BOOL: - kv.Value.Value = &commonv1.AnyValue_BoolValue{ - BoolValue: tag.GetVBool(), - } - case model.ValueType_INT64: - kv.Value.Value = &commonv1.AnyValue_IntValue{ - IntValue: tag.GetVInt64(), - } - case model.ValueType_FLOAT64: - kv.Value.Value = &commonv1.AnyValue_DoubleValue{ - DoubleValue: tag.GetVFloat64(), - } - case model.ValueType_BINARY: - kv.Value.Value = &commonv1.AnyValue_BytesValue{ - BytesValue: tag.GetVBinary(), - } - default: - kv.Value.Value = &commonv1.AnyValue_StringValue{ - StringValue: tag.String(), - } - } - kvs = append(kvs, kv) - } - return kvs -} - -func jLogsToOTLP(logs []model.Log) []*tracev1.Span_Event { - events := make([]*tracev1.Span_Event, len(logs)) - for i, l := range logs { - - var name string - var ignoreKeys map[string]bool - if messageTag, ok := model.KeyValues(l.GetFields()).FindByKey(tagMessage); ok { - name = messageTag.GetVStr() - ignoreKeys = map[string]bool{} - ignoreKeys[tagMessage] = true - } - - events[i] = &tracev1.Span_Event{ - TimeUnixNano: uint64(l.GetTimestamp().UnixNano()), - Name: name, - Attributes: jTagsToOTLP(l.GetFields(), ignoreKeys), - } - } - return events -} - -func jReferencesToOTLP(refs []model.SpanRef, excludeParentID model.SpanID) []*tracev1.Span_Link { - if len(refs) == 0 || len(refs) == 1 && refs[0].SpanID == excludeParentID && refs[0].RefType == model.ChildOf { - return nil - } - var links []*tracev1.Span_Link - for _, r := range refs { - if r.SpanID == excludeParentID && r.GetRefType() == model.ChildOf { - continue - } - links = append(links, &tracev1.Span_Link{ - TraceId: uint64ToTraceID(r.TraceID.High, r.TraceID.Low), - SpanId: uint64ToSpanID(uint64(r.SpanID)), - }) - } - - return links -} - -func getSpanStatus(tags []model.KeyValue) (*tracev1.Status, map[string]bool) { - statusCode := tracev1.Status_STATUS_CODE_UNSET - statusMessage := "" - statusExists := false - - ignoreKeys := map[string]bool{} - kvs := model.KeyValues(tags) - if _, ok := kvs.FindByKey(tagError); ok { - statusCode = tracev1.Status_STATUS_CODE_ERROR - statusExists = true - ignoreKeys[tagError] = true - } - if tag, ok := kvs.FindByKey(tagStatusCode); ok { - statusExists = true - if code, err := getStatusCodeValFromTag(tag); err == nil { - statusCode = tracev1.Status_StatusCode(code) - ignoreKeys[tagStatusCode] = true - } - if tag, ok := kvs.FindByKey(tagStatusMsg); ok { - statusMessage = tag.GetVStr() - ignoreKeys[tagStatusMsg] = true - } - } else if tag, ok := kvs.FindByKey(semconv.AttributeHTTPStatusCode); ok { - statusExists = true - if code, err := getStatusCodeFromHTTPStatusTag(tag); err == nil { - // Do not set status code in case it was set to Unset. - if tracev1.Status_StatusCode(code) != tracev1.Status_STATUS_CODE_UNSET { - statusCode = tracev1.Status_StatusCode(code) - } - - if tag, ok := kvs.FindByKey(tagHTTPStatusMsg); ok { - statusMessage = tag.GetVStr() - } - } - } - - if statusExists { - return &tracev1.Status{ - Code: statusCode, - Message: statusMessage, - }, ignoreKeys - } - return nil, ignoreKeys -} - -func getStatusCodeValFromTag(tag model.KeyValue) (int, error) { - var codeVal int64 - switch tag.GetVType() { - case model.ValueType_INT64: - codeVal = tag.GetVInt64() - case model.ValueType_STRING: - i, err := strconv.Atoi(tag.GetVStr()) - if err != nil { - return 0, err - } - codeVal = int64(i) - default: - return 0, fmt.Errorf("invalid status code attribute type: %q, key: %q", tag.GetKey(), tag.GetKey()) - } - if codeVal > math.MaxInt32 || codeVal < math.MinInt32 { - return 0, fmt.Errorf("invalid status code value: %d", codeVal) - } - return int(codeVal), nil -} - -func getStatusCodeFromHTTPStatusTag(tag model.KeyValue) (int, error) { - statusCode, err := getStatusCodeValFromTag(tag) +func modelToOTLP(spans []*model.Span) ([]*tracev1.ResourceSpans, error) { + batch := &model.Batch{Spans: spans} + td, err := model2otel.ProtoToTraces([]*model.Batch{batch}) if err != nil { - return int(tracev1.Status_STATUS_CODE_OK), err - } - - return int(statusCodeFromHTTP(statusCode)), nil -} - -func jSpanKindToInternal(spanKind trace.SpanKind) tracev1.Span_SpanKind { - switch spanKind { - case trace.SpanKindClient: - return tracev1.Span_SPAN_KIND_CLIENT - case trace.SpanKindServer: - return tracev1.Span_SPAN_KIND_SERVER - case trace.SpanKindProducer: - return tracev1.Span_SPAN_KIND_PRODUCER - case trace.SpanKindConsumer: - return tracev1.Span_SPAN_KIND_CONSUMER - case trace.SpanKindInternal: - return tracev1.Span_SPAN_KIND_INTERNAL + return nil, fmt.Errorf("cannot convert trace to OpenTelemetry: %w", err) } - return tracev1.Span_SPAN_KIND_UNSPECIFIED -} - -func getTraceStateFromAttrs(attrs []model.KeyValue) string { - traceState := "" - for _, attr := range attrs { - if attr.GetKey() == tagW3CTraceState { - return attr.GetVStr() - } + req := ptraceotlp.NewExportRequestFromTraces(td) + // OTEL Collector hides the internal proto implementation, so do a roundtrip conversion (inefficient) + b, err := req.MarshalProto() + if err != nil { + return nil, fmt.Errorf("cannot marshal OTLP: %w", err) } - return traceState -} - -func uint64ToSpanID(id uint64) []byte { - spanID := [8]byte{} - binary.BigEndian.PutUint64(spanID[:], id) - return spanID[:] -} - -func uint64ToTraceID(high, low uint64) []byte { - traceID := [16]byte{} - binary.BigEndian.PutUint64(traceID[:8], high) - binary.BigEndian.PutUint64(traceID[8:], low) - return traceID[:] -} - -// statusCodeFromHTTP takes an HTTP status code and return the appropriate OpenTelemetry status code -// See: https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/semantic_conventions/http.md#status -func statusCodeFromHTTP(httpStatusCode int) ptrace.StatusCode { - if httpStatusCode >= 100 && httpStatusCode < 399 { - return ptrace.StatusCodeUnset + // use api_v3.SpansResponseChunk which has the same shape as otlp.ExportTraceServiceRequest + var chunk api_v3.SpansResponseChunk + if err := proto.Unmarshal(b, &chunk); err != nil { + return nil, fmt.Errorf("cannot marshal OTLP: %w", err) } - return ptrace.StatusCodeError + return chunk.ResourceSpans, nil } diff --git a/cmd/query/app/apiv3/otlp_translator_test.go b/cmd/query/app/apiv3/otlp_translator_test.go deleted file mode 100644 index 08f3b9f23e0..00000000000 --- a/cmd/query/app/apiv3/otlp_translator_test.go +++ /dev/null @@ -1,308 +0,0 @@ -// Copyright (c) 2021 The Jaeger Authors. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package apiv3 - -import ( - "math" - "testing" - "time" - - "github.com/stretchr/testify/assert" - semconv "go.opentelemetry.io/collector/semconv/v1.5.0" - "go.opentelemetry.io/otel/trace" - - "github.com/jaegertracing/jaeger/model" - commonv1 "github.com/jaegertracing/jaeger/proto-gen/otel/common/v1" - resourcev1 "github.com/jaegertracing/jaeger/proto-gen/otel/resource/v1" - v1 "github.com/jaegertracing/jaeger/proto-gen/otel/trace/v1" -) - -var ts = time.Date(2021, 6, 14, 6, 0, 0, 0, time.UTC) - -func TestTranslateSpan(t *testing.T) { - traceID := model.NewTraceID(10, 20) - traceID2 := model.NewTraceID(10, 21) - spanID := model.NewSpanID(30) - spanID2 := model.NewSpanID(999) - spanID3 := model.NewSpanID(888) - spanID4 := model.NewSpanID(8899) - s := &model.Span{ - TraceID: traceID, - SpanID: spanID, - OperationName: "op_name", - References: []model.SpanRef{ - // parent span - { - TraceID: traceID, - SpanID: spanID2, - RefType: model.SpanRefType_CHILD_OF, - }, - { - TraceID: traceID2, - SpanID: spanID3, - RefType: model.SpanRefType_CHILD_OF, - }, - { - TraceID: traceID2, - SpanID: spanID4, - RefType: model.SpanRefType_FOLLOWS_FROM, - }, - }, - Flags: 0, - StartTime: ts, - Duration: 15, - Tags: []model.KeyValue{ - model.String("k1", "v1"), - model.Bool("k2", true), - model.String(semconv.InstrumentationLibraryName, "servlet"), - model.String(semconv.InstrumentationLibraryVersion, "3.0"), - model.String(tagSpanKind, "client"), - model.Int64(tagStatusCode, 1), - model.String(tagStatusMsg, "msg"), - model.String(tagW3CTraceState, "invalid"), - }, - Logs: []model.Log{ - { - Timestamp: ts, - Fields: []model.KeyValue{ - model.String("k11", "v11"), - model.String("message", "example-event-name"), - }, - }, - }, - Process: &model.Process{ - ServiceName: "p1", - Tags: []model.KeyValue{ - model.Int64("pv1", 150), - model.String("version", "1.3.4"), - }, - }, - } - - resourceSpans := jaegerSpansToOTLP([]*model.Span{s}) - assert.Equal(t, []*v1.ResourceSpans{{ - Resource: &resourcev1.Resource{ - Attributes: []*commonv1.KeyValue{ - {Key: "pv1", Value: &commonv1.AnyValue{Value: &commonv1.AnyValue_IntValue{IntValue: 150}}}, - {Key: "version", Value: &commonv1.AnyValue{Value: &commonv1.AnyValue_StringValue{StringValue: "1.3.4"}}}, - {Key: semconv.AttributeServiceName, Value: &commonv1.AnyValue{Value: &commonv1.AnyValue_StringValue{StringValue: "p1"}}}, - }, - }, - InstrumentationLibrarySpans: []*v1.InstrumentationLibrarySpans{ - { - InstrumentationLibrary: &commonv1.InstrumentationLibrary{ - Name: "servlet", - Version: "3.0", - }, - Spans: []*v1.Span{ - { - TraceId: uint64ToTraceID(traceID.High, traceID.Low), - SpanId: uint64ToSpanID(uint64(spanID)), - ParentSpanId: uint64ToSpanID(uint64(spanID2)), - TraceState: "invalid", - Name: "op_name", - Kind: v1.Span_SPAN_KIND_CLIENT, - Status: &v1.Status{ - Code: v1.Status_STATUS_CODE_OK, - Message: "msg", - }, - StartTimeUnixNano: uint64(ts.UnixNano()), - EndTimeUnixNano: uint64(ts.UnixNano() + 15), - Attributes: []*commonv1.KeyValue{ - {Key: "k1", Value: &commonv1.AnyValue{Value: &commonv1.AnyValue_StringValue{StringValue: "v1"}}}, - {Key: "k2", Value: &commonv1.AnyValue{Value: &commonv1.AnyValue_BoolValue{BoolValue: true}}}, - }, - Events: []*v1.Span_Event{ - { - TimeUnixNano: uint64(ts.UnixNano()), - Name: "example-event-name", - Attributes: []*commonv1.KeyValue{ - {Key: "k11", Value: &commonv1.AnyValue{Value: &commonv1.AnyValue_StringValue{StringValue: "v11"}}}, - }, - }, - }, - Links: []*v1.Span_Link{ - { - TraceId: uint64ToTraceID(traceID2.High, traceID2.Low), - SpanId: uint64ToSpanID(uint64(spanID3)), - }, - { - TraceId: uint64ToTraceID(traceID2.High, traceID2.Low), - SpanId: uint64ToSpanID(uint64(spanID4)), - }, - }, - }, - }, - }, - }, - }}, resourceSpans) -} - -func TestTranslateSpanKind(t *testing.T) { - tests := []struct { - kind trace.SpanKind - otelSpanKind v1.Span_SpanKind - }{ - { - kind: trace.SpanKindClient, - otelSpanKind: v1.Span_SPAN_KIND_CLIENT, - }, - { - kind: trace.SpanKindServer, - otelSpanKind: v1.Span_SPAN_KIND_SERVER, - }, - { - kind: trace.SpanKindProducer, - otelSpanKind: v1.Span_SPAN_KIND_PRODUCER, - }, - { - kind: trace.SpanKindConsumer, - otelSpanKind: v1.Span_SPAN_KIND_CONSUMER, - }, - { - kind: trace.SpanKindInternal, - otelSpanKind: v1.Span_SPAN_KIND_INTERNAL, - }, - { - otelSpanKind: v1.Span_SPAN_KIND_UNSPECIFIED, - }, - } - for _, test := range tests { - t.Run(test.kind.String(), func(t *testing.T) { - otelSpanKind := jSpanKindToInternal(test.kind) - assert.Equal(t, test.otelSpanKind, otelSpanKind) - }) - } -} - -func TestTranslateTProcess_nil(t *testing.T) { - assert.Nil(t, jProcessToInternalResource(nil)) -} - -func TestTranslateTags(t *testing.T) { - tags := []model.KeyValue{ - model.String("str", "str"), - model.Bool("bool", true), - model.Int64("int", 150), - model.Float64("float", 15.6), - model.Binary("binary", []byte("bytes")), - model.String("ignore", "str"), - { - Key: "foo", - VType: 999, // unknown type - VStr: "val", - VInt64: 1, - }, - } - otlpKeyValues := jTagsToOTLP(tags, map[string]bool{"ignore": true}) - assert.Equal(t, []*commonv1.KeyValue{ - { - Key: "str", - Value: &commonv1.AnyValue{Value: &commonv1.AnyValue_StringValue{StringValue: "str"}}, - }, - { - Key: "bool", - Value: &commonv1.AnyValue{Value: &commonv1.AnyValue_BoolValue{BoolValue: true}}, - }, - { - Key: "int", - Value: &commonv1.AnyValue{Value: &commonv1.AnyValue_IntValue{IntValue: 150}}, - }, - { - Key: "float", - Value: &commonv1.AnyValue{Value: &commonv1.AnyValue_DoubleValue{DoubleValue: 15.6}}, - }, - { - Key: "binary", - Value: &commonv1.AnyValue{Value: &commonv1.AnyValue_BytesValue{BytesValue: []byte("bytes")}}, - }, - { - Key: "foo", - Value: &commonv1.AnyValue{Value: &commonv1.AnyValue_StringValue{StringValue: "key:\"foo\" v_type:999 v_str:\"val\" v_int64:1 "}}, - }, - }, otlpKeyValues) -} - -func TestTranslateSpanStatus(t *testing.T) { - tests := []struct { - name string - tags []model.KeyValue - status *v1.Status - ignoreKeys map[string]bool - }{ - { - name: "error tag", - tags: []model.KeyValue{model.String(tagError, "true")}, - status: &v1.Status{Code: v1.Status_STATUS_CODE_ERROR}, - ignoreKeys: map[string]bool{tagError: true}, - }, - { - name: "status tag int type", - tags: []model.KeyValue{model.Int64(tagStatusCode, 1), model.String(tagStatusMsg, "foobar")}, - status: &v1.Status{Message: "foobar", Code: v1.Status_STATUS_CODE_OK}, - ignoreKeys: map[string]bool{tagStatusCode: true, tagStatusMsg: true}, - }, - { - name: "status tag int type overflow", - tags: []model.KeyValue{model.Int64(tagStatusCode, math.MaxInt64), model.String(tagStatusMsg, "foobar")}, - status: &v1.Status{Message: "foobar", Code: v1.Status_STATUS_CODE_UNSET}, - ignoreKeys: map[string]bool{tagStatusMsg: true}, - }, - { - name: "status tag string type", - tags: []model.KeyValue{model.String(tagStatusCode, "1"), model.String(tagStatusMsg, "foobar")}, - status: &v1.Status{Message: "foobar", Code: v1.Status_STATUS_CODE_OK}, - ignoreKeys: map[string]bool{tagStatusCode: true, tagStatusMsg: true}, - }, - { - name: "status tag string type error", - tags: []model.KeyValue{model.String(tagStatusCode, "one"), model.String(tagStatusMsg, "foobar")}, - status: &v1.Status{Message: "foobar", Code: v1.Status_STATUS_CODE_UNSET}, - ignoreKeys: map[string]bool{tagStatusMsg: true}, - }, - { - name: "status tag bool type", - tags: []model.KeyValue{model.Bool(tagStatusCode, true), model.String(tagStatusMsg, "foobar")}, - status: &v1.Status{Message: "foobar", Code: v1.Status_STATUS_CODE_UNSET}, - ignoreKeys: map[string]bool{tagStatusMsg: true}, - }, - { - name: "HTTP status tag", - tags: []model.KeyValue{model.Int64(semconv.AttributeHTTPStatusCode, 200), model.String(tagHTTPStatusMsg, "all_fine")}, - status: &v1.Status{Message: "all_fine", Code: v1.Status_STATUS_CODE_UNSET}, - ignoreKeys: map[string]bool{}, - }, - { - name: "HTTP status tag error", - tags: []model.KeyValue{model.Int64(semconv.AttributeHTTPStatusCode, 500), model.String(tagHTTPStatusMsg, "some_err")}, - status: &v1.Status{Message: "some_err", Code: v1.Status_STATUS_CODE_ERROR}, - ignoreKeys: map[string]bool{}, - }, - { - name: "HTTP status tag error wrong tag type", - tags: []model.KeyValue{model.Bool(semconv.AttributeHTTPStatusCode, true), model.String(tagHTTPStatusMsg, "some_err")}, - status: &v1.Status{Code: v1.Status_STATUS_CODE_UNSET}, - ignoreKeys: map[string]bool{}, - }, - } - - for _, test := range tests { - t.Run(test.name, func(t *testing.T) { - status, ignoreKeys := getSpanStatus(test.tags) - assert.Equal(t, test.status, status) - assert.Equal(t, test.ignoreKeys, ignoreKeys) - }) - } -} diff --git a/idl b/idl index 05fe64e9c30..de44a4e9373 160000 --- a/idl +++ b/idl @@ -1 +1 @@ -Subproject commit 05fe64e9c305526901f70ff692030b388787e388 +Subproject commit de44a4e93731f57a6a926e16dffa1767de7a0f22 diff --git a/proto-gen/api_v2/query.pb.go b/proto-gen/api_v2/query.pb.go index 370512c9227..c4898c6c876 100644 --- a/proto-gen/api_v2/query.pb.go +++ b/proto-gen/api_v2/query.pb.go @@ -35,10 +35,14 @@ var _ = time.Kitchen const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type GetTraceRequest struct { - TraceID github_com_jaegertracing_jaeger_model.TraceID `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3,customtype=github.com/jaegertracing/jaeger/model.TraceID" json:"trace_id"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + TraceID github_com_jaegertracing_jaeger_model.TraceID `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3,customtype=github.com/jaegertracing/jaeger/model.TraceID" json:"trace_id"` + // Optional. The start time to search trace ID. + StartTime *time.Time `protobuf:"bytes,2,opt,name=start_time,json=startTime,proto3,stdtime" json:"start_time,omitempty"` + // Optional. The end time to search trace ID. + EndTime *time.Time `protobuf:"bytes,3,opt,name=end_time,json=endTime,proto3,stdtime" json:"end_time,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *GetTraceRequest) Reset() { *m = GetTraceRequest{} } @@ -74,6 +78,20 @@ func (m *GetTraceRequest) XXX_DiscardUnknown() { var xxx_messageInfo_GetTraceRequest proto.InternalMessageInfo +func (m *GetTraceRequest) GetStartTime() *time.Time { + if m != nil { + return m.StartTime + } + return nil +} + +func (m *GetTraceRequest) GetEndTime() *time.Time { + if m != nil { + return m.EndTime + } + return nil +} + type SpansResponseChunk struct { Spans []model.Span `protobuf:"bytes,1,rep,name=spans,proto3" json:"spans"` XXX_NoUnkeyedLiteral struct{} `json:"-"` @@ -122,10 +140,14 @@ func (m *SpansResponseChunk) GetSpans() []model.Span { } type ArchiveTraceRequest struct { - TraceID github_com_jaegertracing_jaeger_model.TraceID `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3,customtype=github.com/jaegertracing/jaeger/model.TraceID" json:"trace_id"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + TraceID github_com_jaegertracing_jaeger_model.TraceID `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3,customtype=github.com/jaegertracing/jaeger/model.TraceID" json:"trace_id"` + // Optional. The start time to search trace ID. + StartTime *time.Time `protobuf:"bytes,2,opt,name=start_time,json=startTime,proto3,stdtime" json:"start_time,omitempty"` + // Optional. The end time to search trace ID. + EndTime *time.Time `protobuf:"bytes,3,opt,name=end_time,json=endTime,proto3,stdtime" json:"end_time,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *ArchiveTraceRequest) Reset() { *m = ArchiveTraceRequest{} } @@ -161,6 +183,20 @@ func (m *ArchiveTraceRequest) XXX_DiscardUnknown() { var xxx_messageInfo_ArchiveTraceRequest proto.InternalMessageInfo +func (m *ArchiveTraceRequest) GetStartTime() *time.Time { + if m != nil { + return m.StartTime + } + return nil +} + +func (m *ArchiveTraceRequest) GetEndTime() *time.Time { + if m != nil { + return m.EndTime + } + return nil +} + type ArchiveTraceResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -200,6 +236,18 @@ func (m *ArchiveTraceResponse) XXX_DiscardUnknown() { var xxx_messageInfo_ArchiveTraceResponse proto.InternalMessageInfo +// Query parameters to find traces. Except for num_traces, all fields should be treated +// as forming a conjunction, e.g., "service_name='X' AND operation_name='Y' AND ...". +// All fields are matched against individual spans, not at the trace level. +// The returned results contain traces where at least one span matches the conditions. +// When num_traces results in fewer traces returned, there is no required ordering. +// +// Note: num_traces should restrict the number of traces returned, but not all backends +// interpret it this way. For instance, in Cassandra this limits the number of _spans_ +// that match the conditions, and the resulting number of traces can be less. +// +// Note: some storage implementations do not guarantee the correct implementation of all parameters. +// type TraceQueryParameters struct { ServiceName string `protobuf:"bytes,1,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"` OperationName string `protobuf:"bytes,2,opt,name=operation_name,json=operationName,proto3" json:"operation_name,omitempty"` @@ -723,67 +771,69 @@ func init() { func init() { proto.RegisterFile("query.proto", fileDescriptor_5c6ac9b241082464) } var fileDescriptor_5c6ac9b241082464 = []byte{ - // 956 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0x4f, 0x6f, 0x1b, 0x45, - 0x14, 0x67, 0x1d, 0x3b, 0xb6, 0xdf, 0xda, 0x2d, 0x7d, 0x76, 0xda, 0x65, 0x0b, 0xb6, 0xb3, 0xa1, - 0x55, 0x84, 0x94, 0xdd, 0x62, 0x0e, 0x94, 0x0a, 0x09, 0x9a, 0xa6, 0xb5, 0x0a, 0xb4, 0xc0, 0x36, - 0x27, 0x38, 0x58, 0x13, 0xef, 0xb0, 0x5e, 0x1c, 0xcf, 0xba, 0xbb, 0xe3, 0x10, 0x0b, 0x71, 0xe1, - 0x13, 0x20, 0x71, 0xe1, 0xc4, 0x95, 0x13, 0xdf, 0xa3, 0x47, 0x24, 0x6e, 0x1c, 0x02, 0x8a, 0xf8, - 0x20, 0x68, 0xfe, 0xac, 0x63, 0xaf, 0xa3, 0x10, 0x7a, 0xe0, 0xe4, 0x99, 0x37, 0xef, 0xfd, 0xde, - 0xbf, 0xdf, 0x7b, 0x6b, 0x30, 0x9f, 0x4f, 0x69, 0x32, 0x73, 0x27, 0x49, 0xcc, 0x63, 0xac, 0x7f, - 0x4d, 0x68, 0x48, 0x13, 0x97, 0x4c, 0xa2, 0xfe, 0x51, 0xd7, 0x36, 0xc7, 0x71, 0x40, 0x0f, 0xd5, - 0x9b, 0xdd, 0x0c, 0xe3, 0x30, 0x96, 0x47, 0x4f, 0x9c, 0xb4, 0xf4, 0xf5, 0x30, 0x8e, 0xc3, 0x43, - 0xea, 0x91, 0x49, 0xe4, 0x11, 0xc6, 0x62, 0x4e, 0x78, 0x14, 0xb3, 0x54, 0xbf, 0xb6, 0xf5, 0xab, - 0xbc, 0x1d, 0x4c, 0xbf, 0xf2, 0x78, 0x34, 0xa6, 0x29, 0x27, 0xe3, 0x89, 0x56, 0x68, 0xe5, 0x15, - 0x82, 0x69, 0x22, 0x11, 0xd4, 0xbb, 0xc3, 0xe0, 0x6a, 0x8f, 0xf2, 0xfd, 0x84, 0x0c, 0xa8, 0x4f, - 0x9f, 0x4f, 0x69, 0xca, 0xf1, 0x4b, 0xa8, 0x70, 0x71, 0xef, 0x47, 0x81, 0x65, 0x74, 0x8c, 0xed, - 0xda, 0xee, 0x87, 0x2f, 0x4e, 0xda, 0xaf, 0xfc, 0x71, 0xd2, 0xde, 0x09, 0x23, 0x3e, 0x9c, 0x1e, - 0xb8, 0x83, 0x78, 0xec, 0xa9, 0x44, 0x84, 0x62, 0xc4, 0x42, 0x7d, 0xf3, 0x54, 0x3a, 0x12, 0xed, - 0xf1, 0xde, 0xe9, 0x49, 0xbb, 0xac, 0x8f, 0x7e, 0x59, 0x22, 0x3e, 0x0e, 0x9c, 0x87, 0x80, 0xcf, - 0x26, 0x84, 0xa5, 0x3e, 0x4d, 0x27, 0x31, 0x4b, 0xe9, 0x83, 0xe1, 0x94, 0x8d, 0xd0, 0x83, 0x52, - 0x2a, 0xa4, 0x96, 0xd1, 0x59, 0xdb, 0x36, 0xbb, 0x0d, 0x77, 0xa9, 0x4c, 0xae, 0xb0, 0xd8, 0x2d, - 0x8a, 0x20, 0x7c, 0xa5, 0xe7, 0x24, 0xd0, 0xb8, 0x9f, 0x0c, 0x86, 0xd1, 0x11, 0xfd, 0xff, 0x42, - 0xbf, 0x0e, 0xcd, 0x65, 0x9f, 0x2a, 0x03, 0xe7, 0x97, 0x22, 0x34, 0xa5, 0xe4, 0x73, 0xd1, 0xe8, - 0xcf, 0x48, 0x42, 0xc6, 0x94, 0xd3, 0x24, 0xc5, 0x4d, 0xa8, 0xa5, 0x34, 0x39, 0x8a, 0x06, 0xb4, - 0xcf, 0xc8, 0x98, 0xca, 0x88, 0xaa, 0xbe, 0xa9, 0x65, 0x4f, 0xc9, 0x98, 0xe2, 0x2d, 0xb8, 0x12, - 0x4f, 0xa8, 0xea, 0x88, 0x52, 0x2a, 0x48, 0xa5, 0xfa, 0x5c, 0x2a, 0xd5, 0xee, 0x43, 0x91, 0x93, - 0x30, 0xb5, 0xd6, 0x64, 0x79, 0x76, 0x72, 0xe5, 0x39, 0xcf, 0xb9, 0xbb, 0x4f, 0xc2, 0xf4, 0x21, - 0xe3, 0xc9, 0xcc, 0x97, 0xa6, 0xf8, 0x11, 0x5c, 0x49, 0x39, 0x49, 0x78, 0x5f, 0x30, 0xa4, 0x3f, - 0x8e, 0x98, 0x55, 0xec, 0x18, 0xdb, 0x66, 0xd7, 0x76, 0x15, 0x43, 0xdc, 0x8c, 0x21, 0xee, 0x7e, - 0x46, 0xa1, 0xdd, 0x8a, 0x28, 0xde, 0x0f, 0x7f, 0xb6, 0x0d, 0xbf, 0x26, 0x6d, 0xc5, 0xcb, 0x93, - 0x88, 0xe5, 0xb1, 0xc8, 0xb1, 0x55, 0x7a, 0x39, 0x2c, 0x72, 0x8c, 0x8f, 0xa0, 0x96, 0x51, 0x52, - 0x46, 0xb5, 0x2e, 0x91, 0x5e, 0x5b, 0x41, 0xda, 0xd3, 0x4a, 0x0a, 0xe8, 0x27, 0x01, 0x64, 0x66, - 0x86, 0x22, 0xa6, 0x25, 0x1c, 0x72, 0x6c, 0x95, 0x5f, 0x06, 0x87, 0x1c, 0xab, 0xa6, 0x91, 0x64, - 0x30, 0xec, 0x07, 0x74, 0xc2, 0x87, 0x56, 0xa5, 0x63, 0x6c, 0x97, 0x44, 0xd3, 0x84, 0x6c, 0x4f, - 0x88, 0xec, 0x77, 0xa1, 0x3a, 0xaf, 0x2e, 0xbe, 0x0a, 0x6b, 0x23, 0x3a, 0xd3, 0xbd, 0x15, 0x47, - 0x6c, 0x42, 0xe9, 0x88, 0x1c, 0x4e, 0xb3, 0x56, 0xaa, 0xcb, 0xbd, 0xc2, 0x5d, 0xc3, 0x79, 0x0a, - 0xd7, 0x1e, 0x45, 0x2c, 0x90, 0xfd, 0x4a, 0x33, 0xce, 0xbe, 0x07, 0x25, 0xb9, 0x21, 0x24, 0x84, - 0xd9, 0xdd, 0xba, 0x44, 0x73, 0x7d, 0x65, 0xe1, 0x34, 0x01, 0x7b, 0x94, 0x3f, 0x53, 0x7c, 0xca, - 0x00, 0x9d, 0xb7, 0xa1, 0xb1, 0x24, 0x55, 0x34, 0x45, 0x1b, 0x2a, 0x9a, 0x79, 0x6a, 0xcc, 0xaa, - 0xfe, 0xfc, 0xee, 0x3c, 0x81, 0x66, 0x8f, 0xf2, 0x4f, 0x33, 0xce, 0xcd, 0x63, 0xb3, 0xa0, 0xac, - 0x75, 0x74, 0x82, 0xd9, 0x15, 0x6f, 0x42, 0x55, 0x4c, 0x62, 0x7f, 0x14, 0xb1, 0x40, 0x27, 0x5a, - 0x11, 0x82, 0x8f, 0x23, 0x16, 0x38, 0xef, 0x43, 0x75, 0x8e, 0x85, 0x08, 0xc5, 0x05, 0xf6, 0xcb, - 0xf3, 0xc5, 0xd6, 0x33, 0xd8, 0xc8, 0x05, 0xa3, 0x33, 0xb8, 0xbd, 0x30, 0x2c, 0x62, 0x2c, 0xb2, - 0x3c, 0x72, 0x52, 0xbc, 0x0b, 0x30, 0x97, 0xa4, 0x56, 0x41, 0xce, 0x8c, 0x95, 0x2b, 0xeb, 0x1c, - 0xde, 0x5f, 0xd0, 0x75, 0x7e, 0x36, 0xe0, 0x7a, 0x8f, 0xf2, 0x3d, 0x3a, 0xa1, 0x2c, 0xa0, 0x6c, - 0x10, 0x9d, 0xb5, 0xe9, 0x01, 0xc0, 0x19, 0xe7, 0x75, 0xaf, 0x2e, 0xc7, 0xf7, 0xea, 0x9c, 0xef, - 0xf8, 0x01, 0x54, 0x28, 0x0b, 0x14, 0x44, 0xe1, 0x3f, 0x40, 0x94, 0x29, 0x0b, 0x84, 0xdc, 0x39, - 0x80, 0x1b, 0x2b, 0xf1, 0xe9, 0xea, 0xf4, 0xa0, 0x16, 0x2c, 0xc8, 0xf5, 0x2a, 0x7d, 0x23, 0x97, - 0xf7, 0xdc, 0x74, 0xf6, 0x49, 0xc4, 0x46, 0x7a, 0xa9, 0x2e, 0x19, 0x76, 0x7f, 0x2d, 0x41, 0x4d, - 0x12, 0x4e, 0x53, 0x08, 0x47, 0x50, 0xc9, 0xbe, 0x11, 0xd8, 0xca, 0xe1, 0xe5, 0x3e, 0x1e, 0xf6, - 0xe6, 0x39, 0xab, 0x7b, 0x79, 0xd9, 0x3b, 0xf6, 0xf7, 0xbf, 0xff, 0xfd, 0x63, 0xa1, 0x89, 0xe8, - 0xc9, 0xcd, 0x9a, 0x7a, 0xdf, 0x66, 0x3b, 0xfb, 0xbb, 0x3b, 0x06, 0x72, 0xa8, 0x2d, 0x6e, 0x59, - 0x74, 0x72, 0x80, 0xe7, 0xac, 0x7d, 0x7b, 0xeb, 0x42, 0x1d, 0xbd, 0xa6, 0x6f, 0x4a, 0xb7, 0x1b, - 0x4e, 0xc3, 0x23, 0xea, 0x79, 0xc1, 0x2f, 0x86, 0x00, 0x67, 0x93, 0x89, 0x9d, 0x1c, 0xde, 0xca, - 0xd0, 0x5e, 0x26, 0x4d, 0x94, 0xfe, 0x6a, 0x4e, 0xd9, 0x53, 0xbb, 0xe3, 0x9e, 0xf1, 0xd6, 0x1d, - 0x03, 0x43, 0x30, 0x17, 0x86, 0x13, 0x37, 0x57, 0xcb, 0x99, 0x1b, 0x67, 0xdb, 0xb9, 0x48, 0x45, - 0xe7, 0x76, 0x4d, 0xfa, 0x32, 0xb1, 0xea, 0x65, 0x23, 0x8d, 0x31, 0xd4, 0x97, 0xa6, 0x08, 0xb7, - 0x56, 0x71, 0x56, 0x06, 0xde, 0x7e, 0xf3, 0x62, 0x25, 0xed, 0xae, 0x21, 0xdd, 0xd5, 0xd1, 0xf4, - 0xce, 0x66, 0x07, 0xbf, 0x91, 0xff, 0x24, 0x16, 0xa9, 0x89, 0xb7, 0x56, 0xd1, 0xce, 0x19, 0x2d, - 0xfb, 0xf6, 0xbf, 0xa9, 0x69, 0xb7, 0x1b, 0xd2, 0xed, 0x55, 0xac, 0x7b, 0x8b, 0x7c, 0xdd, 0xdd, - 0x79, 0x71, 0xda, 0x32, 0x7e, 0x3b, 0x6d, 0x19, 0x7f, 0x9d, 0xb6, 0x0c, 0xb8, 0x11, 0xc5, 0xee, - 0xd2, 0x07, 0x5e, 0xa3, 0x7e, 0xb1, 0xae, 0x7e, 0x0f, 0xd6, 0xe5, 0xa4, 0xbd, 0xf3, 0x4f, 0x00, - 0x00, 0x00, 0xff, 0xff, 0xf6, 0xb2, 0xb8, 0xe2, 0x98, 0x09, 0x00, 0x00, + // 983 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x56, 0x4f, 0x73, 0xdb, 0x44, + 0x14, 0x47, 0x8e, 0x1d, 0xdb, 0x4f, 0x76, 0x4b, 0xd7, 0x4e, 0x2b, 0x54, 0xb0, 0x1d, 0x85, 0x76, + 0x32, 0xcc, 0x44, 0x2a, 0xe6, 0x40, 0x29, 0xcc, 0x94, 0xa6, 0x69, 0x3d, 0x05, 0x5a, 0x40, 0xcd, + 0x09, 0x0e, 0x9e, 0x8d, 0xb5, 0xc8, 0xc2, 0xf1, 0xca, 0x95, 0xd6, 0x21, 0x1e, 0x86, 0x0b, 0x9f, + 0x80, 0x19, 0x2e, 0x9c, 0xb8, 0x72, 0xe2, 0x7b, 0xf4, 0xc8, 0x0c, 0x37, 0x0e, 0x81, 0xc9, 0x70, + 0xe4, 0xc0, 0x47, 0x60, 0xf6, 0x8f, 0x14, 0x49, 0xce, 0xa4, 0x69, 0xae, 0x9c, 0xac, 0x7d, 0xfb, + 0xde, 0xef, 0xfd, 0xfd, 0xbd, 0x35, 0xe8, 0xcf, 0xe6, 0x24, 0x5a, 0xd8, 0xb3, 0x28, 0x64, 0x21, + 0x6a, 0x7e, 0x8d, 0x89, 0x4f, 0x22, 0x1b, 0xcf, 0x82, 0xe1, 0x41, 0xdf, 0xd4, 0xa7, 0xa1, 0x47, + 0xf6, 0xe5, 0x9d, 0xd9, 0xf6, 0x43, 0x3f, 0x14, 0x9f, 0x0e, 0xff, 0x52, 0xd2, 0xd7, 0xfd, 0x30, + 0xf4, 0xf7, 0x89, 0x83, 0x67, 0x81, 0x83, 0x29, 0x0d, 0x19, 0x66, 0x41, 0x48, 0x63, 0x75, 0xdb, + 0x55, 0xb7, 0xe2, 0xb4, 0x37, 0xff, 0xca, 0x61, 0xc1, 0x94, 0xc4, 0x0c, 0x4f, 0x67, 0x4a, 0xa1, + 0x53, 0x54, 0xf0, 0xe6, 0x91, 0x40, 0x90, 0xf7, 0xd6, 0x3f, 0x1a, 0x5c, 0x1e, 0x10, 0xb6, 0x1b, + 0xe1, 0x11, 0x71, 0xc9, 0xb3, 0x39, 0x89, 0x19, 0xfa, 0x12, 0x6a, 0x8c, 0x9f, 0x87, 0x81, 0x67, + 0x68, 0x3d, 0x6d, 0xb3, 0xb1, 0xfd, 0xe1, 0xf3, 0xa3, 0xee, 0x2b, 0x7f, 0x1c, 0x75, 0xb7, 0xfc, + 0x80, 0x8d, 0xe7, 0x7b, 0xf6, 0x28, 0x9c, 0x3a, 0x32, 0x13, 0xae, 0x18, 0x50, 0x5f, 0x9d, 0x1c, + 0x99, 0x8f, 0x40, 0x7b, 0xb4, 0x73, 0x7c, 0xd4, 0xad, 0xaa, 0x4f, 0xb7, 0x2a, 0x10, 0x1f, 0x79, + 0xe8, 0x2e, 0x40, 0xcc, 0x70, 0xc4, 0x86, 0x3c, 0x52, 0xa3, 0xd4, 0xd3, 0x36, 0xf5, 0xbe, 0x69, + 0xcb, 0x28, 0xed, 0x24, 0x4a, 0x7b, 0x37, 0x49, 0x63, 0xbb, 0xfc, 0xc3, 0x9f, 0x5d, 0xcd, 0xad, + 0x0b, 0x1b, 0x2e, 0x45, 0xef, 0x43, 0x8d, 0x50, 0x4f, 0x9a, 0xaf, 0x9c, 0xd3, 0xbc, 0x4a, 0xa8, + 0xc7, 0x65, 0xd6, 0x03, 0x40, 0x4f, 0x67, 0x98, 0xc6, 0x2e, 0x89, 0x67, 0x21, 0x8d, 0xc9, 0xfd, + 0xf1, 0x9c, 0x4e, 0x90, 0x03, 0x95, 0x98, 0x4b, 0x0d, 0xad, 0xb7, 0xb2, 0xa9, 0xf7, 0x5b, 0x76, + 0xae, 0x4b, 0x36, 0xb7, 0xd8, 0x2e, 0xf3, 0x12, 0xb8, 0x52, 0xcf, 0xfa, 0x57, 0x83, 0xd6, 0xbd, + 0x68, 0x34, 0x0e, 0x0e, 0xc8, 0xff, 0xa5, 0x72, 0x57, 0xa1, 0x9d, 0xcf, 0x58, 0x16, 0xd0, 0xfa, + 0xa5, 0x0c, 0x6d, 0x21, 0xf9, 0x9c, 0x8f, 0xf9, 0x67, 0x38, 0xc2, 0x53, 0xc2, 0x48, 0x14, 0xa3, + 0x75, 0x68, 0xc4, 0x24, 0x3a, 0x08, 0x46, 0x64, 0x48, 0xf1, 0x94, 0x88, 0x7a, 0xd4, 0x5d, 0x5d, + 0xc9, 0x9e, 0xe0, 0x29, 0x41, 0x37, 0xe0, 0x52, 0x38, 0x23, 0x72, 0x1e, 0xa5, 0x52, 0x49, 0x28, + 0x35, 0x53, 0xa9, 0x50, 0xbb, 0x07, 0x65, 0x86, 0xfd, 0xd8, 0x58, 0x11, 0xdd, 0xd9, 0x2a, 0x74, + 0xe7, 0x34, 0xe7, 0xf6, 0x2e, 0xf6, 0xe3, 0x07, 0x94, 0x45, 0x0b, 0x57, 0x98, 0xa2, 0x8f, 0xe0, + 0xd2, 0x49, 0xed, 0x86, 0xd3, 0x80, 0x1a, 0xe5, 0x17, 0x16, 0xa0, 0xc6, 0x5b, 0x27, 0x8a, 0xd0, + 0x48, 0x6b, 0xf8, 0x38, 0xa0, 0x45, 0x2c, 0x7c, 0x68, 0x54, 0x2e, 0x86, 0x85, 0x0f, 0xd1, 0x43, + 0x68, 0x24, 0x84, 0x14, 0x51, 0xad, 0x0a, 0xa4, 0xd7, 0x96, 0x90, 0x76, 0x94, 0x92, 0x04, 0xfa, + 0x89, 0x03, 0xe9, 0x89, 0x21, 0x8f, 0x29, 0x87, 0x83, 0x0f, 0x8d, 0xea, 0x45, 0x70, 0xf0, 0xa1, + 0x6c, 0x1a, 0x8e, 0x46, 0xe3, 0xa1, 0x47, 0x66, 0x6c, 0x6c, 0xd4, 0x7a, 0xda, 0x66, 0x85, 0x37, + 0x8d, 0xcb, 0x76, 0xb8, 0xc8, 0x7c, 0x17, 0xea, 0x69, 0x75, 0xd1, 0xab, 0xb0, 0x32, 0x21, 0x0b, + 0xd5, 0x5b, 0xfe, 0x89, 0xda, 0x50, 0x39, 0xc0, 0xfb, 0xf3, 0xa4, 0x95, 0xf2, 0x70, 0xa7, 0x74, + 0x5b, 0xb3, 0x9e, 0xc0, 0x95, 0x87, 0x01, 0xf5, 0x44, 0xbf, 0xe2, 0x84, 0x31, 0xef, 0x41, 0x45, + 0xec, 0x47, 0x01, 0xa1, 0xf7, 0x37, 0xce, 0xd1, 0x5c, 0x57, 0x5a, 0x58, 0x6d, 0x40, 0x03, 0xc2, + 0x9e, 0xca, 0x79, 0x4a, 0x00, 0xad, 0xb7, 0xa1, 0x95, 0x93, 0xca, 0x31, 0x45, 0x26, 0xd4, 0xd4, + 0xe4, 0x49, 0x96, 0xd7, 0xdd, 0xf4, 0x6c, 0x3d, 0x86, 0xf6, 0x80, 0xb0, 0x4f, 0x93, 0x99, 0x4b, + 0x63, 0x33, 0xa0, 0xaa, 0x74, 0x54, 0x82, 0xc9, 0x11, 0x5d, 0x87, 0x3a, 0x5f, 0x04, 0xc3, 0x49, + 0x40, 0x3d, 0x95, 0x68, 0x8d, 0x0b, 0x3e, 0x0e, 0xa8, 0x67, 0x7d, 0x00, 0xf5, 0x14, 0x0b, 0x21, + 0x28, 0x67, 0xa6, 0x5f, 0x7c, 0x9f, 0x6d, 0xbd, 0x80, 0xb5, 0x42, 0x30, 0x2a, 0x83, 0x9b, 0x19, + 0xb2, 0x70, 0x5a, 0x24, 0x79, 0x14, 0xa4, 0xe8, 0x36, 0x40, 0x2a, 0x89, 0x8d, 0x92, 0xe0, 0x8c, + 0x51, 0x28, 0x6b, 0x0a, 0xef, 0x66, 0x74, 0xad, 0x9f, 0x35, 0xb8, 0x3a, 0x20, 0x6c, 0x87, 0xcc, + 0x08, 0xf5, 0x08, 0x1d, 0x05, 0x27, 0x6d, 0xba, 0x9f, 0xdb, 0x3d, 0xda, 0x4b, 0xcc, 0x7b, 0x66, + 0xff, 0xdc, 0xcd, 0xec, 0x9f, 0xd2, 0x4b, 0x40, 0xa4, 0x3b, 0x68, 0x0f, 0xae, 0x2d, 0xc5, 0xa7, + 0xaa, 0x33, 0x80, 0x86, 0x97, 0x91, 0xab, 0x4d, 0xfe, 0x46, 0x21, 0xef, 0xd4, 0x74, 0xf1, 0x49, + 0x40, 0x27, 0x6a, 0xa7, 0xe7, 0x0c, 0xfb, 0xbf, 0x56, 0xa0, 0x21, 0x06, 0x4e, 0x8d, 0x10, 0x9a, + 0x40, 0x2d, 0x79, 0x20, 0x51, 0xa7, 0x80, 0x57, 0x78, 0x39, 0xcd, 0xf5, 0x53, 0x5e, 0x8e, 0xfc, + 0x5b, 0x63, 0x99, 0xdf, 0xff, 0xfe, 0xf7, 0x8f, 0xa5, 0x36, 0x42, 0x8e, 0xd8, 0xeb, 0xb1, 0xf3, + 0x6d, 0xf2, 0x62, 0x7c, 0x77, 0x4b, 0x43, 0x0c, 0x1a, 0xd9, 0x2d, 0x8b, 0xac, 0x02, 0xe0, 0x29, + 0x8f, 0x8e, 0xb9, 0x71, 0xa6, 0x8e, 0x5a, 0xd3, 0xd7, 0x85, 0xdb, 0x35, 0xab, 0xe5, 0x60, 0x79, + 0x9d, 0xf1, 0x8b, 0x7c, 0x80, 0x13, 0x66, 0xa2, 0x5e, 0x01, 0x6f, 0x89, 0xb4, 0xe7, 0x49, 0x13, + 0x09, 0x7f, 0x0d, 0xab, 0xea, 0xc8, 0xdd, 0x71, 0x47, 0x7b, 0xeb, 0x96, 0x86, 0x7c, 0xd0, 0x33, + 0xe4, 0x44, 0xeb, 0xcb, 0xe5, 0x2c, 0xd0, 0xd9, 0xb4, 0xce, 0x52, 0x51, 0xb9, 0x5d, 0x11, 0xbe, + 0x74, 0x54, 0x77, 0x12, 0x4a, 0xa3, 0x10, 0x9a, 0x39, 0x16, 0xa1, 0x8d, 0x65, 0x9c, 0x25, 0xc2, + 0x9b, 0x6f, 0x9e, 0xad, 0xa4, 0xdc, 0xb5, 0x84, 0xbb, 0x26, 0xd2, 0x9d, 0x13, 0xee, 0xa0, 0x6f, + 0xc4, 0xdf, 0xa8, 0xec, 0x68, 0xa2, 0x1b, 0xcb, 0x68, 0xa7, 0x50, 0xcb, 0xbc, 0xf9, 0x22, 0x35, + 0xe5, 0x76, 0x4d, 0xb8, 0xbd, 0x8c, 0x9a, 0x4e, 0x76, 0x5e, 0xb7, 0xb7, 0x9e, 0x1f, 0x77, 0xb4, + 0xdf, 0x8e, 0x3b, 0xda, 0x5f, 0xc7, 0x1d, 0x0d, 0xae, 0x05, 0xa1, 0x9d, 0xfb, 0x7b, 0xa1, 0x50, + 0xbf, 0x58, 0x95, 0xbf, 0x7b, 0xab, 0x82, 0x69, 0xef, 0xfc, 0x17, 0x00, 0x00, 0xff, 0xff, 0xe1, + 0x8b, 0x00, 0xa9, 0x96, 0x0a, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1125,6 +1175,26 @@ func (m *GetTraceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + if m.EndTime != nil { + n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.EndTime):]) + if err1 != nil { + return 0, err1 + } + i -= n1 + i = encodeVarintQuery(dAtA, i, uint64(n1)) + i-- + dAtA[i] = 0x1a + } + if m.StartTime != nil { + n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.StartTime):]) + if err2 != nil { + return 0, err2 + } + i -= n2 + i = encodeVarintQuery(dAtA, i, uint64(n2)) + i-- + dAtA[i] = 0x12 + } { size := m.TraceID.Size() i -= size @@ -1203,6 +1273,26 @@ func (m *ArchiveTraceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + if m.EndTime != nil { + n3, err3 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.EndTime):]) + if err3 != nil { + return 0, err3 + } + i -= n3 + i = encodeVarintQuery(dAtA, i, uint64(n3)) + i-- + dAtA[i] = 0x1a + } + if m.StartTime != nil { + n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.StartTime):]) + if err4 != nil { + return 0, err4 + } + i -= n4 + i = encodeVarintQuery(dAtA, i, uint64(n4)) + i-- + dAtA[i] = 0x12 + } { size := m.TraceID.Size() i -= size @@ -1272,36 +1362,36 @@ func (m *TraceQueryParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x40 } - n1, err1 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.DurationMax, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.DurationMax):]) - if err1 != nil { - return 0, err1 + n5, err5 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.DurationMax, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.DurationMax):]) + if err5 != nil { + return 0, err5 } - i -= n1 - i = encodeVarintQuery(dAtA, i, uint64(n1)) + i -= n5 + i = encodeVarintQuery(dAtA, i, uint64(n5)) i-- dAtA[i] = 0x3a - n2, err2 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.DurationMin, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.DurationMin):]) - if err2 != nil { - return 0, err2 + n6, err6 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.DurationMin, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.DurationMin):]) + if err6 != nil { + return 0, err6 } - i -= n2 - i = encodeVarintQuery(dAtA, i, uint64(n2)) + i -= n6 + i = encodeVarintQuery(dAtA, i, uint64(n6)) i-- dAtA[i] = 0x32 - n3, err3 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTimeMax, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTimeMax):]) - if err3 != nil { - return 0, err3 + n7, err7 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTimeMax, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTimeMax):]) + if err7 != nil { + return 0, err7 } - i -= n3 - i = encodeVarintQuery(dAtA, i, uint64(n3)) + i -= n7 + i = encodeVarintQuery(dAtA, i, uint64(n7)) i-- dAtA[i] = 0x2a - n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTimeMin, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTimeMin):]) - if err4 != nil { - return 0, err4 + n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTimeMin, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTimeMin):]) + if err8 != nil { + return 0, err8 } - i -= n4 - i = encodeVarintQuery(dAtA, i, uint64(n4)) + i -= n8 + i = encodeVarintQuery(dAtA, i, uint64(n8)) i-- dAtA[i] = 0x22 if len(m.Tags) > 0 { @@ -1598,20 +1688,20 @@ func (m *GetDependenciesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - n6, err6 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime):]) - if err6 != nil { - return 0, err6 + n10, err10 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime):]) + if err10 != nil { + return 0, err10 } - i -= n6 - i = encodeVarintQuery(dAtA, i, uint64(n6)) + i -= n10 + i = encodeVarintQuery(dAtA, i, uint64(n10)) i-- dAtA[i] = 0x12 - n7, err7 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime):]) - if err7 != nil { - return 0, err7 + n11, err11 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime):]) + if err11 != nil { + return 0, err11 } - i -= n7 - i = encodeVarintQuery(dAtA, i, uint64(n7)) + i -= n11 + i = encodeVarintQuery(dAtA, i, uint64(n11)) i-- dAtA[i] = 0xa return len(dAtA) - i, nil @@ -1677,6 +1767,14 @@ func (m *GetTraceRequest) Size() (n int) { _ = l l = m.TraceID.Size() n += 1 + l + sovQuery(uint64(l)) + if m.StartTime != nil { + l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.StartTime) + n += 1 + l + sovQuery(uint64(l)) + } + if m.EndTime != nil { + l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.EndTime) + n += 1 + l + sovQuery(uint64(l)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -1709,6 +1807,14 @@ func (m *ArchiveTraceRequest) Size() (n int) { _ = l l = m.TraceID.Size() n += 1 + l + sovQuery(uint64(l)) + if m.StartTime != nil { + l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.StartTime) + n += 1 + l + sovQuery(uint64(l)) + } + if m.EndTime != nil { + l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.EndTime) + n += 1 + l + sovQuery(uint64(l)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -1978,6 +2084,78 @@ func (m *GetTraceRequest) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StartTime == nil { + m.StartTime = new(time.Time) + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.StartTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EndTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.EndTime == nil { + m.EndTime = new(time.Time) + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.EndTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipQuery(dAtA[iNdEx:]) @@ -2147,6 +2325,78 @@ func (m *ArchiveTraceRequest) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StartTime == nil { + m.StartTime = new(time.Time) + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.StartTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EndTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.EndTime == nil { + m.EndTime = new(time.Time) + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.EndTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipQuery(dAtA[iNdEx:]) diff --git a/proto-gen/api_v3/query_service.pb.go b/proto-gen/api_v3/query_service.pb.go index eb3ee8b4cc6..3cf2bf386dd 100644 --- a/proto-gen/api_v3/query_service.pb.go +++ b/proto-gen/api_v3/query_service.pb.go @@ -6,6 +6,7 @@ package api_v3 import ( context "context" fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" proto "github.com/gogo/protobuf/proto" types "github.com/gogo/protobuf/types" v1 "github.com/jaegertracing/jaeger/proto-gen/otel/trace/v1" @@ -13,12 +14,14 @@ import ( codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" math "math" + time "time" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf +var _ = time.Kitchen // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. @@ -29,10 +32,14 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // Request object to get a trace. type GetTraceRequest struct { // Hex encoded 64 or 128 bit trace ID. - TraceId string `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + TraceId string `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"` + // Optional. The start time to search trace ID. + StartTime *time.Time `protobuf:"bytes,2,opt,name=start_time,json=startTime,proto3,stdtime" json:"start_time,omitempty"` + // Optional. The end time to search trace ID. + EndTime *time.Time `protobuf:"bytes,3,opt,name=end_time,json=endTime,proto3,stdtime" json:"end_time,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *GetTraceRequest) Reset() { *m = GetTraceRequest{} } @@ -66,6 +73,20 @@ func (m *GetTraceRequest) GetTraceId() string { return "" } +func (m *GetTraceRequest) GetStartTime() *time.Time { + if m != nil { + return m.StartTime + } + return nil +} + +func (m *GetTraceRequest) GetEndTime() *time.Time { + if m != nil { + return m.EndTime + } + return nil +} + // Response object with spans. type SpansResponseChunk struct { // A list of OpenTelemetry ResourceSpans. @@ -111,8 +132,18 @@ func (m *SpansResponseChunk) GetResourceSpans() []*v1.ResourceSpans { return nil } -// Query parameters to find traces. -// Note that some storage implementations do not guarantee the correct implementation of all parameters. +// Query parameters to find traces. Except for num_traces, all fields should be treated +// as forming a conjunction, e.g., "service_name='X' AND operation_name='Y' AND ...". +// All fields are matched against individual spans, not at the trace level. +// The returned results contain traces where at least one span matches the conditions. +// When num_traces results in fewer traces returned, there is no required ordering. +// +// Note: num_traces should restrict the number of traces returned, but not all backends +// interpret it this way. For instance, in Cassandra this limits the number of _spans_ +// that match the conditions, and the resulting number of traces can be less. +// +// Note: some storage implementations do not guarantee the correct implementation of all parameters. +// type TraceQueryParameters struct { ServiceName string `protobuf:"bytes,1,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"` OperationName string `protobuf:"bytes,2,opt,name=operation_name,json=operationName,proto3" json:"operation_name,omitempty"` @@ -474,50 +505,53 @@ func init() { func init() { proto.RegisterFile("query_service.proto", fileDescriptor_5fcb6756dc1afb8d) } var fileDescriptor_5fcb6756dc1afb8d = []byte{ - // 675 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x7f, 0x4f, 0xdb, 0x3a, - 0x14, 0x25, 0x40, 0xa1, 0xbd, 0x6d, 0xe1, 0x3d, 0xd3, 0xa7, 0x17, 0x32, 0x8d, 0xb5, 0x61, 0x93, - 0x2a, 0x6d, 0x4a, 0x47, 0xf9, 0x87, 0x4d, 0x4c, 0xda, 0x6f, 0x34, 0x4d, 0xb0, 0x11, 0xd8, 0xfe, - 0x98, 0x26, 0x45, 0x86, 0xde, 0x95, 0x0c, 0xe2, 0x04, 0xdb, 0xa9, 0xda, 0xcf, 0xb1, 0xef, 0xb9, - 0xcf, 0x30, 0xc5, 0x76, 0xb2, 0x36, 0x9d, 0x10, 0xfb, 0x2b, 0xb9, 0xf6, 0x39, 0xc7, 0xd7, 0xf7, - 0xdc, 0x6b, 0xd8, 0xb8, 0x4e, 0x91, 0x4f, 0x02, 0x81, 0x7c, 0x14, 0x9e, 0xa3, 0x97, 0xf0, 0x58, - 0xc6, 0xa4, 0xf9, 0x9d, 0xe2, 0x10, 0xb9, 0x47, 0x93, 0x30, 0x18, 0xed, 0x3a, 0xdd, 0x38, 0x41, - 0x26, 0xf1, 0x0a, 0x23, 0x94, 0x7c, 0xd2, 0x53, 0x98, 0x9e, 0xe4, 0xf4, 0x1c, 0x7b, 0xa3, 0x1d, - 0xfd, 0xa3, 0x89, 0xce, 0xbd, 0x61, 0x1c, 0x0f, 0xaf, 0x50, 0x43, 0xce, 0xd2, 0x6f, 0x3d, 0x19, - 0x46, 0x28, 0x24, 0x8d, 0x12, 0x03, 0xd8, 0x2a, 0x03, 0x06, 0x29, 0xa7, 0x32, 0x8c, 0x99, 0xde, - 0x77, 0x1f, 0xc1, 0xfa, 0x01, 0xca, 0xd3, 0x4c, 0xd2, 0xc7, 0xeb, 0x14, 0x85, 0x24, 0x9b, 0x50, - 0x55, 0x47, 0x04, 0xe1, 0xc0, 0xb6, 0xda, 0x56, 0xb7, 0xe6, 0xaf, 0xaa, 0xf8, 0xdd, 0xc0, 0xbd, - 0x00, 0x72, 0x92, 0x50, 0x26, 0x7c, 0x14, 0x49, 0xcc, 0x04, 0xbe, 0xba, 0x48, 0xd9, 0x25, 0xf1, - 0x61, 0x8d, 0xa3, 0x88, 0x53, 0x7e, 0x8e, 0x81, 0xc8, 0xb6, 0x6d, 0xab, 0xbd, 0xd4, 0xad, 0xf7, - 0x1f, 0x7a, 0x33, 0xf7, 0xd0, 0x27, 0x7a, 0x3a, 0xfd, 0xd1, 0x8e, 0xe7, 0x1b, 0x8e, 0x56, 0x6c, - 0xf2, 0xe9, 0xd0, 0xfd, 0xb1, 0x0c, 0x2d, 0x95, 0xd5, 0x71, 0x56, 0xae, 0x8f, 0x94, 0xd3, 0x08, - 0x25, 0x72, 0x41, 0x3a, 0xd0, 0x30, 0xb5, 0x0b, 0x18, 0x8d, 0xd0, 0x64, 0x58, 0x37, 0x6b, 0x47, - 0x34, 0x42, 0xf2, 0x00, 0xd6, 0xe2, 0x04, 0xf5, 0x35, 0x35, 0x68, 0x51, 0x81, 0x9a, 0xc5, 0xaa, - 0x82, 0x9d, 0x00, 0x50, 0x29, 0x79, 0x78, 0x96, 0x4a, 0x14, 0xf6, 0x92, 0x4a, 0x79, 0xd7, 0x9b, - 0x71, 0xc2, 0xfb, 0x53, 0x0a, 0xde, 0x8b, 0x82, 0xf5, 0x86, 0x49, 0x3e, 0xf1, 0xa7, 0x64, 0xc8, - 0x73, 0x58, 0x13, 0x92, 0x72, 0x19, 0x64, 0x46, 0x04, 0x51, 0xc8, 0xec, 0xe5, 0xb6, 0xd5, 0xad, - 0xf7, 0x1d, 0x4f, 0x1b, 0xe1, 0xe5, 0x46, 0x78, 0xa7, 0xb9, 0x53, 0x7e, 0x43, 0x31, 0xb2, 0xf8, - 0x30, 0x64, 0x65, 0x05, 0x3a, 0xb6, 0x2b, 0x7f, 0xa3, 0x40, 0xc7, 0x64, 0x1f, 0x1a, 0xb9, 0xcb, - 0x2a, 0x83, 0x15, 0xc5, 0xdf, 0x9c, 0xe3, 0xbf, 0x36, 0x20, 0xbf, 0x9e, 0xc3, 0xb3, 0xf3, 0x67, - 0xd8, 0x74, 0x6c, 0xaf, 0xde, 0x9e, 0x4d, 0xc7, 0xe4, 0x2e, 0x00, 0x4b, 0xa3, 0x40, 0x99, 0x2c, - 0xec, 0x6a, 0xdb, 0xea, 0x56, 0xfc, 0x1a, 0x4b, 0x23, 0x55, 0x48, 0xe1, 0x3c, 0x83, 0xf5, 0x52, - 0xf5, 0xc8, 0x3f, 0xb0, 0x74, 0x89, 0x13, 0xe3, 0x63, 0xf6, 0x4b, 0x5a, 0x50, 0x19, 0xd1, 0xab, - 0x34, 0xb7, 0x4d, 0x07, 0x4f, 0x17, 0xf7, 0x2c, 0xf7, 0x08, 0xfe, 0x7d, 0x1b, 0xb2, 0x81, 0x16, - 0xcb, 0xfb, 0xf5, 0x09, 0x54, 0xd4, 0x4c, 0x29, 0x89, 0x7a, 0x7f, 0xfb, 0x16, 0x16, 0xfa, 0x9a, - 0xe1, 0xb6, 0x80, 0x1c, 0xa0, 0x3c, 0xd1, 0xbd, 0x93, 0x0b, 0xba, 0x3b, 0xb0, 0x31, 0xb3, 0xaa, - 0x7b, 0x9d, 0x38, 0x50, 0x35, 0x5d, 0xa6, 0x1b, 0xbc, 0xe6, 0x17, 0xb1, 0x7b, 0x08, 0xad, 0x03, - 0x94, 0x1f, 0xf2, 0xfe, 0x2a, 0x72, 0xb3, 0x61, 0xd5, 0x60, 0xf2, 0x51, 0x32, 0x21, 0xb9, 0x03, - 0xb5, 0x6c, 0x56, 0x82, 0xcb, 0x90, 0x0d, 0xcc, 0x45, 0xab, 0xd9, 0xc2, 0xfb, 0x90, 0x0d, 0xdc, - 0x7d, 0xa8, 0x15, 0x5a, 0x84, 0xc0, 0xf2, 0x54, 0xa7, 0xab, 0xff, 0x9b, 0xd9, 0xc7, 0xf0, 0x5f, - 0x29, 0x19, 0x73, 0x83, 0x3d, 0x80, 0x62, 0x04, 0xf2, 0x21, 0xb5, 0x4b, 0xe5, 0x2a, 0x68, 0xfe, - 0x14, 0xb6, 0xff, 0x73, 0x11, 0x1a, 0xaa, 0x86, 0xa6, 0x2a, 0xe4, 0x18, 0xaa, 0xf9, 0xbb, 0x41, - 0xb6, 0x4a, 0x12, 0xa5, 0x07, 0xc5, 0xe9, 0x94, 0xf6, 0xe7, 0x9f, 0x10, 0x77, 0xe1, 0xb1, 0x45, - 0x3e, 0x01, 0xfc, 0x36, 0x97, 0xb4, 0x4b, 0xa4, 0x39, 0xdf, 0x6f, 0x2b, 0xfb, 0x19, 0xea, 0x53, - 0x6e, 0x92, 0xce, 0x7c, 0xb2, 0x25, 0xff, 0x1d, 0xf7, 0x26, 0x88, 0x96, 0x77, 0x17, 0xc8, 0x57, - 0x68, 0xce, 0x54, 0x99, 0x6c, 0xcf, 0xd3, 0xe6, 0x1a, 0xc2, 0xb9, 0x7f, 0x33, 0x28, 0x57, 0x7f, - 0xd9, 0x81, 0xff, 0xc3, 0xd8, 0x60, 0xb3, 0x61, 0x0a, 0xd9, 0xd0, 0x50, 0xbe, 0xac, 0xe8, 0xef, - 0xd9, 0x8a, 0x1a, 0xc5, 0xdd, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xd4, 0x58, 0x79, 0x69, 0x52, - 0x06, 0x00, 0x00, + // 726 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xed, 0x6e, 0xd3, 0x48, + 0x14, 0xad, 0xf3, 0xd1, 0x24, 0x37, 0x49, 0xbb, 0x3b, 0xcd, 0x6a, 0x5d, 0xaf, 0xb6, 0x4d, 0xdc, + 0x5d, 0x29, 0x12, 0x92, 0x43, 0xd3, 0x3f, 0x05, 0x8a, 0x80, 0xf2, 0x51, 0x21, 0xd4, 0x42, 0xdd, + 0xc2, 0x0f, 0x84, 0x64, 0x4d, 0xeb, 0x4b, 0x6a, 0x5a, 0x8f, 0x53, 0x7b, 0x1c, 0x25, 0x6f, 0x81, + 0xc4, 0x5b, 0xf0, 0x52, 0xbc, 0x01, 0xcf, 0x80, 0x3c, 0x33, 0x76, 0x13, 0x07, 0x95, 0xf0, 0x2b, + 0x33, 0x77, 0xce, 0x39, 0xf7, 0xe6, 0x9e, 0x7b, 0x0d, 0x6b, 0xd7, 0x31, 0x86, 0x13, 0x27, 0xc2, + 0x70, 0xe4, 0x9d, 0xa3, 0x35, 0x0c, 0x03, 0x1e, 0x90, 0xe6, 0x27, 0x8a, 0x03, 0x0c, 0x2d, 0x3a, + 0xf4, 0x9c, 0xd1, 0x8e, 0xd1, 0x0d, 0x86, 0xc8, 0x38, 0x5e, 0xa1, 0x8f, 0x3c, 0x9c, 0xf4, 0x04, + 0xa6, 0xc7, 0x43, 0x7a, 0x8e, 0xbd, 0xd1, 0xb6, 0x3c, 0x48, 0xa2, 0xd1, 0x1a, 0x04, 0x83, 0x40, + 0xbe, 0x27, 0x27, 0x15, 0xdd, 0x1c, 0x04, 0xc1, 0xe0, 0x0a, 0x25, 0xf1, 0x2c, 0xfe, 0xd8, 0xe3, + 0x9e, 0x8f, 0x11, 0xa7, 0xfe, 0x50, 0x01, 0x36, 0xf2, 0x00, 0x37, 0x0e, 0x29, 0xf7, 0x02, 0x26, + 0xdf, 0xcd, 0xaf, 0x1a, 0xac, 0x1e, 0x20, 0x3f, 0x4d, 0x32, 0xd9, 0x78, 0x1d, 0x63, 0xc4, 0xc9, + 0x3a, 0x54, 0x45, 0x66, 0xc7, 0x73, 0x75, 0xad, 0xad, 0x75, 0x6b, 0x76, 0x45, 0xdc, 0x5f, 0xba, + 0xe4, 0x11, 0x40, 0xc4, 0x69, 0xc8, 0x9d, 0x24, 0x8f, 0x5e, 0x68, 0x6b, 0xdd, 0x7a, 0xdf, 0xb0, + 0x64, 0x0e, 0x2b, 0xcd, 0x61, 0x9d, 0xa6, 0x45, 0xec, 0x97, 0x3e, 0x7f, 0xdb, 0xd4, 0xec, 0x9a, + 0xe0, 0x24, 0x51, 0xf2, 0x00, 0xaa, 0xc8, 0x5c, 0x49, 0x2f, 0x2e, 0x48, 0xaf, 0x20, 0x73, 0x93, + 0x98, 0x79, 0x01, 0xe4, 0x64, 0x48, 0x59, 0x64, 0x63, 0x34, 0x0c, 0x58, 0x84, 0x4f, 0x2f, 0x62, + 0x76, 0x49, 0x6c, 0x58, 0x09, 0x31, 0x0a, 0xe2, 0xf0, 0x1c, 0x9d, 0x28, 0x79, 0xd6, 0xb5, 0x76, + 0xb1, 0x5b, 0xef, 0xdf, 0xb1, 0x66, 0x9a, 0x2b, 0xf5, 0x2d, 0xd9, 0xd3, 0xd1, 0xb6, 0x65, 0x2b, + 0x8e, 0x54, 0x6c, 0x86, 0xd3, 0x57, 0xf3, 0x4b, 0x09, 0x5a, 0xa2, 0x27, 0xc7, 0x89, 0x87, 0x6f, + 0x68, 0x48, 0x7d, 0xe4, 0x18, 0x46, 0xa4, 0x03, 0x0d, 0x65, 0xa8, 0xc3, 0xa8, 0x8f, 0xaa, 0x3f, + 0x75, 0x15, 0x3b, 0xa2, 0x3e, 0x92, 0xff, 0x61, 0x25, 0x18, 0xa2, 0xec, 0xb2, 0x04, 0x15, 0x04, + 0xa8, 0x99, 0x45, 0x05, 0xec, 0x04, 0x80, 0x72, 0x1e, 0x7a, 0x67, 0x31, 0xc7, 0x48, 0x2f, 0x8a, + 0x92, 0x77, 0xac, 0x99, 0xf1, 0xb0, 0x7e, 0x56, 0x82, 0xf5, 0x24, 0x63, 0x3d, 0x67, 0x3c, 0x9c, + 0xd8, 0x53, 0x32, 0xe4, 0x31, 0xac, 0xdc, 0xf8, 0xe3, 0xf8, 0x1e, 0xd3, 0x4b, 0xbf, 0x6a, 0xb2, + 0xdd, 0xc8, 0xdc, 0x39, 0xf4, 0x58, 0x5e, 0x81, 0x8e, 0xf5, 0xf2, 0xef, 0x28, 0xd0, 0x31, 0xd9, + 0x83, 0x46, 0x3a, 0x64, 0xa2, 0x82, 0x65, 0xc1, 0x5f, 0x9f, 0xe3, 0x3f, 0x53, 0x20, 0xbb, 0x9e, + 0xc2, 0x93, 0xfc, 0x33, 0x6c, 0x3a, 0xd6, 0x2b, 0x8b, 0xb3, 0xe9, 0x98, 0xfc, 0x0b, 0xc0, 0x62, + 0xdf, 0x11, 0x26, 0x47, 0x7a, 0xb5, 0xad, 0x75, 0xcb, 0x76, 0x8d, 0xc5, 0xbe, 0x68, 0x64, 0x64, + 0x3c, 0x84, 0xd5, 0x5c, 0xf7, 0xc8, 0x1f, 0x50, 0xbc, 0xc4, 0x89, 0xf2, 0x31, 0x39, 0x92, 0x16, + 0x94, 0x47, 0xf4, 0x2a, 0x4e, 0x6d, 0x93, 0x97, 0xfb, 0x85, 0x5d, 0xcd, 0x3c, 0x82, 0x3f, 0x5f, + 0x78, 0xcc, 0x95, 0x62, 0xe9, 0xb6, 0xdc, 0x83, 0xb2, 0x58, 0x74, 0x21, 0x51, 0xef, 0x6f, 0x2d, + 0x60, 0xa1, 0x2d, 0x19, 0x66, 0x0b, 0xc8, 0x01, 0xf2, 0x13, 0x39, 0x3b, 0xa9, 0xa0, 0xb9, 0x0d, + 0x6b, 0x33, 0x51, 0x39, 0xeb, 0xc4, 0x80, 0xaa, 0x9a, 0x32, 0x39, 0xe0, 0x35, 0x3b, 0xbb, 0x9b, + 0x87, 0xd0, 0x3a, 0x40, 0xfe, 0x3a, 0x9d, 0xaf, 0xac, 0x36, 0x1d, 0x2a, 0x0a, 0x93, 0x2e, 0xb2, + 0xba, 0x92, 0x7f, 0xa0, 0x96, 0xec, 0x8a, 0x73, 0xe9, 0x31, 0x57, 0xfd, 0xd1, 0x6a, 0x12, 0x78, + 0xe5, 0x31, 0xd7, 0xdc, 0x83, 0x5a, 0xa6, 0x45, 0x08, 0x94, 0xa6, 0x26, 0x5d, 0x9c, 0x6f, 0x67, + 0x1f, 0xc3, 0x5f, 0xb9, 0x62, 0xd4, 0x3f, 0xd8, 0x05, 0xc8, 0x56, 0x20, 0x5d, 0x52, 0x3d, 0xd7, + 0xae, 0x8c, 0x66, 0x4f, 0x61, 0xfb, 0xdf, 0x0b, 0xd0, 0x10, 0x3d, 0x54, 0x5d, 0x21, 0xc7, 0x50, + 0x4d, 0xbf, 0x5a, 0x64, 0x23, 0x27, 0x91, 0xfb, 0x9c, 0x19, 0x9d, 0xdc, 0xfb, 0xfc, 0x27, 0xc4, + 0x5c, 0xba, 0xab, 0x91, 0xb7, 0x00, 0x37, 0xe6, 0x92, 0x76, 0x8e, 0x34, 0xe7, 0xfb, 0xa2, 0xb2, + 0xef, 0xa0, 0x3e, 0xe5, 0x26, 0xe9, 0xcc, 0x17, 0x9b, 0xf3, 0xdf, 0x30, 0x6f, 0x83, 0x48, 0x79, + 0x73, 0x89, 0x7c, 0x80, 0xe6, 0x4c, 0x97, 0xc9, 0xd6, 0x3c, 0x6d, 0x6e, 0x20, 0x8c, 0xff, 0x6e, + 0x07, 0xa5, 0xea, 0xfb, 0x1d, 0xf8, 0xdb, 0x0b, 0x14, 0x36, 0x59, 0x26, 0x8f, 0x0d, 0x14, 0xe5, + 0xfd, 0xb2, 0xfc, 0x3d, 0x5b, 0x16, 0xab, 0xb8, 0xf3, 0x23, 0x00, 0x00, 0xff, 0xff, 0xe0, 0xd2, + 0xc5, 0xf1, 0xe7, 0x06, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/proto-gen/api_v3/query_service.pb.gw.go b/proto-gen/api_v3/query_service.pb.gw.go index 32a13f58271..d393094c306 100644 --- a/proto-gen/api_v3/query_service.pb.gw.go +++ b/proto-gen/api_v3/query_service.pb.gw.go @@ -33,6 +33,10 @@ var _ = utilities.NewDoubleArray var _ = descriptor.ForMessage var _ = metadata.Join +var ( + filter_QueryService_GetTrace_0 = &utilities.DoubleArray{Encoding: map[string]int{"trace_id": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} +) + func request_QueryService_GetTrace_0(ctx context.Context, marshaler runtime.Marshaler, client QueryServiceClient, req *http.Request, pathParams map[string]string) (QueryService_GetTraceClient, runtime.ServerMetadata, error) { var protoReq GetTraceRequest var metadata runtime.ServerMetadata @@ -55,6 +59,13 @@ func request_QueryService_GetTrace_0(ctx context.Context, marshaler runtime.Mars return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "trace_id", err) } + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_QueryService_GetTrace_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + stream, err := client.GetTrace(ctx, &protoReq) if err != nil { return nil, metadata, err diff --git a/proto-gen/otel/common/v1/common.pb.go b/proto-gen/otel/common/v1/common.pb.go index a7696be26f8..02892d7108d 100644 --- a/proto-gen/otel/common/v1/common.pb.go +++ b/proto-gen/otel/common/v1/common.pb.go @@ -304,92 +304,115 @@ func (m *KeyValue) GetValue() *AnyValue { return nil } -// InstrumentationLibrary is a message representing the instrumentation library information +// InstrumentationScope is a message representing the instrumentation scope information // such as the fully qualified name and version. -type InstrumentationLibrary struct { - // An empty instrumentation library name means the name is unknown. - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *InstrumentationLibrary) Reset() { *m = InstrumentationLibrary{} } -func (m *InstrumentationLibrary) String() string { return proto.CompactTextString(m) } -func (*InstrumentationLibrary) ProtoMessage() {} -func (*InstrumentationLibrary) Descriptor() ([]byte, []int) { +type InstrumentationScope struct { + // An empty instrumentation scope name means the name is unknown. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"` + // Additional attributes that describe the scope. [Optional]. + // Attribute keys MUST be unique (it is not allowed to have more than one + // attribute with the same key). + Attributes []*KeyValue `protobuf:"bytes,3,rep,name=attributes,proto3" json:"attributes,omitempty"` + DroppedAttributesCount uint32 `protobuf:"varint,4,opt,name=dropped_attributes_count,json=droppedAttributesCount,proto3" json:"dropped_attributes_count,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *InstrumentationScope) Reset() { *m = InstrumentationScope{} } +func (m *InstrumentationScope) String() string { return proto.CompactTextString(m) } +func (*InstrumentationScope) ProtoMessage() {} +func (*InstrumentationScope) Descriptor() ([]byte, []int) { return fileDescriptor_92d5df4519b8f2e3, []int{4} } -func (m *InstrumentationLibrary) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_InstrumentationLibrary.Unmarshal(m, b) +func (m *InstrumentationScope) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_InstrumentationScope.Unmarshal(m, b) } -func (m *InstrumentationLibrary) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_InstrumentationLibrary.Marshal(b, m, deterministic) +func (m *InstrumentationScope) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_InstrumentationScope.Marshal(b, m, deterministic) } -func (m *InstrumentationLibrary) XXX_Merge(src proto.Message) { - xxx_messageInfo_InstrumentationLibrary.Merge(m, src) +func (m *InstrumentationScope) XXX_Merge(src proto.Message) { + xxx_messageInfo_InstrumentationScope.Merge(m, src) } -func (m *InstrumentationLibrary) XXX_Size() int { - return xxx_messageInfo_InstrumentationLibrary.Size(m) +func (m *InstrumentationScope) XXX_Size() int { + return xxx_messageInfo_InstrumentationScope.Size(m) } -func (m *InstrumentationLibrary) XXX_DiscardUnknown() { - xxx_messageInfo_InstrumentationLibrary.DiscardUnknown(m) +func (m *InstrumentationScope) XXX_DiscardUnknown() { + xxx_messageInfo_InstrumentationScope.DiscardUnknown(m) } -var xxx_messageInfo_InstrumentationLibrary proto.InternalMessageInfo +var xxx_messageInfo_InstrumentationScope proto.InternalMessageInfo -func (m *InstrumentationLibrary) GetName() string { +func (m *InstrumentationScope) GetName() string { if m != nil { return m.Name } return "" } -func (m *InstrumentationLibrary) GetVersion() string { +func (m *InstrumentationScope) GetVersion() string { if m != nil { return m.Version } return "" } +func (m *InstrumentationScope) GetAttributes() []*KeyValue { + if m != nil { + return m.Attributes + } + return nil +} + +func (m *InstrumentationScope) GetDroppedAttributesCount() uint32 { + if m != nil { + return m.DroppedAttributesCount + } + return 0 +} + func init() { proto.RegisterType((*AnyValue)(nil), "jaeger.common.v1.AnyValue") proto.RegisterType((*ArrayValue)(nil), "jaeger.common.v1.ArrayValue") proto.RegisterType((*KeyValueList)(nil), "jaeger.common.v1.KeyValueList") proto.RegisterType((*KeyValue)(nil), "jaeger.common.v1.KeyValue") - proto.RegisterType((*InstrumentationLibrary)(nil), "jaeger.common.v1.InstrumentationLibrary") + proto.RegisterType((*InstrumentationScope)(nil), "jaeger.common.v1.InstrumentationScope") } func init() { proto.RegisterFile("common/v1/common.proto", fileDescriptor_92d5df4519b8f2e3) } var fileDescriptor_92d5df4519b8f2e3 = []byte{ - // 418 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0x4f, 0x6f, 0xd4, 0x30, - 0x10, 0xc5, 0xd7, 0xdd, 0x76, 0x77, 0x33, 0xc9, 0xa1, 0xf2, 0xa1, 0x5a, 0x21, 0xfe, 0x98, 0xe5, - 0x92, 0x0b, 0x09, 0x5d, 0x2e, 0xdc, 0xa0, 0xa9, 0x84, 0x82, 0xa8, 0x50, 0xe5, 0x03, 0x07, 0x2e, - 0xc8, 0x29, 0x56, 0x30, 0x9b, 0xd8, 0x95, 0xe3, 0x44, 0xca, 0x17, 0xe4, 0x73, 0x21, 0xff, 0x49, - 0x16, 0x01, 0x42, 0xbd, 0xcd, 0x3c, 0xff, 0xe6, 0xcd, 0x4b, 0x6c, 0xb8, 0xb8, 0x53, 0x6d, 0xab, - 0x64, 0x3e, 0x5c, 0xe6, 0xbe, 0xca, 0xee, 0xb5, 0x32, 0x0a, 0x9f, 0xff, 0x60, 0xbc, 0xe6, 0x3a, - 0x0b, 0xe2, 0x70, 0xb9, 0xfb, 0x79, 0x02, 0x9b, 0x2b, 0x39, 0x7e, 0x66, 0x4d, 0xcf, 0xf1, 0x0b, - 0x48, 0x3a, 0xa3, 0x85, 0xac, 0xbf, 0x0e, 0xb6, 0xdf, 0x22, 0x82, 0xd2, 0xa8, 0x5c, 0xd0, 0xd8, - 0xab, 0x1e, 0x7a, 0x06, 0x50, 0x29, 0xd5, 0x04, 0xe4, 0x84, 0xa0, 0x74, 0x53, 0x2e, 0x68, 0x64, - 0x35, 0x0f, 0x3c, 0x81, 0x48, 0x48, 0x13, 0xce, 0x97, 0x04, 0xa5, 0xcb, 0x72, 0x41, 0x37, 0x42, - 0x9a, 0x79, 0xc9, 0x37, 0xd5, 0x57, 0x0d, 0x0f, 0xc4, 0x29, 0x41, 0x29, 0xb2, 0x4b, 0xbc, 0xea, - 0xa1, 0xb7, 0x10, 0x33, 0xad, 0xd9, 0x18, 0x98, 0x33, 0x82, 0xd2, 0x78, 0xff, 0x38, 0xfb, 0x33, - 0x7e, 0x76, 0x65, 0x21, 0x37, 0x52, 0x2e, 0x28, 0xb0, 0xb9, 0xc3, 0xd7, 0x90, 0x1c, 0x86, 0x46, - 0x74, 0x53, 0x8e, 0x95, 0x73, 0x78, 0xfa, 0xb7, 0xc3, 0x47, 0xee, 0x27, 0x6e, 0x44, 0x67, 0x6c, - 0x0a, 0x3f, 0xe5, 0x4d, 0x9e, 0x43, 0x5c, 0x8d, 0x86, 0x77, 0xc1, 0x63, 0x4d, 0x50, 0x9a, 0xd8, - 0x3d, 0x4e, 0x74, 0x48, 0xb1, 0x86, 0x33, 0x77, 0xb8, 0x7b, 0x07, 0x70, 0x0c, 0x83, 0xf7, 0xb0, - 0x72, 0x72, 0xb7, 0x45, 0x64, 0x99, 0xc6, 0xfb, 0x47, 0xff, 0x88, 0x1e, 0xfe, 0x3a, 0x0d, 0xe4, - 0xae, 0x80, 0xe4, 0xf7, 0x30, 0x0f, 0xf1, 0x98, 0xf8, 0xd9, 0xe3, 0x13, 0x6c, 0x26, 0x0d, 0x9f, - 0xc3, 0xf2, 0xc0, 0x47, 0x7f, 0x89, 0xd4, 0x96, 0xf8, 0x55, 0x08, 0xeb, 0x6e, 0xed, 0xff, 0xa1, - 0xc2, 0x57, 0xbd, 0x87, 0x8b, 0x0f, 0xb2, 0x33, 0xba, 0x6f, 0xb9, 0x34, 0xcc, 0x08, 0x25, 0x6f, - 0x44, 0xa5, 0x99, 0x1e, 0x31, 0x86, 0x53, 0xc9, 0xda, 0xf0, 0x46, 0xa8, 0xab, 0xf1, 0x16, 0xd6, - 0x03, 0xd7, 0x9d, 0x50, 0xd2, 0x6d, 0x88, 0xe8, 0xd4, 0x16, 0x07, 0x20, 0x42, 0x65, 0xea, 0x9e, - 0x4b, 0xc3, 0x1b, 0xde, 0x72, 0xa3, 0x47, 0xff, 0x24, 0x8f, 0xbb, 0x8b, 0xf8, 0xda, 0x95, 0xb7, - 0x56, 0xbe, 0x45, 0x5f, 0xde, 0xd4, 0xc2, 0x7c, 0xef, 0x2b, 0x0b, 0xe4, 0x3e, 0xa7, 0xd1, 0xec, - 0x4e, 0xc8, 0x3a, 0x74, 0xb9, 0x9b, 0x7f, 0x59, 0x73, 0x99, 0x2b, 0xc3, 0x9b, 0x7c, 0x7e, 0xf2, - 0xd5, 0xca, 0x9d, 0xbc, 0xfe, 0x15, 0x00, 0x00, 0xff, 0xff, 0x70, 0x1d, 0x25, 0xcc, 0x06, 0x03, - 0x00, 0x00, + // 485 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0xcb, 0x6e, 0xd3, 0x40, + 0x14, 0xcd, 0x24, 0x6d, 0x1e, 0xd7, 0x41, 0xaa, 0x46, 0xa8, 0x8a, 0x10, 0x05, 0x13, 0x36, 0xde, + 0x60, 0x93, 0xb0, 0xa9, 0xd8, 0x40, 0x92, 0x4d, 0x10, 0x08, 0x2a, 0x83, 0xba, 0x60, 0x13, 0xd9, + 0xc9, 0x55, 0x18, 0x6a, 0xcf, 0x58, 0xe3, 0xb1, 0x25, 0x7f, 0x03, 0x7f, 0xc2, 0x27, 0xf0, 0x01, + 0x7c, 0x17, 0x9a, 0x47, 0x9c, 0x0a, 0x10, 0x74, 0x77, 0xef, 0xb9, 0xe7, 0x9e, 0x73, 0xec, 0x99, + 0x81, 0xf3, 0xad, 0xc8, 0x73, 0xc1, 0xa3, 0x7a, 0x16, 0xd9, 0x2a, 0x2c, 0xa4, 0x50, 0x82, 0x9e, + 0x7d, 0x4d, 0x70, 0x8f, 0x32, 0x74, 0x60, 0x3d, 0x9b, 0xfe, 0xec, 0xc2, 0x70, 0xc1, 0x9b, 0xeb, + 0x24, 0xab, 0x90, 0x3e, 0x85, 0x71, 0xa9, 0x24, 0xe3, 0xfb, 0x4d, 0xad, 0xfb, 0x09, 0xf1, 0x49, + 0x30, 0x5a, 0x77, 0x62, 0xcf, 0xa2, 0x96, 0xf4, 0x18, 0x20, 0x15, 0x22, 0x73, 0x94, 0xae, 0x4f, + 0x82, 0xe1, 0xba, 0x13, 0x8f, 0x34, 0x66, 0x09, 0x17, 0x30, 0x62, 0x5c, 0xb9, 0x79, 0xcf, 0x27, + 0x41, 0x6f, 0xdd, 0x89, 0x87, 0x8c, 0xab, 0xd6, 0x64, 0x27, 0xaa, 0x34, 0x43, 0xc7, 0x38, 0xf1, + 0x49, 0x40, 0xb4, 0x89, 0x45, 0x2d, 0xe9, 0x15, 0x78, 0x89, 0x94, 0x49, 0xe3, 0x38, 0xa7, 0x3e, + 0x09, 0xbc, 0xf9, 0xc3, 0xf0, 0xf7, 0xf8, 0xe1, 0x42, 0x93, 0xcc, 0xca, 0xba, 0x13, 0x43, 0xd2, + 0x76, 0x74, 0x05, 0xe3, 0x9b, 0x3a, 0x63, 0xe5, 0x21, 0x47, 0xdf, 0x28, 0x3c, 0xfa, 0x53, 0xe1, + 0x2d, 0xda, 0x8d, 0x77, 0xac, 0x54, 0x3a, 0x85, 0xdd, 0xb2, 0x22, 0x4f, 0xc0, 0x4b, 0x1b, 0x85, + 0xa5, 0xd3, 0x18, 0xf8, 0x24, 0x18, 0x6b, 0x1f, 0x03, 0x1a, 0xca, 0x72, 0x00, 0xa7, 0x66, 0x38, + 0x7d, 0x0d, 0x70, 0x0c, 0x43, 0xe7, 0xd0, 0x37, 0x70, 0x39, 0x21, 0x7e, 0x2f, 0xf0, 0xe6, 0x0f, + 0xfe, 0x12, 0xdd, 0xfd, 0xf5, 0xd8, 0x31, 0xa7, 0x4b, 0x18, 0xdf, 0x0e, 0x73, 0x17, 0x8d, 0x03, + 0xbf, 0xd5, 0x78, 0x0f, 0xc3, 0x03, 0x46, 0xcf, 0xa0, 0x77, 0x83, 0x8d, 0x3d, 0xc4, 0x58, 0x97, + 0xf4, 0xb9, 0x0b, 0x6b, 0x4e, 0xed, 0xdf, 0xa1, 0xdc, 0x57, 0xfd, 0x20, 0x70, 0xff, 0x0d, 0x2f, + 0x95, 0xac, 0x72, 0xe4, 0x2a, 0x51, 0x4c, 0xf0, 0x8f, 0x5b, 0x51, 0x20, 0xa5, 0x70, 0xc2, 0x93, + 0xdc, 0x5d, 0x91, 0xd8, 0xd4, 0x74, 0x02, 0x83, 0x1a, 0x65, 0xc9, 0x04, 0x37, 0x06, 0xa3, 0xf8, + 0xd0, 0xd2, 0x97, 0x00, 0x89, 0x52, 0x92, 0xa5, 0x95, 0xc2, 0x72, 0xd2, 0xfb, 0xef, 0xe7, 0xdc, + 0x62, 0xd3, 0x4b, 0x98, 0xec, 0xa4, 0x28, 0x0a, 0xdc, 0x6d, 0x8e, 0xe8, 0x66, 0x2b, 0x2a, 0xae, + 0xcc, 0xdd, 0xb9, 0x17, 0x9f, 0xbb, 0xf9, 0xa2, 0x1d, 0xaf, 0xf4, 0x74, 0xf9, 0x8d, 0x80, 0xcf, + 0x44, 0x28, 0x0a, 0xe4, 0x0a, 0x33, 0xcc, 0x51, 0xc9, 0xc6, 0x3e, 0x84, 0xa3, 0xe7, 0xd2, 0x5b, + 0x99, 0xf2, 0x4a, 0xc3, 0x57, 0xe4, 0xf3, 0xe5, 0x9e, 0xa9, 0x2f, 0x55, 0xaa, 0x09, 0x91, 0xcd, + 0xa7, 0x64, 0xb2, 0x65, 0x7c, 0xef, 0xba, 0xc8, 0xec, 0x3f, 0xdb, 0x23, 0x8f, 0x84, 0xc2, 0x2c, + 0x6a, 0x1f, 0xda, 0xf7, 0xee, 0xc5, 0x87, 0x02, 0xf9, 0xa7, 0xd6, 0xc8, 0x28, 0x86, 0x56, 0x3d, + 0xbc, 0x9e, 0xa5, 0x7d, 0xb3, 0xf9, 0xe2, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, 0xae, 0x68, 0xa0, + 0xac, 0x9c, 0x03, 0x00, 0x00, } diff --git a/proto-gen/otel/resource/v1/resource.pb.go b/proto-gen/otel/resource/v1/resource.pb.go index 956dd9b8384..bcbde34f821 100644 --- a/proto-gen/otel/resource/v1/resource.pb.go +++ b/proto-gen/otel/resource/v1/resource.pb.go @@ -80,20 +80,21 @@ func init() { func init() { proto.RegisterFile("resource/v1/resource.proto", fileDescriptor_cebae6241f1ea243) } var fileDescriptor_cebae6241f1ea243 = []byte{ - // 230 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0x90, 0x31, 0x4f, 0xc3, 0x30, - 0x10, 0x85, 0x15, 0x90, 0x10, 0x32, 0xea, 0x92, 0xa1, 0x8a, 0x32, 0x55, 0x9d, 0xba, 0x60, 0x2b, - 0xb0, 0xa0, 0x6e, 0x94, 0x91, 0xa5, 0xca, 0xc0, 0xc0, 0x52, 0x25, 0xe9, 0xc9, 0x18, 0x25, 0x3e, - 0x73, 0x3d, 0x47, 0xea, 0xc6, 0x4f, 0x47, 0xae, 0xdd, 0x90, 0xed, 0x7c, 0xdf, 0xf3, 0xd3, 0x67, - 0x8b, 0x92, 0xe0, 0x84, 0x9e, 0x3a, 0x50, 0x63, 0xa5, 0xae, 0xb3, 0x74, 0x84, 0x8c, 0x79, 0xfe, - 0xdd, 0x80, 0x06, 0x92, 0xd3, 0x7a, 0xac, 0xca, 0x65, 0x87, 0xc3, 0x80, 0x36, 0xa4, 0xe3, 0x14, - 0xb3, 0xeb, 0xdf, 0x4c, 0xdc, 0xd7, 0x29, 0x97, 0x6f, 0x85, 0x68, 0x98, 0xc9, 0xb4, 0x9e, 0xe1, - 0x54, 0x64, 0xab, 0xdb, 0xcd, 0xc3, 0x53, 0x29, 0x53, 0x5b, 0xba, 0x36, 0x56, 0xf2, 0x1d, 0xce, - 0x1f, 0x4d, 0xef, 0xa1, 0x9e, 0xa5, 0xf3, 0x17, 0x51, 0x1c, 0x09, 0x9d, 0x83, 0xe3, 0xe1, 0x7f, - 0x7b, 0xe8, 0xd0, 0x5b, 0x2e, 0x6e, 0x56, 0xd9, 0x66, 0x51, 0x2f, 0x13, 0x7f, 0x9d, 0xf0, 0x5b, - 0xa0, 0xbb, 0x1f, 0xb1, 0x36, 0x28, 0xd1, 0x81, 0x65, 0xe8, 0x61, 0x00, 0xa6, 0x73, 0x94, 0x9b, - 0x3f, 0x60, 0xb7, 0xb8, 0x5a, 0xee, 0x03, 0xda, 0x67, 0x9f, 0x5b, 0x6d, 0xf8, 0xcb, 0xb7, 0xc1, - 0x4b, 0x45, 0x45, 0xa6, 0xa6, 0x33, 0x56, 0xa7, 0x93, 0xba, 0x74, 0x3c, 0x6a, 0xb0, 0x0a, 0x19, - 0x7a, 0x35, 0xfb, 0xb0, 0xf6, 0xee, 0xc2, 0x9e, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x8b, 0x35, - 0xea, 0x1b, 0x46, 0x01, 0x00, 0x00, + // 252 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0x90, 0xb1, 0x4e, 0xc3, 0x30, + 0x10, 0x86, 0xe5, 0x22, 0x21, 0x64, 0xd4, 0x25, 0x43, 0x15, 0x65, 0xa1, 0xea, 0xd4, 0x05, 0x5b, + 0x81, 0x05, 0x75, 0xa3, 0x8c, 0x0c, 0x54, 0x11, 0xea, 0xc0, 0x52, 0x25, 0xe9, 0x29, 0x04, 0x25, + 0x3e, 0xeb, 0x7a, 0x8e, 0x94, 0x8d, 0x77, 0xe0, 0x2d, 0x78, 0x4a, 0x94, 0xc4, 0x09, 0xd9, 0xce, + 0xf7, 0xff, 0xf7, 0xdf, 0xe7, 0x93, 0x11, 0xc1, 0x05, 0x1d, 0xe5, 0xa0, 0x9b, 0x58, 0x8f, 0xb5, + 0xb2, 0x84, 0x8c, 0x41, 0xf0, 0x95, 0x42, 0x01, 0xa4, 0xa6, 0x76, 0x13, 0x47, 0xab, 0x1c, 0xeb, + 0x1a, 0x4d, 0xe7, 0x1e, 0xaa, 0xc1, 0xbb, 0xf9, 0x16, 0xf2, 0x26, 0xf1, 0xbe, 0x60, 0x27, 0x65, + 0xca, 0x4c, 0x65, 0xe6, 0x18, 0x2e, 0xa1, 0x58, 0x5f, 0x6d, 0x6f, 0x1f, 0x22, 0xe5, 0xd3, 0xfc, + 0x58, 0x13, 0xab, 0x57, 0x68, 0x8f, 0x69, 0xe5, 0x20, 0x99, 0xb9, 0x83, 0x27, 0x19, 0x9e, 0x09, + 0xad, 0x85, 0xf3, 0xe9, 0xbf, 0x7b, 0xca, 0xd1, 0x19, 0x0e, 0x17, 0x6b, 0xb1, 0x5d, 0x26, 0x2b, + 0xaf, 0x3f, 0x4f, 0xf2, 0x4b, 0xa7, 0xee, 0x7f, 0x84, 0xdc, 0x94, 0xa8, 0xd0, 0x82, 0x61, 0xa8, + 0xa0, 0x06, 0xa6, 0x76, 0xa0, 0x9b, 0xff, 0x60, 0xbf, 0x1c, 0x31, 0x0f, 0x9d, 0x74, 0x10, 0x1f, + 0xbb, 0xa2, 0xe4, 0x4f, 0x97, 0x75, 0x60, 0x7a, 0x60, 0x64, 0x4a, 0xf3, 0xd2, 0x14, 0xfe, 0xa5, + 0xfb, 0x8c, 0xfb, 0x02, 0x8c, 0x46, 0x86, 0x4a, 0xcf, 0x2e, 0xf6, 0xbb, 0xb8, 0x7b, 0xb3, 0x60, + 0xde, 0xa7, 0x75, 0x7d, 0xa6, 0x1a, 0x37, 0xa8, 0x63, 0x9c, 0x5d, 0xf7, 0xd3, 0x8f, 0x7f, 0x01, + 0x00, 0x00, 0xff, 0xff, 0x55, 0x91, 0xb4, 0x1d, 0x69, 0x01, 0x00, 0x00, } diff --git a/proto-gen/otel/trace/v1/trace.pb.go b/proto-gen/otel/trace/v1/trace.pb.go index 9b8ea6259fb..e4cf6a6ba67 100644 --- a/proto-gen/otel/trace/v1/trace.pb.go +++ b/proto-gen/otel/trace/v1/trace.pb.go @@ -82,8 +82,8 @@ type Status_StatusCode int32 const ( // The default status. Status_STATUS_CODE_UNSET Status_StatusCode = 0 - // The Span has been validated by an Application developers or Operator to have - // completed successfully. + // The Span has been validated by an Application developer or Operator to + // have completed successfully. Status_STATUS_CODE_OK Status_StatusCode = 1 // The Span contains an error. Status_STATUS_CODE_ERROR Status_StatusCode = 2 @@ -162,16 +162,15 @@ func (m *TracesData) GetResourceSpans() []*ResourceSpans { return nil } -// A collection of InstrumentationLibrarySpans from a Resource. +// A collection of ScopeSpans from a Resource. type ResourceSpans struct { // The resource for the spans in this message. // If this field is not set then no resource info is known. Resource *v1.Resource `protobuf:"bytes,1,opt,name=resource,proto3" json:"resource,omitempty"` - // A list of InstrumentationLibrarySpans that originate from a resource. - InstrumentationLibrarySpans []*InstrumentationLibrarySpans `protobuf:"bytes,2,rep,name=instrumentation_library_spans,json=instrumentationLibrarySpans,proto3" json:"instrumentation_library_spans,omitempty"` + // A list of ScopeSpans that originate from a resource. + ScopeSpans []*ScopeSpans `protobuf:"bytes,2,rep,name=scope_spans,json=scopeSpans,proto3" json:"scope_spans,omitempty"` // This schema_url applies to the data in the "resource" field. It does not apply - // to the data in the "instrumentation_library_spans" field which have their own - // schema_url field. + // to the data in the "scope_spans" field which have their own schema_url field. SchemaUrl string `protobuf:"bytes,3,opt,name=schema_url,json=schemaUrl,proto3" json:"schema_url,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -209,9 +208,9 @@ func (m *ResourceSpans) GetResource() *v1.Resource { return nil } -func (m *ResourceSpans) GetInstrumentationLibrarySpans() []*InstrumentationLibrarySpans { +func (m *ResourceSpans) GetScopeSpans() []*ScopeSpans { if m != nil { - return m.InstrumentationLibrarySpans + return m.ScopeSpans } return nil } @@ -223,13 +222,13 @@ func (m *ResourceSpans) GetSchemaUrl() string { return "" } -// A collection of Spans produced by an InstrumentationLibrary. -type InstrumentationLibrarySpans struct { - // The instrumentation library information for the spans in this message. - // Semantically when InstrumentationLibrary isn't set, it is equivalent with - // an empty instrumentation library name (unknown). - InstrumentationLibrary *v11.InstrumentationLibrary `protobuf:"bytes,1,opt,name=instrumentation_library,json=instrumentationLibrary,proto3" json:"instrumentation_library,omitempty"` - // A list of Spans that originate from an instrumentation library. +// A collection of Spans produced by an InstrumentationScope. +type ScopeSpans struct { + // The instrumentation scope information for the spans in this message. + // Semantically when InstrumentationScope isn't set, it is equivalent with + // an empty instrumentation scope name (unknown). + Scope *v11.InstrumentationScope `protobuf:"bytes,1,opt,name=scope,proto3" json:"scope,omitempty"` + // A list of Spans that originate from an instrumentation scope. Spans []*Span `protobuf:"bytes,2,rep,name=spans,proto3" json:"spans,omitempty"` // This schema_url applies to all spans and span events in the "spans" field. SchemaUrl string `protobuf:"bytes,3,opt,name=schema_url,json=schemaUrl,proto3" json:"schema_url,omitempty"` @@ -238,76 +237,66 @@ type InstrumentationLibrarySpans struct { XXX_sizecache int32 `json:"-"` } -func (m *InstrumentationLibrarySpans) Reset() { *m = InstrumentationLibrarySpans{} } -func (m *InstrumentationLibrarySpans) String() string { return proto.CompactTextString(m) } -func (*InstrumentationLibrarySpans) ProtoMessage() {} -func (*InstrumentationLibrarySpans) Descriptor() ([]byte, []int) { +func (m *ScopeSpans) Reset() { *m = ScopeSpans{} } +func (m *ScopeSpans) String() string { return proto.CompactTextString(m) } +func (*ScopeSpans) ProtoMessage() {} +func (*ScopeSpans) Descriptor() ([]byte, []int) { return fileDescriptor_a52825641200f25e, []int{2} } -func (m *InstrumentationLibrarySpans) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_InstrumentationLibrarySpans.Unmarshal(m, b) +func (m *ScopeSpans) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ScopeSpans.Unmarshal(m, b) } -func (m *InstrumentationLibrarySpans) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_InstrumentationLibrarySpans.Marshal(b, m, deterministic) +func (m *ScopeSpans) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ScopeSpans.Marshal(b, m, deterministic) } -func (m *InstrumentationLibrarySpans) XXX_Merge(src proto.Message) { - xxx_messageInfo_InstrumentationLibrarySpans.Merge(m, src) +func (m *ScopeSpans) XXX_Merge(src proto.Message) { + xxx_messageInfo_ScopeSpans.Merge(m, src) } -func (m *InstrumentationLibrarySpans) XXX_Size() int { - return xxx_messageInfo_InstrumentationLibrarySpans.Size(m) +func (m *ScopeSpans) XXX_Size() int { + return xxx_messageInfo_ScopeSpans.Size(m) } -func (m *InstrumentationLibrarySpans) XXX_DiscardUnknown() { - xxx_messageInfo_InstrumentationLibrarySpans.DiscardUnknown(m) +func (m *ScopeSpans) XXX_DiscardUnknown() { + xxx_messageInfo_ScopeSpans.DiscardUnknown(m) } -var xxx_messageInfo_InstrumentationLibrarySpans proto.InternalMessageInfo +var xxx_messageInfo_ScopeSpans proto.InternalMessageInfo -func (m *InstrumentationLibrarySpans) GetInstrumentationLibrary() *v11.InstrumentationLibrary { +func (m *ScopeSpans) GetScope() *v11.InstrumentationScope { if m != nil { - return m.InstrumentationLibrary + return m.Scope } return nil } -func (m *InstrumentationLibrarySpans) GetSpans() []*Span { +func (m *ScopeSpans) GetSpans() []*Span { if m != nil { return m.Spans } return nil } -func (m *InstrumentationLibrarySpans) GetSchemaUrl() string { +func (m *ScopeSpans) GetSchemaUrl() string { if m != nil { return m.SchemaUrl } return "" } -// Span represents a single operation within a trace. Spans can be -// nested to form a trace tree. Spans may also be linked to other spans -// from the same or different trace and form graphs. Often, a trace -// contains a root span that describes the end-to-end latency, and one -// or more subspans for its sub-operations. A trace can also contain -// multiple root spans, or none at all. Spans do not need to be -// contiguous - there may be gaps or overlaps between spans in a trace. +// A Span represents a single operation performed by a single component of the system. // // The next available field id is 17. type Span struct { // A unique identifier for a trace. All spans from the same trace share - // the same `trace_id`. The ID is a 16-byte array. An ID with all zeroes - // is considered invalid. - // - // This field is semantically required. Receiver should generate new - // random trace_id if empty or invalid trace_id was received. + // the same `trace_id`. The ID is a 16-byte array. An ID with all zeroes OR + // of length other than 16 bytes is considered invalid (empty string in OTLP/JSON + // is zero-length and thus is also invalid). // // This field is required. TraceId []byte `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"` // A unique identifier for a span within a trace, assigned when the span - // is created. The ID is an 8-byte array. An ID with all zeroes is considered - // invalid. - // - // This field is semantically required. Receiver should generate new - // random span_id if empty or invalid span_id was received. + // is created. The ID is an 8-byte array. An ID with all zeroes OR of length + // other than 8 bytes is considered invalid (empty string in OTLP/JSON + // is zero-length and thus is also invalid). // // This field is required. SpanId []byte `protobuf:"bytes,2,opt,name=span_id,json=spanId,proto3" json:"span_id,omitempty"` @@ -353,11 +342,11 @@ type Span struct { // // "/http/user_agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36" // "/http/server_latency": 300 - // "abc.com/myattribute": true - // "abc.com/score": 10.239 + // "example.com/myattribute": true + // "example.com/score": 10.239 // // The OpenTelemetry API specification further restricts the allowed value types: - // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/common/common.md#attributes + // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/common/README.md#attribute // Attribute keys MUST be unique (it is not allowed to have more than one // attribute with the same key). Attributes []*v11.KeyValue `protobuf:"bytes,9,rep,name=attributes,proto3" json:"attributes,omitempty"` @@ -723,7 +712,7 @@ func init() { proto.RegisterEnum("jaeger.trace.v1.Status_StatusCode", Status_StatusCode_name, Status_StatusCode_value) proto.RegisterType((*TracesData)(nil), "jaeger.trace.v1.TracesData") proto.RegisterType((*ResourceSpans)(nil), "jaeger.trace.v1.ResourceSpans") - proto.RegisterType((*InstrumentationLibrarySpans)(nil), "jaeger.trace.v1.InstrumentationLibrarySpans") + proto.RegisterType((*ScopeSpans)(nil), "jaeger.trace.v1.ScopeSpans") proto.RegisterType((*Span)(nil), "jaeger.trace.v1.Span") proto.RegisterType((*Span_Event)(nil), "jaeger.trace.v1.Span.Event") proto.RegisterType((*Span_Link)(nil), "jaeger.trace.v1.Span.Link") @@ -733,60 +722,62 @@ func init() { func init() { proto.RegisterFile("trace/v1/trace.proto", fileDescriptor_a52825641200f25e) } var fileDescriptor_a52825641200f25e = []byte{ - // 874 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x4d, 0x6f, 0xe3, 0x36, - 0x10, 0x5d, 0x3a, 0xb2, 0xe3, 0x4c, 0x12, 0x47, 0x61, 0xf3, 0xa1, 0x75, 0xba, 0x5d, 0xc3, 0xe8, - 0xc1, 0xc0, 0xb6, 0xf6, 0x6e, 0x16, 0x68, 0x17, 0xbd, 0x65, 0x6d, 0x15, 0x70, 0x93, 0xca, 0x06, - 0x65, 0xef, 0xa1, 0x17, 0x81, 0xb1, 0x08, 0x87, 0x8d, 0x45, 0x19, 0x12, 0x15, 0x6c, 0x7e, 0x4a, - 0xff, 0x45, 0x6f, 0x3d, 0xf7, 0xde, 0x4b, 0xaf, 0xfd, 0x35, 0x05, 0x49, 0x29, 0xb1, 0xf2, 0xd5, - 0x4b, 0x7a, 0x49, 0xc8, 0xf7, 0xde, 0xcc, 0xbc, 0xd1, 0x8c, 0x20, 0xc3, 0x9e, 0x4c, 0xe8, 0x8c, - 0xf5, 0xae, 0xde, 0xf5, 0xf4, 0xa1, 0xbb, 0x4c, 0x62, 0x19, 0xe3, 0x9d, 0x5f, 0x29, 0x9b, 0xb3, - 0xa4, 0x6b, 0xb0, 0xab, 0x77, 0xcd, 0x83, 0x59, 0x1c, 0x45, 0xb1, 0x50, 0x3a, 0x73, 0x32, 0xc2, - 0x66, 0x33, 0x61, 0x69, 0x9c, 0x25, 0x26, 0x43, 0x71, 0x36, 0x5c, 0xdb, 0x07, 0x98, 0xa8, 0xf8, - 0x74, 0x40, 0x25, 0xc5, 0x2e, 0x34, 0x0a, 0x3e, 0x48, 0x97, 0x54, 0xa4, 0x0e, 0x6a, 0xad, 0x75, - 0x36, 0x8f, 0xbf, 0xea, 0xde, 0xa9, 0xd5, 0x25, 0xb9, 0xcc, 0x57, 0x2a, 0xb2, 0x9d, 0xac, 0x5e, - 0xdb, 0xff, 0x20, 0xd8, 0x2e, 0x09, 0xf0, 0x07, 0xa8, 0x17, 0x12, 0x07, 0xb5, 0x50, 0x67, 0xf3, - 0xf8, 0xcb, 0x22, 0xe5, 0x8d, 0xa1, 0x95, 0xac, 0xe4, 0x46, 0x8d, 0x97, 0xf0, 0x8a, 0x8b, 0x54, - 0x26, 0x59, 0xc4, 0x84, 0xa4, 0x92, 0xc7, 0x22, 0x58, 0xf0, 0xf3, 0x84, 0x26, 0xd7, 0xb9, 0xc3, - 0x8a, 0x76, 0xf8, 0xcd, 0x3d, 0x87, 0xc3, 0x72, 0xd4, 0x99, 0x09, 0x32, 0x7e, 0x8f, 0xf8, 0xe3, - 0x24, 0x7e, 0x05, 0x90, 0xce, 0x2e, 0x58, 0x44, 0x83, 0x2c, 0x59, 0x38, 0x6b, 0x2d, 0xd4, 0xd9, - 0x20, 0x1b, 0x06, 0x99, 0x26, 0x8b, 0xf6, 0x5f, 0x08, 0x8e, 0x9e, 0xc8, 0x8d, 0x29, 0x1c, 0x3e, - 0x62, 0x38, 0xef, 0xbc, 0x53, 0x58, 0xcd, 0x87, 0xf4, 0xa8, 0x57, 0x72, 0xf0, 0xb0, 0x4d, 0xfc, - 0x06, 0xaa, 0xab, 0xbd, 0xef, 0xdf, 0xeb, 0x5d, 0x39, 0x21, 0x46, 0xf3, 0x5f, 0xed, 0xfc, 0xb9, - 0x01, 0x96, 0x92, 0xe3, 0x97, 0x50, 0xd7, 0xf1, 0x01, 0x0f, 0xb5, 0xd1, 0x2d, 0xb2, 0xae, 0xef, - 0xc3, 0x10, 0x1f, 0xc2, 0xba, 0xca, 0xa5, 0x98, 0x8a, 0x66, 0x6a, 0xea, 0x3a, 0x0c, 0xf1, 0x6b, - 0xd8, 0x34, 0x31, 0xa9, 0xa4, 0x92, 0xe5, 0xc9, 0x41, 0x43, 0xbe, 0x42, 0xf0, 0xd7, 0xd0, 0x58, - 0xd2, 0x84, 0x09, 0x19, 0x14, 0x09, 0x2c, 0x9d, 0x60, 0xcb, 0xa0, 0xbe, 0x49, 0x83, 0xc1, 0x12, - 0x34, 0x62, 0x4e, 0x55, 0xc7, 0xeb, 0x33, 0x3e, 0x06, 0xeb, 0x92, 0x8b, 0xd0, 0xa9, 0xb5, 0x50, - 0xa7, 0xf1, 0xc0, 0x02, 0xaa, 0x50, 0xfd, 0xe7, 0x94, 0x8b, 0x90, 0x68, 0x2d, 0xee, 0xc1, 0x5e, - 0x2a, 0x69, 0x22, 0x03, 0xc9, 0x23, 0x16, 0x64, 0x82, 0x7f, 0x0e, 0x04, 0x15, 0xb1, 0xb3, 0xde, - 0x42, 0x9d, 0x1a, 0xd9, 0xd5, 0xdc, 0x84, 0x47, 0x6c, 0x2a, 0xf8, 0x67, 0x8f, 0x8a, 0x18, 0xbf, - 0x01, 0xcc, 0x44, 0x78, 0x57, 0x5e, 0xd7, 0xf2, 0x1d, 0x26, 0xc2, 0x92, 0xf8, 0x07, 0x00, 0x2a, - 0x65, 0xc2, 0xcf, 0x33, 0xc9, 0x52, 0x67, 0x43, 0x3f, 0xfa, 0xe6, 0xfd, 0x59, 0x9e, 0xb2, 0xeb, - 0x4f, 0x74, 0x91, 0x31, 0xb2, 0xa2, 0xc6, 0x1f, 0xc0, 0x09, 0x93, 0x78, 0xb9, 0x64, 0x61, 0x70, - 0x8b, 0x06, 0xb3, 0x38, 0x13, 0xd2, 0x81, 0x16, 0xea, 0x6c, 0x93, 0x83, 0x9c, 0x3f, 0xb9, 0xa1, - 0xfb, 0x8a, 0xc5, 0xef, 0xa1, 0xc6, 0xae, 0x98, 0x90, 0xa9, 0xb3, 0xa9, 0x2b, 0x1e, 0x3d, 0xfc, - 0x24, 0x5c, 0xa5, 0x21, 0xb9, 0x14, 0xbf, 0x85, 0xbd, 0xa2, 0x9c, 0x41, 0xf2, 0x52, 0x5b, 0xba, - 0x14, 0xce, 0x39, 0x1d, 0x93, 0x97, 0x79, 0x0b, 0xd5, 0x05, 0x17, 0x97, 0xa9, 0xb3, 0x5d, 0xee, - 0xab, 0x5c, 0xe5, 0x8c, 0x8b, 0x4b, 0x62, 0x84, 0xb8, 0x0b, 0x5f, 0x14, 0x35, 0x34, 0x90, 0x97, - 0x68, 0xe8, 0x12, 0xbb, 0x39, 0xa5, 0x02, 0xf2, 0x0a, 0x3d, 0xa8, 0xa9, 0x2d, 0xc9, 0x52, 0x67, - 0x47, 0xbf, 0x06, 0x87, 0xf7, 0x4b, 0x68, 0x9a, 0xe4, 0xb2, 0xe6, 0x1f, 0x08, 0xaa, 0xda, 0xa2, - 0xda, 0xa2, 0x3b, 0x23, 0x42, 0x7a, 0x44, 0x5b, 0x72, 0x75, 0x3e, 0xc5, 0x16, 0x55, 0x56, 0xb6, - 0xa8, 0x3c, 0xb3, 0xb5, 0x67, 0x9b, 0x99, 0xf5, 0xd4, 0xcc, 0x9a, 0x7f, 0x23, 0xb0, 0x54, 0xe7, - 0xff, 0xcf, 0x3b, 0x55, 0xee, 0xc9, 0x7a, 0xb6, 0x9e, 0xaa, 0x4f, 0xf5, 0xd4, 0xfe, 0x0d, 0x41, - 0xbd, 0x78, 0xdd, 0xf0, 0x4b, 0xd8, 0xf7, 0xc7, 0x27, 0x5e, 0x70, 0x3a, 0xf4, 0x06, 0xc1, 0xd4, - 0xf3, 0xc7, 0x6e, 0x7f, 0xf8, 0xe3, 0xd0, 0x1d, 0xd8, 0x2f, 0xf0, 0x01, 0xe0, 0x5b, 0x6a, 0xe8, - 0x4d, 0x5c, 0xe2, 0x9d, 0x9c, 0xd9, 0x08, 0xef, 0x81, 0x7d, 0x8b, 0xfb, 0x2e, 0xf9, 0xe4, 0x12, - 0xbb, 0x52, 0x46, 0xfb, 0x67, 0x43, 0xd7, 0x9b, 0xd8, 0x6b, 0xe5, 0x1c, 0x63, 0x32, 0x1a, 0x4c, - 0xfb, 0x2e, 0xb1, 0xad, 0x32, 0xde, 0x1f, 0x79, 0xfe, 0xf4, 0x67, 0x97, 0xd8, 0xd5, 0xf6, 0xef, - 0x08, 0x6a, 0x66, 0x79, 0xb0, 0x03, 0xeb, 0x11, 0x4b, 0x53, 0x3a, 0x2f, 0xf6, 0xa0, 0xb8, 0xe2, - 0xef, 0xc0, 0x9a, 0xc5, 0xa1, 0x79, 0xa0, 0x8d, 0xe3, 0xf6, 0x23, 0xdb, 0x97, 0xff, 0xeb, 0xc7, - 0x21, 0x23, 0x5a, 0xdf, 0xf6, 0x00, 0x6e, 0x31, 0xbc, 0x0f, 0xbb, 0xfe, 0xe4, 0x64, 0x32, 0xf5, - 0x83, 0xfe, 0x68, 0xe0, 0xaa, 0xde, 0xdd, 0x89, 0xfd, 0x02, 0x63, 0x68, 0xac, 0xc2, 0xa3, 0x53, - 0x1b, 0xdd, 0x95, 0xba, 0x84, 0x8c, 0x88, 0x5d, 0xf9, 0xc9, 0xaa, 0x23, 0xbb, 0xf2, 0xf1, 0x02, - 0x5e, 0xf3, 0xb8, 0x1b, 0x2f, 0x99, 0x90, 0x6c, 0xc1, 0x22, 0x26, 0x93, 0x6b, 0xf3, 0x45, 0xbe, - 0x31, 0xf4, 0xd1, 0x7c, 0x98, 0xc7, 0x0a, 0x1c, 0xa3, 0x5f, 0xbe, 0x9f, 0x73, 0x79, 0x91, 0x9d, - 0xab, 0x01, 0xf7, 0x8c, 0x75, 0x25, 0xe4, 0x62, 0x9e, 0xdf, 0x7a, 0x3a, 0xfa, 0xdb, 0x39, 0x13, - 0xbd, 0x58, 0xb2, 0x45, 0xaf, 0xf8, 0xc9, 0x70, 0x5e, 0xd3, 0xc4, 0xfb, 0x7f, 0x03, 0x00, 0x00, - 0xff, 0xff, 0x27, 0xd9, 0xff, 0x6c, 0x45, 0x08, 0x00, 0x00, + // 898 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xdd, 0x6e, 0xdb, 0x36, + 0x14, 0x2e, 0x1d, 0xf9, 0x27, 0xc7, 0x89, 0xa3, 0x70, 0x49, 0xaa, 0x7a, 0xdd, 0x6a, 0x18, 0xc3, + 0x60, 0xa0, 0x98, 0xdc, 0xa4, 0xc0, 0x56, 0x0c, 0xbd, 0x49, 0x6d, 0x0d, 0x70, 0x93, 0xc9, 0x06, + 0x65, 0xe7, 0x62, 0x37, 0x82, 0x62, 0x11, 0xae, 0x16, 0x8b, 0x12, 0x24, 0x2a, 0x68, 0x9f, 0x60, + 0x6f, 0x30, 0x60, 0xaf, 0xb0, 0x8b, 0x61, 0x77, 0xbb, 0xde, 0x23, 0xec, 0x2d, 0xb6, 0xb7, 0x18, + 0x48, 0x4a, 0xb6, 0x15, 0xaf, 0xdd, 0x4d, 0x7a, 0x63, 0x93, 0xdf, 0xf9, 0xce, 0xf9, 0x3e, 0xf2, + 0x1c, 0x81, 0x70, 0xc4, 0x13, 0x6f, 0x4e, 0xfb, 0xb7, 0xa7, 0x7d, 0xb9, 0x30, 0xe3, 0x24, 0xe2, + 0x11, 0x3e, 0xf8, 0xd1, 0xa3, 0x0b, 0x9a, 0x98, 0x0a, 0xbb, 0x3d, 0x6d, 0x9f, 0xcc, 0xa3, 0x30, + 0x8c, 0x98, 0xe0, 0xa9, 0x95, 0x22, 0xb6, 0xdb, 0x09, 0x4d, 0xa3, 0x2c, 0x51, 0x15, 0x8a, 0xb5, + 0x8a, 0x75, 0x1d, 0x80, 0xa9, 0xc8, 0x4f, 0x87, 0x1e, 0xf7, 0xb0, 0x05, 0xad, 0x22, 0xee, 0xa6, + 0xb1, 0xc7, 0x52, 0x03, 0x75, 0x76, 0x7a, 0xcd, 0xb3, 0xcf, 0xcd, 0x3b, 0x5a, 0x26, 0xc9, 0x69, + 0x8e, 0x60, 0x91, 0xfd, 0x64, 0x73, 0xdb, 0xfd, 0x0d, 0xc1, 0x7e, 0x89, 0x80, 0x5f, 0x40, 0xa3, + 0xa0, 0x18, 0xa8, 0x83, 0x7a, 0xcd, 0xb3, 0xc7, 0x45, 0xc9, 0x95, 0xa1, 0x8d, 0xaa, 0x64, 0xc5, + 0xc6, 0x2f, 0xa1, 0x99, 0xce, 0xa3, 0xb8, 0xf0, 0x53, 0x91, 0x7e, 0x3e, 0xdd, 0xf2, 0xe3, 0x08, + 0x8e, 0x32, 0x03, 0xe9, 0x6a, 0x8d, 0x3f, 0x03, 0x48, 0xe7, 0x6f, 0x68, 0xe8, 0xb9, 0x59, 0xb2, + 0x34, 0x76, 0x3a, 0xa8, 0xb7, 0x4b, 0x76, 0x15, 0x32, 0x4b, 0x96, 0xaf, 0x6b, 0x8d, 0xbf, 0xeb, + 0xfa, 0x3f, 0xf5, 0xee, 0xcf, 0x08, 0x60, 0x5d, 0x01, 0xbf, 0x84, 0xaa, 0xac, 0x91, 0x5b, 0xfd, + 0xb2, 0x50, 0xcb, 0x6f, 0xf5, 0xf6, 0xd4, 0x1c, 0xb1, 0x94, 0x27, 0x59, 0x48, 0x19, 0xf7, 0x78, + 0x10, 0x31, 0x99, 0x4b, 0x54, 0x12, 0x7e, 0x0a, 0xd5, 0x4d, 0xaf, 0xc7, 0xdb, 0x5e, 0x63, 0x8f, + 0x11, 0xc5, 0xf9, 0x1f, 0x83, 0xdd, 0x3f, 0x77, 0x41, 0x13, 0x74, 0xfc, 0x08, 0x1a, 0x32, 0xdf, + 0x0d, 0x7c, 0xe9, 0x6a, 0x8f, 0xd4, 0xe5, 0x7e, 0xe4, 0xe3, 0x87, 0x50, 0x17, 0xb5, 0x44, 0xa4, + 0x22, 0x23, 0x35, 0xb1, 0x1d, 0xf9, 0xf8, 0x09, 0x34, 0x55, 0x4e, 0xca, 0x3d, 0x4e, 0xf3, 0xe2, + 0x20, 0x21, 0x47, 0x20, 0xf8, 0x0b, 0x68, 0xc5, 0x5e, 0x42, 0x19, 0x77, 0x8b, 0x02, 0x9a, 0x2c, + 0xb0, 0xa7, 0x50, 0x47, 0x95, 0xc1, 0xa0, 0x31, 0x2f, 0xa4, 0x46, 0x55, 0xe6, 0xcb, 0x35, 0x3e, + 0x03, 0xed, 0x26, 0x60, 0xbe, 0x51, 0xeb, 0xa0, 0x5e, 0xeb, 0x3f, 0xc6, 0x43, 0xa4, 0xca, 0x9f, + 0x8b, 0x80, 0xf9, 0x44, 0x72, 0x71, 0x1f, 0x8e, 0x52, 0xee, 0x25, 0xdc, 0xe5, 0x41, 0x48, 0xdd, + 0x8c, 0x05, 0x6f, 0x5d, 0xe6, 0xb1, 0xc8, 0xa8, 0x77, 0x50, 0xaf, 0x46, 0x0e, 0x65, 0x6c, 0x1a, + 0x84, 0x74, 0xc6, 0x82, 0xb7, 0xb6, 0xc7, 0x22, 0xfc, 0x14, 0x30, 0x65, 0xfe, 0x5d, 0x7a, 0x43, + 0xd2, 0x0f, 0x28, 0xf3, 0x4b, 0xe4, 0x6f, 0x01, 0x3c, 0xce, 0x93, 0xe0, 0x3a, 0xe3, 0x34, 0x35, + 0x76, 0xe5, 0xd5, 0xb7, 0xb7, 0x1b, 0x77, 0x41, 0xdf, 0x5d, 0x79, 0xcb, 0x8c, 0x92, 0x0d, 0x36, + 0x7e, 0x01, 0x86, 0x9f, 0x44, 0x71, 0x4c, 0x7d, 0x77, 0x8d, 0xba, 0xf3, 0x28, 0x63, 0xdc, 0x80, + 0x0e, 0xea, 0xed, 0x93, 0x93, 0x3c, 0x7e, 0xbe, 0x0a, 0x0f, 0x44, 0x14, 0x3f, 0x87, 0x1a, 0xbd, + 0xa5, 0x8c, 0xa7, 0x46, 0xf3, 0x7d, 0x83, 0x29, 0x6e, 0xc2, 0x12, 0x1c, 0x92, 0x53, 0xf1, 0x33, + 0x38, 0x2a, 0xe4, 0x14, 0x92, 0x4b, 0xed, 0x49, 0x29, 0x9c, 0xc7, 0x64, 0x4e, 0x2e, 0xf3, 0x0c, + 0xaa, 0xcb, 0x80, 0xdd, 0xa4, 0xc6, 0x7e, 0xf9, 0x5c, 0x65, 0x95, 0xcb, 0x80, 0xdd, 0x10, 0x45, + 0xc4, 0x26, 0x7c, 0x52, 0x68, 0x48, 0x20, 0x97, 0x68, 0x49, 0x89, 0xc3, 0x3c, 0x24, 0x12, 0x72, + 0x85, 0x3e, 0xd4, 0xc4, 0x94, 0x64, 0xa9, 0x71, 0x20, 0x67, 0xfe, 0xe1, 0xb6, 0x84, 0x0c, 0x93, + 0x9c, 0xd6, 0xfe, 0x03, 0x41, 0x55, 0x5a, 0x14, 0x53, 0x74, 0xa7, 0x45, 0x48, 0xb6, 0x68, 0x8f, + 0x6f, 0xf6, 0xa7, 0x98, 0xa2, 0xca, 0xc6, 0x14, 0x95, 0x7b, 0xb6, 0x73, 0x6f, 0x3d, 0xd3, 0x3e, + 0xd4, 0xb3, 0xf6, 0x5f, 0x08, 0x34, 0x71, 0xf2, 0x8f, 0xf3, 0x4d, 0x95, 0xcf, 0xa4, 0xdd, 0xdb, + 0x99, 0xaa, 0x1f, 0x3a, 0x53, 0xf7, 0x17, 0x04, 0x8d, 0xe2, 0x73, 0xc3, 0x8f, 0xe0, 0xd8, 0x99, + 0x9c, 0xdb, 0xee, 0xc5, 0xc8, 0x1e, 0xba, 0x33, 0xdb, 0x99, 0x58, 0x83, 0xd1, 0x77, 0x23, 0x6b, + 0xa8, 0x3f, 0xc0, 0x27, 0x80, 0xd7, 0xa1, 0x91, 0x3d, 0xb5, 0x88, 0x7d, 0x7e, 0xa9, 0x23, 0x7c, + 0x04, 0xfa, 0x1a, 0x77, 0x2c, 0x72, 0x65, 0x11, 0xbd, 0x52, 0x46, 0x07, 0x97, 0x23, 0xcb, 0x9e, + 0xea, 0x3b, 0xe5, 0x1a, 0x13, 0x32, 0x1e, 0xce, 0x06, 0x16, 0xd1, 0xb5, 0x32, 0x3e, 0x18, 0xdb, + 0xce, 0xec, 0x7b, 0x8b, 0xe8, 0xd5, 0xee, 0xef, 0x08, 0x6a, 0x6a, 0x78, 0xb0, 0x01, 0xf5, 0x90, + 0xa6, 0xa9, 0xb7, 0x28, 0xe6, 0xa0, 0xd8, 0xe2, 0xaf, 0x41, 0x9b, 0x47, 0xbe, 0xba, 0xd0, 0xd6, + 0x59, 0xf7, 0x3d, 0xd3, 0x97, 0xff, 0x0d, 0x22, 0x9f, 0x12, 0xc9, 0xef, 0xda, 0x00, 0x6b, 0x0c, + 0x1f, 0xc3, 0xa1, 0x33, 0x3d, 0x9f, 0xce, 0x1c, 0x77, 0x30, 0x1e, 0x5a, 0xe2, 0xec, 0xd6, 0x54, + 0x7f, 0x80, 0x31, 0xb4, 0x36, 0xe1, 0xf1, 0x85, 0x8e, 0xee, 0x52, 0x2d, 0x42, 0xc6, 0x44, 0xaf, + 0xbc, 0xd6, 0x1a, 0x48, 0xaf, 0xbc, 0xfa, 0x09, 0xc1, 0x93, 0x20, 0x32, 0xa3, 0x98, 0x32, 0x4e, + 0x97, 0x34, 0xa4, 0x3c, 0x79, 0xa7, 0x1e, 0xcc, 0x95, 0xa3, 0x57, 0xea, 0xdd, 0x9c, 0x08, 0x70, + 0x82, 0x7e, 0xf8, 0x66, 0x11, 0xf0, 0x37, 0xd9, 0xb5, 0xe8, 0x70, 0x5f, 0x79, 0x17, 0xc4, 0x80, + 0x2d, 0xf2, 0x5d, 0x5f, 0x66, 0x7f, 0xb5, 0xa0, 0xac, 0x1f, 0x71, 0xba, 0xec, 0x17, 0x2f, 0xfa, + 0xaf, 0x95, 0xc7, 0xe3, 0x98, 0xb2, 0xe9, 0x4a, 0x45, 0x16, 0x34, 0x65, 0x6d, 0xf3, 0xea, 0xf4, + 0xba, 0x26, 0xf3, 0x9e, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xd6, 0x4c, 0xee, 0xb6, 0x03, 0x08, + 0x00, 0x00, }