From 205ad2a0ea49a845d9b96f46a6df6f1650e6d38f Mon Sep 17 00:00:00 2001 From: Tyler Yahn Date: Tue, 24 Mar 2020 20:49:23 -0700 Subject: [PATCH] Move span transforms of the OTLP exporter to internal Breakup and move functionality of the `transform_spans.go` file into appropriate files in the `internal/transform` sub-package. This is in preparation of using some of the overlapping functionality to implement Resource support in the metric side of the exporter. Adds more specific unit tests for some of the functionality transferred. The tests removed used the exporter as a processing engine and the replacement tests do not do this. The test found in the `oltp_test.go` seem to comprehensively cover this type of test. Include Link `Name` in the exporter span link and adds a test to check for this. Resolves #527 --- exporters/otlp/go.mod | 3 +- exporters/otlp/go.sum | 5 + .../otlp/internal/transform/attribute.go | 66 +++ .../otlp/internal/transform/attribute_test.go | 113 +++++ exporters/otlp/internal/transform/resource.go | 29 ++ .../otlp/internal/transform/resource_test.go | 34 ++ .../transform/span.go} | 115 ++--- .../otlp/internal/transform/span_test.go | 399 ++++++++++++++++ exporters/otlp/otlp.go | 36 +- exporters/otlp/transform_spans_test.go | 433 ------------------ 10 files changed, 697 insertions(+), 536 deletions(-) create mode 100644 exporters/otlp/internal/transform/attribute.go create mode 100644 exporters/otlp/internal/transform/attribute_test.go create mode 100644 exporters/otlp/internal/transform/resource.go create mode 100644 exporters/otlp/internal/transform/resource_test.go rename exporters/otlp/{transform_spans.go => internal/transform/span.go} (52%) create mode 100644 exporters/otlp/internal/transform/span_test.go delete mode 100644 exporters/otlp/transform_spans_test.go diff --git a/exporters/otlp/go.mod b/exporters/otlp/go.mod index cf7d087f27b..60106ee5714 100644 --- a/exporters/otlp/go.mod +++ b/exporters/otlp/go.mod @@ -3,7 +3,8 @@ module go.opentelemetry.io/otel/exporters/otlp replace go.opentelemetry.io/otel => ../.. require ( - github.com/golang/protobuf v1.3.4 + github.com/gogo/protobuf v1.3.1 + github.com/golang/protobuf v1.3.4 // indirect github.com/google/go-cmp v0.4.0 github.com/grpc-ecosystem/grpc-gateway v1.14.3 // indirect github.com/open-telemetry/opentelemetry-proto v0.3.0 diff --git a/exporters/otlp/go.sum b/exporters/otlp/go.sum index 5de50eefc27..9efdf481db6 100644 --- a/exporters/otlp/go.sum +++ b/exporters/otlp/go.sum @@ -14,6 +14,8 @@ github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= +github.com/gogo/protobuf v1.3.1 h1:DqDEcV5aeaTmdFBePNpYsp3FlcVH/2ISVVM9Qf8PSls= +github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= @@ -31,6 +33,8 @@ github.com/google/gofuzz v1.0.0 h1:A8PeW59pxE9IoFRqBp37U+mSNaQoZ46F1f0f863XSXw= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/grpc-ecosystem/grpc-gateway v1.14.3 h1:OCJlWkOUoTnl0neNGlf4fUm3TmbEtguw7vR+nGtnDjY= github.com/grpc-ecosystem/grpc-gateway v1.14.3/go.mod h1:6CwZWGDSPRJidgKAtJVvND6soZe6fT7iteq8wDPdhb0= +github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= @@ -72,6 +76,7 @@ golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= diff --git a/exporters/otlp/internal/transform/attribute.go b/exporters/otlp/internal/transform/attribute.go new file mode 100644 index 00000000000..c2dd9010d53 --- /dev/null +++ b/exporters/otlp/internal/transform/attribute.go @@ -0,0 +1,66 @@ +// Copyright The OpenTelemetry 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 transform + +import ( + commonpb "github.com/open-telemetry/opentelemetry-proto/gen/go/common/v1" + + "go.opentelemetry.io/otel/api/core" +) + +// Attributes transforms a slice of KeyValues into a slice of OTLP attribute key-values. +func Attributes(attrs []core.KeyValue) []*commonpb.AttributeKeyValue { + if len(attrs) == 0 { + return nil + } + + out := make([]*commonpb.AttributeKeyValue, 0, len(attrs)) + for _, v := range attrs { + switch v.Value.Type() { + case core.BOOL: + out = append(out, &commonpb.AttributeKeyValue{ + Key: string(v.Key), + Type: commonpb.AttributeKeyValue_BOOL, + BoolValue: v.Value.AsBool(), + }) + case core.INT64, core.INT32, core.UINT32, core.UINT64: + out = append(out, &commonpb.AttributeKeyValue{ + Key: string(v.Key), + Type: commonpb.AttributeKeyValue_INT, + IntValue: v.Value.AsInt64(), + }) + case core.FLOAT32: + f32 := v.Value.AsFloat32() + out = append(out, &commonpb.AttributeKeyValue{ + Key: string(v.Key), + Type: commonpb.AttributeKeyValue_DOUBLE, + DoubleValue: float64(f32), + }) + case core.FLOAT64: + out = append(out, &commonpb.AttributeKeyValue{ + Key: string(v.Key), + Type: commonpb.AttributeKeyValue_DOUBLE, + DoubleValue: v.Value.AsFloat64(), + }) + case core.STRING: + out = append(out, &commonpb.AttributeKeyValue{ + Key: string(v.Key), + Type: commonpb.AttributeKeyValue_STRING, + StringValue: v.Value.AsString(), + }) + } + } + return out +} diff --git a/exporters/otlp/internal/transform/attribute_test.go b/exporters/otlp/internal/transform/attribute_test.go new file mode 100644 index 00000000000..557659d5c93 --- /dev/null +++ b/exporters/otlp/internal/transform/attribute_test.go @@ -0,0 +1,113 @@ +// Copyright The OpenTelemetry 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 transform + +import ( + "testing" + + commonpb "github.com/open-telemetry/opentelemetry-proto/gen/go/common/v1" + "github.com/stretchr/testify/assert" + + "go.opentelemetry.io/otel/api/core" +) + +func TestAttributes(t *testing.T) { + for _, test := range []struct { + attrs []core.KeyValue + expected []*commonpb.AttributeKeyValue + }{ + {nil, nil}, + { + []core.KeyValue{ + core.Key("int to int").Int(123), + core.Key("uint to int").Uint(1234), + core.Key("int32 to int").Int32(12345), + core.Key("uint32 to int").Uint32(123456), + core.Key("int64 to int64").Int64(1234567), + core.Key("uint64 to int64").Uint64(12345678), + core.Key("float32 to double").Float32(3.14), + core.Key("float64 to double").Float32(1.61), + core.Key("string to string").String("string"), + core.Key("bool to bool").Bool(true), + }, + []*commonpb.AttributeKeyValue{ + { + Key: "int to int", + Type: commonpb.AttributeKeyValue_INT, + IntValue: 123, + }, + { + Key: "uint to int", + Type: commonpb.AttributeKeyValue_INT, + IntValue: 1234, + }, + { + Key: "int32 to int", + Type: commonpb.AttributeKeyValue_INT, + IntValue: 12345, + }, + { + Key: "uint32 to int", + Type: commonpb.AttributeKeyValue_INT, + IntValue: 123456, + }, + { + Key: "int64 to int64", + Type: commonpb.AttributeKeyValue_INT, + IntValue: 1234567, + }, + { + Key: "uint64 to int64", + Type: commonpb.AttributeKeyValue_INT, + IntValue: 12345678, + }, + { + Key: "float32 to double", + Type: commonpb.AttributeKeyValue_DOUBLE, + DoubleValue: 3.14, + }, + { + Key: "float64 to double", + Type: commonpb.AttributeKeyValue_DOUBLE, + DoubleValue: 1.61, + }, + { + Key: "string to string", + Type: commonpb.AttributeKeyValue_STRING, + StringValue: "string", + }, + { + Key: "bool to bool", + Type: commonpb.AttributeKeyValue_BOOL, + BoolValue: true, + }, + }, + }, + } { + got := Attributes(test.attrs) + if !assert.Len(t, got, len(test.expected)) { + continue + } + for i, actual := range got { + if actual.Type == commonpb.AttributeKeyValue_DOUBLE { + if !assert.InDelta(t, test.expected[i].DoubleValue, actual.DoubleValue, 0.01) { + continue + } + test.expected[i].DoubleValue = actual.DoubleValue + } + assert.Equal(t, test.expected[i], actual) + } + } +} diff --git a/exporters/otlp/internal/transform/resource.go b/exporters/otlp/internal/transform/resource.go new file mode 100644 index 00000000000..0dcec7da705 --- /dev/null +++ b/exporters/otlp/internal/transform/resource.go @@ -0,0 +1,29 @@ +// Copyright The OpenTelemetry 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 transform + +import ( + resourcepb "github.com/open-telemetry/opentelemetry-proto/gen/go/resource/v1" + + "go.opentelemetry.io/otel/sdk/resource" +) + +// Resource transforms a Resource into an OTLP Resource. +func Resource(r *resource.Resource) *resourcepb.Resource { + if r == nil { + return nil + } + return &resourcepb.Resource{Attributes: Attributes(r.Attributes())} +} diff --git a/exporters/otlp/internal/transform/resource_test.go b/exporters/otlp/internal/transform/resource_test.go new file mode 100644 index 00000000000..138d0223ab5 --- /dev/null +++ b/exporters/otlp/internal/transform/resource_test.go @@ -0,0 +1,34 @@ +package transform + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "go.opentelemetry.io/otel/api/core" + "go.opentelemetry.io/otel/sdk/resource" +) + +func TestNilResource(t *testing.T) { + assert.Empty(t, Resource(nil)) +} + +func TestEmptyResource(t *testing.T) { + assert.Empty(t, Resource(&resource.Resource{})) +} + +/* +* This does not include any testing on the ordering of Resource Attributes. +* They are stored as a map internally to the Resource and their order is not +* guaranteed. + */ + +func TestResourceAttributes(t *testing.T) { + attrs := []core.KeyValue{core.Key("one").Int(1), core.Key("two").Int(2)} + + got := Resource(resource.New(attrs...)).GetAttributes() + if !assert.Len(t, attrs, 2) { + return + } + assert.ElementsMatch(t, Attributes(attrs), got) +} diff --git a/exporters/otlp/transform_spans.go b/exporters/otlp/internal/transform/span.go similarity index 52% rename from exporters/otlp/transform_spans.go rename to exporters/otlp/internal/transform/span.go index e9995b7f455..e16b004a85c 100644 --- a/exporters/otlp/transform_spans.go +++ b/exporters/otlp/internal/transform/span.go @@ -1,4 +1,4 @@ -// Copyright 2020, OpenTelemetry Authors +// Copyright The OpenTelemetry Authors // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -12,37 +12,56 @@ // See the License for the specific language governing permissions and // limitations under the License. -package otlp +package transform import ( "google.golang.org/grpc/codes" - "go.opentelemetry.io/otel/sdk/resource" - - commonpb "github.com/open-telemetry/opentelemetry-proto/gen/go/common/v1" - resourcepb "github.com/open-telemetry/opentelemetry-proto/gen/go/resource/v1" tracepb "github.com/open-telemetry/opentelemetry-proto/gen/go/trace/v1" - "go.opentelemetry.io/otel/api/core" apitrace "go.opentelemetry.io/otel/api/trace" export "go.opentelemetry.io/otel/sdk/export/trace" + "go.opentelemetry.io/otel/sdk/resource" ) const ( maxMessageEventsPerSpan = 128 ) -func otResourceToProtoResource(res *resource.Resource) *resourcepb.Resource { - if res == nil { +// Attributes transforms a slice of KeyValues into a slice of OTLP attribute key-values. +func SpanData(sdl []*export.SpanData) []*tracepb.ResourceSpans { + if len(sdl) == 0 { return nil } - resProto := &resourcepb.Resource{ - Attributes: otAttributesToProtoAttributes(res.Attributes()), + rsm := make(map[*resource.Resource]*tracepb.ResourceSpans) + + for _, sd := range sdl { + if sd != nil { + rs, ok := rsm[sd.Resource] + if !ok { + rs = &tracepb.ResourceSpans{ + Resource: Resource(sd.Resource), + InstrumentationLibrarySpans: []*tracepb.InstrumentationLibrarySpans{ + { + Spans: []*tracepb.Span{}, + }, + }, + } + rsm[sd.Resource] = rs + } + rs.InstrumentationLibrarySpans[0].Spans = + append(rs.InstrumentationLibrarySpans[0].Spans, span(sd)) + } + } + rss := make([]*tracepb.ResourceSpans, 0, len(rsm)) + for _, rs := range rsm { + rss = append(rss, rs) } - return resProto + return rss } -func otSpanToProtoSpan(sd *export.SpanData) *tracepb.Span { +// status transforms a Span into an OTLP span. +func span(sd *export.SpanData) *tracepb.Span { if sd == nil { return nil } @@ -50,14 +69,14 @@ func otSpanToProtoSpan(sd *export.SpanData) *tracepb.Span { TraceId: sd.SpanContext.TraceID[:], SpanId: sd.SpanContext.SpanID[:], ParentSpanId: sd.ParentSpanID[:], - Status: otStatusToProtoStatus(sd.StatusCode, sd.StatusMessage), + Status: status(sd.StatusCode, sd.StatusMessage), StartTimeUnixNano: uint64(sd.StartTime.Nanosecond()), EndTimeUnixNano: uint64(sd.EndTime.Nanosecond()), - Links: otLinksToProtoLinks(sd.Links), - Kind: otSpanKindToProtoSpanKind(sd.SpanKind), + Links: links(sd.Links), + Kind: spanKind(sd.SpanKind), Name: sd.Name, - Attributes: otAttributesToProtoAttributes(sd.Attributes), - Events: otTimeEventsToProtoTimeEvents(sd.MessageEvents), + Attributes: Attributes(sd.Attributes), + Events: spanEvents(sd.MessageEvents), // TODO (rghetia): Add Tracestate: when supported. DroppedAttributesCount: uint32(sd.DroppedAttributeCount), DroppedEventsCount: uint32(sd.DroppedMessageEventCount), @@ -65,14 +84,16 @@ func otSpanToProtoSpan(sd *export.SpanData) *tracepb.Span { } } -func otStatusToProtoStatus(status codes.Code, message string) *tracepb.Status { +// status transform a span code and message into an OTLP span status. +func status(status codes.Code, message string) *tracepb.Status { return &tracepb.Status{ Code: tracepb.Status_StatusCode(status), Message: message, } } -func otLinksToProtoLinks(links []apitrace.Link) []*tracepb.Span_Link { +// links transforms span Links to OTLP span links. +func links(links []apitrace.Link) []*tracepb.Span_Link { if len(links) == 0 { return nil } @@ -86,56 +107,14 @@ func otLinksToProtoLinks(links []apitrace.Link) []*tracepb.Span_Link { sl = append(sl, &tracepb.Span_Link{ TraceId: otLink.TraceID[:], SpanId: otLink.SpanID[:], - Attributes: otAttributesToProtoAttributes(otLink.Attributes), + Attributes: Attributes(otLink.Attributes), }) } return sl } -func otAttributesToProtoAttributes(attrs []core.KeyValue) []*commonpb.AttributeKeyValue { - if len(attrs) == 0 { - return nil - } - out := make([]*commonpb.AttributeKeyValue, 0, len(attrs)) - for _, v := range attrs { - switch v.Value.Type() { - case core.BOOL: - out = append(out, &commonpb.AttributeKeyValue{ - Key: string(v.Key), - Type: commonpb.AttributeKeyValue_BOOL, - BoolValue: v.Value.AsBool(), - }) - case core.INT64, core.INT32, core.UINT32, core.UINT64: - out = append(out, &commonpb.AttributeKeyValue{ - Key: string(v.Key), - Type: commonpb.AttributeKeyValue_INT, - IntValue: v.Value.AsInt64(), - }) - case core.FLOAT32: - f32 := v.Value.AsFloat32() - out = append(out, &commonpb.AttributeKeyValue{ - Key: string(v.Key), - Type: commonpb.AttributeKeyValue_DOUBLE, - DoubleValue: float64(f32), - }) - case core.FLOAT64: - out = append(out, &commonpb.AttributeKeyValue{ - Key: string(v.Key), - Type: commonpb.AttributeKeyValue_DOUBLE, - DoubleValue: v.Value.AsFloat64(), - }) - case core.STRING: - out = append(out, &commonpb.AttributeKeyValue{ - Key: string(v.Key), - Type: commonpb.AttributeKeyValue_STRING, - StringValue: v.Value.AsString(), - }) - } - } - return out -} - -func otTimeEventsToProtoTimeEvents(es []export.Event) []*tracepb.Span_Event { +// spanEvents transforms span Events to a OTLP span events. +func spanEvents(es []export.Event) []*tracepb.Span_Event { if len(es) == 0 { return nil } @@ -155,8 +134,9 @@ func otTimeEventsToProtoTimeEvents(es []export.Event) []*tracepb.Span_Event { messageEvents++ events = append(events, &tracepb.Span_Event{ + Name: e.Name, TimeUnixNano: uint64(e.Time.Nanosecond()), - Attributes: otAttributesToProtoAttributes(e.Attributes), + Attributes: Attributes(e.Attributes), // TODO (rghetia) : Add Drop Counts when supported. }, ) @@ -165,7 +145,8 @@ func otTimeEventsToProtoTimeEvents(es []export.Event) []*tracepb.Span_Event { return events } -func otSpanKindToProtoSpanKind(kind apitrace.SpanKind) tracepb.Span_SpanKind { +// spanKind transforms a SpanKind to an OTLP span kind. +func spanKind(kind apitrace.SpanKind) tracepb.Span_SpanKind { switch kind { case apitrace.SpanKindInternal: return tracepb.Span_INTERNAL diff --git a/exporters/otlp/internal/transform/span_test.go b/exporters/otlp/internal/transform/span_test.go new file mode 100644 index 00000000000..c0bd394e86d --- /dev/null +++ b/exporters/otlp/internal/transform/span_test.go @@ -0,0 +1,399 @@ +package transform + +import ( + "strconv" + "testing" + "time" + + "github.com/gogo/protobuf/proto" + "github.com/google/go-cmp/cmp" + tracepb "github.com/open-telemetry/opentelemetry-proto/gen/go/trace/v1" + "github.com/stretchr/testify/assert" + "google.golang.org/grpc/codes" + + "go.opentelemetry.io/otel/api/core" + apitrace "go.opentelemetry.io/otel/api/trace" + export "go.opentelemetry.io/otel/sdk/export/trace" + "go.opentelemetry.io/otel/sdk/resource" +) + +func TestSpanKind(t *testing.T) { + for _, test := range []struct { + kind apitrace.SpanKind + expected tracepb.Span_SpanKind + }{ + { + apitrace.SpanKindInternal, + tracepb.Span_INTERNAL, + }, + { + apitrace.SpanKindClient, + tracepb.Span_CLIENT, + }, + { + apitrace.SpanKindServer, + tracepb.Span_SERVER, + }, + { + apitrace.SpanKindProducer, + tracepb.Span_PRODUCER, + }, + { + apitrace.SpanKindConsumer, + tracepb.Span_CONSUMER, + }, + { + apitrace.SpanKind(-1), + tracepb.Span_SPAN_KIND_UNSPECIFIED, + }, + } { + assert.Equal(t, test.expected, spanKind(test.kind)) + } +} + +func TestNilSpanEvent(t *testing.T) { + assert.Nil(t, spanEvents(nil)) +} + +func TestEmptySpanEvent(t *testing.T) { + assert.Nil(t, spanEvents([]export.Event{})) +} + +func TestSpanEvent(t *testing.T) { + attrs := []core.KeyValue{core.Key("one").Int(1), core.Key("two").Int(2)} + now := time.Now() + got := spanEvents([]export.Event{ + { + Name: "test 1", + Attributes: []core.KeyValue{}, + Time: now, + }, + { + Name: "test 2", + Attributes: attrs, + Time: now, + }, + }) + if !assert.Len(t, got, 2) { + return + } + uNow := uint64(now.Nanosecond()) + assert.Equal(t, &tracepb.Span_Event{Name: "test 1", Attributes: nil, TimeUnixNano: uNow}, got[0]) + // Do not test Attributes directly, just that the return value goes to the correct field. + assert.Equal(t, &tracepb.Span_Event{Name: "test 2", Attributes: Attributes(attrs), TimeUnixNano: uNow}, got[1]) +} + +func TestExcessiveSpanEvents(t *testing.T) { + e := make([]export.Event, maxMessageEventsPerSpan+1) + for i := 0; i < maxMessageEventsPerSpan+1; i++ { + e[i] = export.Event{Name: strconv.Itoa(i)} + } + assert.Len(t, e, maxMessageEventsPerSpan+1) + got := spanEvents(e) + assert.Len(t, got, maxMessageEventsPerSpan) + // Ensure the drop order. + assert.Equal(t, strconv.Itoa(maxMessageEventsPerSpan-1), got[len(got)-1].Name) +} + +func TestNilLinks(t *testing.T) { + assert.Nil(t, links(nil)) +} + +func TestEmptyLinks(t *testing.T) { + assert.Nil(t, links([]apitrace.Link{})) +} + +func TestLinks(t *testing.T) { + attrs := []core.KeyValue{core.Key("one").Int(1), core.Key("two").Int(2)} + l := []apitrace.Link{ + {}, + { + SpanContext: core.EmptySpanContext(), + Attributes: attrs, + }, + } + got := links(l) + + // Make sure we get the same number back first. + if !assert.Len(t, got, 2) { + return + } + + // Empty should be empty. + expected := &tracepb.Span_Link{ + TraceId: []uint8{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, + SpanId: []uint8{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, + } + assert.Equal(t, expected, got[0]) + + // Do not test Attributes directly, just that the return value goes to the correct field. + expected.Attributes = Attributes(attrs) + assert.Equal(t, expected, got[1]) + + // Changes to our links should not change the produced links. + l[1].TraceID[0] = byte(0x1) + l[1].SpanID[0] = byte(0x1) + assert.Equal(t, expected, got[1]) +} + +func TestStatus(t *testing.T) { + for _, test := range []struct { + grpcCode codes.Code + message string + otlpStatus tracepb.Status_StatusCode + }{ + { + codes.OK, + "test OK", + tracepb.Status_Ok, + }, + { + codes.Canceled, + //nolint + "test CANCELLED", + //nolint + tracepb.Status_Cancelled, + }, + { + codes.Unknown, + "test UNKNOWN", + tracepb.Status_UnknownError, + }, + { + codes.InvalidArgument, + "test INVALID_ARGUMENT", + tracepb.Status_InvalidArgument, + }, + { + codes.DeadlineExceeded, + "test DEADLINE_EXCEEDED", + tracepb.Status_DeadlineExceeded, + }, + { + codes.NotFound, + "test NOT_FOUND", + tracepb.Status_NotFound, + }, + { + codes.AlreadyExists, + "test ALREADY_EXISTS", + tracepb.Status_AlreadyExists, + }, + { + codes.PermissionDenied, + "test PERMISSION_DENIED", + tracepb.Status_PermissionDenied, + }, + { + codes.ResourceExhausted, + "test RESOURCE_EXHAUSTED", + tracepb.Status_ResourceExhausted, + }, + { + codes.FailedPrecondition, + "test FAILED_PRECONDITION", + tracepb.Status_FailedPrecondition, + }, + { + codes.Aborted, + "test ABORTED", + tracepb.Status_Aborted, + }, + { + codes.OutOfRange, + "test OUT_OF_RANGE", + tracepb.Status_OutOfRange, + }, + { + codes.Unimplemented, + "test UNIMPLEMENTED", + tracepb.Status_Unimplemented, + }, + { + codes.Internal, + "test INTERNAL", + tracepb.Status_InternalError, + }, + { + codes.Unavailable, + "test UNAVAILABLE", + tracepb.Status_Unavailable, + }, + { + codes.DataLoss, + "test DATA_LOSS", + tracepb.Status_DataLoss, + }, + { + codes.Unauthenticated, + "test UNAUTHENTICATED", + tracepb.Status_Unauthenticated, + }, + } { + expected := &tracepb.Status{Code: test.otlpStatus, Message: test.message} + assert.Equal(t, expected, status(test.grpcCode, test.message)) + } + +} + +func TestNilSpan(t *testing.T) { + assert.Nil(t, span(nil)) +} + +func TestNilSpanData(t *testing.T) { + assert.Nil(t, SpanData(nil)) +} + +func TestEmptySpanData(t *testing.T) { + assert.Nil(t, SpanData(nil)) +} + +func TestSpanData(t *testing.T) { + // Full test of span data transform. + + startTime := time.Now() + endTime := startTime.Add(10 * time.Second) + spanData := &export.SpanData{ + SpanContext: core.SpanContext{ + TraceID: core.TraceID{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F}, + SpanID: core.SpanID{0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8}, + }, + SpanKind: apitrace.SpanKindServer, + ParentSpanID: core.SpanID{0xEF, 0xEE, 0xED, 0xEC, 0xEB, 0xEA, 0xE9, 0xE8}, + Name: "span data to span data", + StartTime: startTime, + EndTime: endTime, + MessageEvents: []export.Event{ + {Time: startTime, + Attributes: []core.KeyValue{ + core.Key("CompressedByteSize").Uint64(512), + }, + }, + {Time: endTime, + Attributes: []core.KeyValue{ + core.Key("MessageEventType").String("Recv"), + }, + }, + }, + Links: []apitrace.Link{ + { + SpanContext: core.SpanContext{ + TraceID: core.TraceID{0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF}, + SpanID: core.SpanID{0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7}, + TraceFlags: 0, + }, + Attributes: []core.KeyValue{ + core.Key("LinkType").String("Parent"), + }, + }, + { + SpanContext: core.SpanContext{ + TraceID: core.TraceID{0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF}, + SpanID: core.SpanID{0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7}, + TraceFlags: 0, + }, + Attributes: []core.KeyValue{ + core.Key("LinkType").String("Child"), + }, + }, + }, + StatusCode: codes.Internal, + StatusMessage: "utterly unrecognized", + HasRemoteParent: true, + Attributes: []core.KeyValue{ + core.Key("timeout_ns").Int64(12e9), + }, + DroppedAttributeCount: 1, + DroppedMessageEventCount: 2, + DroppedLinkCount: 3, + Resource: resource.New(core.Key("rk1").String("rv1"), core.Key("rk2").Int64(5)), + } + + // Not checking resource as the underlying map of our Resource makes + // ordering impossible to guarantee on the output. The Resource + // transform function has unit tests that should suffice. + expectedSpan := tracepb.Span{ + TraceId: []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F}, + SpanId: []byte{0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8}, + ParentSpanId: []byte{0xEF, 0xEE, 0xED, 0xEC, 0xEB, 0xEA, 0xE9, 0xE8}, + Name: spanData.Name, + Kind: tracepb.Span_SERVER, + StartTimeUnixNano: uint64(startTime.Nanosecond()), + EndTimeUnixNano: uint64(endTime.Nanosecond()), + Status: status(spanData.StatusCode, spanData.StatusMessage), + Events: spanEvents(spanData.MessageEvents), + Links: links(spanData.Links), + Attributes: Attributes(spanData.Attributes), + DroppedAttributesCount: 1, + DroppedEventsCount: 2, + DroppedLinksCount: 3, + } + + got := SpanData([]*export.SpanData{spanData}) + if !assert.Len(t, got, 1) { + return + } + + // Break the span down as large diffs can be hard to read. + actualSpans := got[0].GetInstrumentationLibrarySpans() + if !assert.Len(t, actualSpans, 1) && !assert.Len(t, actualSpans[0].Spans, 1) { + return + } + actualSpan := actualSpans[0].Spans[0] + + if diff := cmp.Diff(expectedSpan.TraceId, actualSpan.TraceId, cmp.Comparer(proto.Equal)); diff != "" { + t.Fatalf("transformed span.TraceId differs %v\n", diff) + } + + if diff := cmp.Diff(expectedSpan.SpanId, actualSpan.SpanId, cmp.Comparer(proto.Equal)); diff != "" { + t.Fatalf("transformed span..SpanId differs %v\n", diff) + } + + if diff := cmp.Diff(expectedSpan.ParentSpanId, actualSpan.ParentSpanId, cmp.Comparer(proto.Equal)); diff != "" { + t.Fatalf("transformed span.ParentSpanId differs %v\n", diff) + } + + if diff := cmp.Diff(expectedSpan.Status, actualSpan.Status, cmp.Comparer(proto.Equal)); diff != "" { + t.Fatalf("transformed span.Status differs %v\n", diff) + } + + if diff := cmp.Diff(expectedSpan.StartTimeUnixNano, actualSpan.StartTimeUnixNano, cmp.Comparer(proto.Equal)); diff != "" { + t.Fatalf("transformed span.StartTimeUnixNano differs %v\n", diff) + } + + if diff := cmp.Diff(expectedSpan.EndTimeUnixNano, actualSpan.EndTimeUnixNano, cmp.Comparer(proto.Equal)); diff != "" { + t.Fatalf("transformed span.EndTimeUnixNano differs %v\n", diff) + } + + if diff := cmp.Diff(expectedSpan.Links, actualSpan.Links, cmp.Comparer(proto.Equal)); diff != "" { + t.Fatalf("transformed span.Links differs %v\n", diff) + } + + if diff := cmp.Diff(expectedSpan.Kind, actualSpan.Kind, cmp.Comparer(proto.Equal)); diff != "" { + t.Fatalf("transformed span.Kind differs %v\n", diff) + } + + if diff := cmp.Diff(expectedSpan.Name, actualSpan.Name, cmp.Comparer(proto.Equal)); diff != "" { + t.Fatalf("transformed span.Name differs %v\n", diff) + } + + if diff := cmp.Diff(expectedSpan.Attributes, actualSpan.Attributes, cmp.Comparer(proto.Equal)); diff != "" { + t.Fatalf("transformed span.Attributes differs %v\n", diff) + } + + if diff := cmp.Diff(expectedSpan.Events, actualSpan.Events, cmp.Comparer(proto.Equal)); diff != "" { + t.Fatalf("transformed span.Events differs %v\n", diff) + } + + if diff := cmp.Diff(expectedSpan.DroppedAttributesCount, actualSpan.DroppedAttributesCount, cmp.Comparer(proto.Equal)); diff != "" { + t.Fatalf("transformed span.DroppedAttributesCount differs %v\n", diff) + } + + if diff := cmp.Diff(expectedSpan.DroppedEventsCount, actualSpan.DroppedEventsCount, cmp.Comparer(proto.Equal)); diff != "" { + t.Fatalf("transformed span.DroppedEventsCount differs %v\n", diff) + } + + if diff := cmp.Diff(expectedSpan.DroppedLinksCount, actualSpan.DroppedLinksCount, cmp.Comparer(proto.Equal)); diff != "" { + t.Fatalf("transformed span.DroppedLinksCount differs %v\n", diff) + } +} diff --git a/exporters/otlp/otlp.go b/exporters/otlp/otlp.go index 996e1a241a1..73d57cfe5ef 100644 --- a/exporters/otlp/otlp.go +++ b/exporters/otlp/otlp.go @@ -23,15 +23,12 @@ import ( "sync" "unsafe" - "go.opentelemetry.io/otel/sdk/resource" - "google.golang.org/grpc" "google.golang.org/grpc/metadata" colmetricpb "github.com/open-telemetry/opentelemetry-proto/gen/go/collector/metrics/v1" coltracepb "github.com/open-telemetry/opentelemetry-proto/gen/go/collector/trace/v1" metricpb "github.com/open-telemetry/opentelemetry-proto/gen/go/metrics/v1" - tracepb "github.com/open-telemetry/opentelemetry-proto/gen/go/trace/v1" "go.opentelemetry.io/otel/exporters/otlp/internal/transform" metricsdk "go.opentelemetry.io/otel/sdk/export/metric" @@ -349,37 +346,6 @@ func (e *Exporter) ExportSpans(ctx context.Context, sds []*tracesdk.SpanData) { e.uploadTraces(ctx, sds) } -func otSpanDataToPbSpans(sdl []*tracesdk.SpanData) []*tracepb.ResourceSpans { - if len(sdl) == 0 { - return nil - } - rsm := make(map[*resource.Resource]*tracepb.ResourceSpans) - - for _, sd := range sdl { - if sd != nil { - rs, ok := rsm[sd.Resource] - if !ok { - rs = &tracepb.ResourceSpans{ - Resource: otResourceToProtoResource(sd.Resource), - InstrumentationLibrarySpans: []*tracepb.InstrumentationLibrarySpans{ - { - Spans: []*tracepb.Span{}, - }, - }, - } - rsm[sd.Resource] = rs - } - rs.InstrumentationLibrarySpans[0].Spans = - append(rs.InstrumentationLibrarySpans[0].Spans, otSpanToProtoSpan(sd)) - } - } - rss := make([]*tracepb.ResourceSpans, 0, len(rsm)) - for _, rs := range rsm { - rss = append(rss, rs) - } - return rss -} - func (e *Exporter) uploadTraces(ctx context.Context, sdl []*tracesdk.SpanData) { select { case <-e.stopCh: @@ -390,7 +356,7 @@ func (e *Exporter) uploadTraces(ctx context.Context, sdl []*tracesdk.SpanData) { return } - protoSpans := otSpanDataToPbSpans(sdl) + protoSpans := transform.SpanData(sdl) if len(protoSpans) == 0 { return } diff --git a/exporters/otlp/transform_spans_test.go b/exporters/otlp/transform_spans_test.go deleted file mode 100644 index 96c003ff613..00000000000 --- a/exporters/otlp/transform_spans_test.go +++ /dev/null @@ -1,433 +0,0 @@ -// Copyright 2020, OpenTelemetry 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 otlp_test - -import ( - "context" - "testing" - "time" - - "go.opentelemetry.io/otel/sdk/resource" - - "github.com/golang/protobuf/proto" - "github.com/google/go-cmp/cmp" - "google.golang.org/grpc/codes" - - commonpb "github.com/open-telemetry/opentelemetry-proto/gen/go/common/v1" - resourcepb "github.com/open-telemetry/opentelemetry-proto/gen/go/resource/v1" - tracepb "github.com/open-telemetry/opentelemetry-proto/gen/go/trace/v1" - - "go.opentelemetry.io/otel/api/core" - apitrace "go.opentelemetry.io/otel/api/trace" - "go.opentelemetry.io/otel/exporters/otlp" - export "go.opentelemetry.io/otel/sdk/export/trace" -) - -type testCases struct { - otSpan []*export.SpanData - otlpResSpan *tracepb.ResourceSpans -} - -func TestOtSpanToOtlpSpan_Basic(t *testing.T) { - // The goal of this test is to ensure that each - // spanData is transformed and exported correctly! - testAndVerify("Basic End-2-End", t, func(t *testing.T) testCases { - - startTime := time.Now() - endTime := startTime.Add(10 * time.Second) - - tc := testCases{ - otSpan: []*export.SpanData{ - { - SpanContext: core.SpanContext{ - TraceID: core.TraceID{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F}, - SpanID: core.SpanID{0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8}, - }, - SpanKind: apitrace.SpanKindServer, - ParentSpanID: core.SpanID{0xEF, 0xEE, 0xED, 0xEC, 0xEB, 0xEA, 0xE9, 0xE8}, - Name: "End-To-End Here", - StartTime: startTime, - EndTime: endTime, - MessageEvents: []export.Event{ - {Time: startTime, - Attributes: []core.KeyValue{ - core.Key("CompressedByteSize").Uint64(512), - }, - }, - {Time: endTime, - Attributes: []core.KeyValue{ - core.Key("MessageEventType").String("Recv"), - }, - }, - }, - Links: []apitrace.Link{ - { - SpanContext: core.SpanContext{ - TraceID: core.TraceID{0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF}, - SpanID: core.SpanID{0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7}, - TraceFlags: 0, - }, - Attributes: []core.KeyValue{ - core.Key("LinkType").String("Parent"), - }, - }, - { - SpanContext: core.SpanContext{ - TraceID: core.TraceID{0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF}, - SpanID: core.SpanID{0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7}, - TraceFlags: 0, - }, - Attributes: []core.KeyValue{ - core.Key("LinkType").String("Child"), - }, - }, - }, - StatusCode: codes.Internal, - StatusMessage: "utterly unrecognized", - HasRemoteParent: true, - Attributes: []core.KeyValue{ - core.Key("timeout_ns").Int64(12e9), - }, - DroppedAttributeCount: 1, - DroppedMessageEventCount: 2, - DroppedLinkCount: 3, - Resource: resource.New(core.Key("rk1").String("rv1"), - core.Key("rk2").Int64(5)), - }, - }, - otlpResSpan: &tracepb.ResourceSpans{ - InstrumentationLibrarySpans: []*tracepb.InstrumentationLibrarySpans{ - { - Spans: []*tracepb.Span{ - { - TraceId: []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F}, - SpanId: []byte{0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8}, - ParentSpanId: []byte{0xEF, 0xEE, 0xED, 0xEC, 0xEB, 0xEA, 0xE9, 0xE8}, - Name: "End-To-End Here", - Kind: tracepb.Span_SERVER, - StartTimeUnixNano: uint64(startTime.Nanosecond()), - EndTimeUnixNano: uint64(endTime.Nanosecond()), - Status: &tracepb.Status{ - Code: 13, - Message: "utterly unrecognized", - }, - Events: []*tracepb.Span_Event{ - { - TimeUnixNano: uint64(startTime.Nanosecond()), - Attributes: []*commonpb.AttributeKeyValue{ - { - Key: "CompressedByteSize", - Type: commonpb.AttributeKeyValue_INT, - IntValue: 512, - }, - }, - }, - { - TimeUnixNano: uint64(endTime.Nanosecond()), - Attributes: []*commonpb.AttributeKeyValue{ - { - Key: "MessageEventType", - Type: commonpb.AttributeKeyValue_STRING, - StringValue: "Recv", - }, - }, - }, - }, - Links: []*tracepb.Span_Link{ - { - TraceId: []byte{0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF}, - SpanId: []byte{0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7}, - Attributes: []*commonpb.AttributeKeyValue{ - { - Key: "LinkType", - Type: commonpb.AttributeKeyValue_STRING, - StringValue: "Parent", - }, - }, - }, - { - TraceId: []byte{0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF}, - SpanId: []byte{0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7}, - Attributes: []*commonpb.AttributeKeyValue{ - { - Key: "LinkType", - Type: commonpb.AttributeKeyValue_STRING, - StringValue: "Child", - }, - }, - }, - }, - Attributes: []*commonpb.AttributeKeyValue{ - { - Key: "timeout_ns", - Type: commonpb.AttributeKeyValue_INT, - IntValue: 12e9, - }, - }, - DroppedAttributesCount: 1, - DroppedEventsCount: 2, - DroppedLinksCount: 3, - }, - }, - }, - }, - Resource: &resourcepb.Resource{ - Attributes: []*commonpb.AttributeKeyValue{ - { - Key: "rk1", - Type: commonpb.AttributeKeyValue_STRING, - StringValue: "rv1", - }, - { - Key: "rk2", - Type: commonpb.AttributeKeyValue_INT, - IntValue: 5, - }, - }, - }, - }, - } - return tc - }) -} - -func TestOtSpanToOtlpSpan_SpanKind(t *testing.T) { - testAndVerify("Test SpanKind", t, func(t *testing.T) testCases { - kinds := []struct { - in apitrace.SpanKind - out tracepb.Span_SpanKind - }{ - { - in: apitrace.SpanKindClient, - out: tracepb.Span_CLIENT, - }, - { - in: apitrace.SpanKindServer, - out: tracepb.Span_SERVER, - }, - { - in: apitrace.SpanKindProducer, - out: tracepb.Span_PRODUCER, - }, - { - in: apitrace.SpanKindConsumer, - out: tracepb.Span_CONSUMER, - }, - { - in: apitrace.SpanKindInternal, - out: tracepb.Span_INTERNAL, - }, - { - in: apitrace.SpanKindUnspecified, - out: tracepb.Span_SPAN_KIND_UNSPECIFIED, - }, - } - - otSpans := make([]*export.SpanData, 0, len(kinds)) - otlpSpans := make([]*tracepb.Span, 0, len(kinds)) - for _, kind := range kinds { - otSpan, otlpSpan := getSpan() - otSpan.SpanKind = kind.in - otlpSpan.Kind = kind.out - otSpans = append(otSpans, otSpan) - otlpSpans = append(otlpSpans, otlpSpan) - } - tc := testCases{ - otSpan: otSpans, - otlpResSpan: &tracepb.ResourceSpans{ - Resource: nil, - InstrumentationLibrarySpans: []*tracepb.InstrumentationLibrarySpans{ - { - Spans: otlpSpans, - }, - }, - }, - } - return tc - }) -} - -func TestOtSpanToOtlpSpan_Attribute(t *testing.T) { - testAndVerify("Test SpanAttribute", t, func(t *testing.T) testCases { - attrInt := &commonpb.AttributeKeyValue{ - Key: "commonInt", - Type: commonpb.AttributeKeyValue_INT, - IntValue: 25, - } - attrInt64 := &commonpb.AttributeKeyValue{ - Key: "commonInt64", - Type: commonpb.AttributeKeyValue_INT, - IntValue: 12e9, - } - kinds := []struct { - in core.KeyValue - out *commonpb.AttributeKeyValue - }{ - { - in: core.Key("commonInt").Int(25), - out: attrInt, - }, - { - in: core.Key("commonInt").Uint(25), - out: attrInt, - }, - { - in: core.Key("commonInt").Int32(25), - out: attrInt, - }, - { - in: core.Key("commonInt").Uint32(25), - out: attrInt, - }, - { - in: core.Key("commonInt64").Int64(12e9), - out: attrInt64, - }, - { - in: core.Key("commonInt64").Uint64(12e9), - out: attrInt64, - }, - { - in: core.Key("float32").Float32(3.598549), - out: &commonpb.AttributeKeyValue{ - - Key: "float32", - Type: commonpb.AttributeKeyValue_DOUBLE, - DoubleValue: 3.5985488891601562, - }, - }, - { - in: core.Key("float64").Float64(14.598549), - out: &commonpb.AttributeKeyValue{ - - Key: "float64", - Type: commonpb.AttributeKeyValue_DOUBLE, - DoubleValue: 14.598549, - }, - }, - { - in: core.Key("string").String("string"), - out: &commonpb.AttributeKeyValue{ - - Key: "string", - Type: commonpb.AttributeKeyValue_STRING, - StringValue: "string", - }, - }, - { - in: core.Key("bool").Bool(true), - out: &commonpb.AttributeKeyValue{ - - Key: "bool", - Type: commonpb.AttributeKeyValue_BOOL, - BoolValue: true, - }, - }, - } - - otSpans := make([]*export.SpanData, 0, len(kinds)) - otlpSpans := make([]*tracepb.Span, 0, len(kinds)) - for _, kind := range kinds { - otSpan, otlpSpan := getSpan() - otSpan.Attributes = []core.KeyValue{kind.in} - otlpSpan.Attributes = []*commonpb.AttributeKeyValue{kind.out} - otSpans = append(otSpans, otSpan) - otlpSpans = append(otlpSpans, otlpSpan) - } - tc := testCases{ - otSpan: otSpans, - otlpResSpan: &tracepb.ResourceSpans{ - Resource: nil, - InstrumentationLibrarySpans: []*tracepb.InstrumentationLibrarySpans{ - { - Spans: otlpSpans, - }, - }, - }, - } - return tc - }) -} - -func getSpan() (*export.SpanData, *tracepb.Span) { - startTime := time.Now() - endTime := startTime.Add(10 * time.Second) - - otSpan := &export.SpanData{ - SpanContext: core.SpanContext{ - TraceID: core.TraceID{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F}, - SpanID: core.SpanID{0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8}, - }, - SpanKind: apitrace.SpanKindServer, - ParentSpanID: core.SpanID{0xEF, 0xEE, 0xED, 0xEC, 0xEB, 0xEA, 0xE9, 0xE8}, - Name: "Test Span", - StartTime: startTime, - EndTime: endTime, - } - otlpSpan := &tracepb.Span{ - TraceId: []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F}, - SpanId: []byte{0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8}, - ParentSpanId: []byte{0xEF, 0xEE, 0xED, 0xEC, 0xEB, 0xEA, 0xE9, 0xE8}, - Name: "Test Span", - Kind: tracepb.Span_SERVER, - StartTimeUnixNano: uint64(startTime.Nanosecond()), - EndTimeUnixNano: uint64(endTime.Nanosecond()), - Status: &tracepb.Status{ - Code: 0, - }, - } - - return otSpan, otlpSpan -} - -func testAndVerify(name string, t *testing.T, f func(t *testing.T) testCases) { - // The goal of this test is to ensure that each - // spanData is transformed and exported correctly! - - collector := runMockCol(t) - defer func() { - _ = collector.stop() - }() - - exp, err := otlp.NewExporter(otlp.WithInsecure(), - otlp.WithAddress(collector.address), - otlp.WithReconnectionPeriod(50*time.Millisecond)) - if err != nil { - t.Fatalf("Failed to create a new collector exporter: %v", err) - } - defer func() { - _ = exp.Stop() - }() - - // Give the background collector connection sometime to setup. - <-time.After(20 * time.Millisecond) - - tc := f(t) - exp.ExportSpans(context.Background(), tc.otSpan) - - _ = exp.Stop() - _ = collector.stop() - - rss := collector.getResourceSpans() - gotCount := len(rss) - wantCount := 1 - if gotCount != wantCount { - t.Fatalf("%s: ResourceSpans: got %d, want %d", name, gotCount, wantCount) - } - - if diff := cmp.Diff(rss[0], tc.otlpResSpan, cmp.Comparer(proto.Equal)); diff != "" { - t.Fatalf("%s transformed span differs %v\n", name, diff) - } -}