From 8042a032f4936a43e081ceae04edb68c7c582160 Mon Sep 17 00:00:00 2001 From: Iris Song <73505006+IrisTuntun@users.noreply.github.com> Date: Mon, 7 Jun 2021 03:07:15 -0700 Subject: [PATCH] Remove the proto dependency in goldendataset for traces (#3322) * Remove the proto dependency in goldendataset for traces * revert changelog * update changelog * Update consumer/pdata/common.go Co-authored-by: Anthony Mirabella * Fix common.go where there is a missing "}" * Add functions to convert proto keyvalues to AttributeMap * further remove proto dependency * Add PR number to CHANGELOG * update resource_generator_test and resource_to_oc_test * Return nil instead of empty objects for some generator functions. Co-authored-by: Anthony Mirabella Co-authored-by: Bogdan Drutu --- CHANGELOG.md | 1 + internal/goldendataset/generator_commons.go | 65 +++--- internal/goldendataset/resource_generator.go | 43 ++-- .../goldendataset/resource_generator_test.go | 21 +- internal/goldendataset/span_generator.go | 191 +++++++++--------- internal/goldendataset/span_generator_test.go | 27 ++- internal/goldendataset/traces_generator.go | 68 ++++--- .../internaldata/resource_to_oc_test.go | 8 +- 8 files changed, 195 insertions(+), 229 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0487b6a55f153..4d42e137da7e7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -20,6 +20,7 @@ - Add `doc.go` files to the consumer package and its subpackages (#3270) - Automate triggering of doc-update on release (#3234) - Enable Dependabot for Github Actions (#3312) +- Remove the proto dependency in `goldendataset` for traces (#3322) - Add telemetry for dropped data due to exporter sending queue overflow (#3328) ## v0.27.0 Beta diff --git a/internal/goldendataset/generator_commons.go b/internal/goldendataset/generator_commons.go index c1bf9ee894a71..cbfc44ea12a5d 100644 --- a/internal/goldendataset/generator_commons.go +++ b/internal/goldendataset/generator_commons.go @@ -22,58 +22,41 @@ import ( "github.com/spf13/cast" - "go.opentelemetry.io/collector/internal/data" - otlpcommon "go.opentelemetry.io/collector/internal/data/protogen/common/v1" + "go.opentelemetry.io/collector/consumer/pdata" ) -func convertMapToAttributeKeyValues(attrsMap map[string]interface{}) []otlpcommon.KeyValue { +func convertMapToAttributeMap(attrsMap map[string]interface{}) *pdata.AttributeMap { + attributeMap := pdata.NewAttributeMap() if attrsMap == nil { return nil } - attrList := make([]otlpcommon.KeyValue, len(attrsMap)) - index := 0 for key, value := range attrsMap { - attrList[index] = constructAttributeKeyValue(key, value) - index++ + attributeMap.Insert(key, convertToAttributeValue(value)) } - return attrList + return &attributeMap } -func constructAttributeKeyValue(key string, value interface{}) otlpcommon.KeyValue { - var attr otlpcommon.KeyValue +func convertToAttributeValue(value interface{}) pdata.AttributeValue { + var newValue pdata.AttributeValue switch val := value.(type) { case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64: - attr = otlpcommon.KeyValue{ - Key: key, - Value: otlpcommon.AnyValue{Value: &otlpcommon.AnyValue_IntValue{IntValue: cast.ToInt64(val)}}, - } + newValue = pdata.NewAttributeValueInt(cast.ToInt64(val)) case float32, float64: - attr = otlpcommon.KeyValue{ - Key: key, - Value: otlpcommon.AnyValue{Value: &otlpcommon.AnyValue_DoubleValue{DoubleValue: cast.ToFloat64(val)}}, - } + newValue = pdata.NewAttributeValueDouble(cast.ToFloat64(val)) case bool: - attr = otlpcommon.KeyValue{ - Key: key, - Value: otlpcommon.AnyValue{Value: &otlpcommon.AnyValue_BoolValue{BoolValue: cast.ToBool(val)}}, - } - case *otlpcommon.ArrayValue: - attr = otlpcommon.KeyValue{ - Key: key, - Value: otlpcommon.AnyValue{Value: &otlpcommon.AnyValue_ArrayValue{ArrayValue: val}}, - } - case *otlpcommon.KeyValueList: - attr = otlpcommon.KeyValue{ - Key: key, - Value: otlpcommon.AnyValue{Value: &otlpcommon.AnyValue_KvlistValue{KvlistValue: val}}, - } + newValue = pdata.NewAttributeValueBool(cast.ToBool(val)) + case pdata.AttributeMap: + newValue = pdata.NewAttributeValueMap() + val.CopyTo(newValue.MapVal()) + case pdata.AnyValueArray: + newValue = pdata.NewAttributeValueArray() + val.CopyTo(newValue.ArrayVal()) + case pdata.AttributeValue: + newValue = val default: - attr = otlpcommon.KeyValue{ - Key: key, - Value: otlpcommon.AnyValue{Value: &otlpcommon.AnyValue_StringValue{StringValue: val.(string)}}, - } + newValue = pdata.NewAttributeValueString(val.(string)) } - return attr + return newValue } func loadPictOutputFile(fileName string) ([][]string, error) { @@ -94,20 +77,20 @@ func loadPictOutputFile(fileName string) ([][]string, error) { return reader.ReadAll() } -func generateTraceID(random io.Reader) data.TraceID { +func generatePDataTraceID(random io.Reader) pdata.TraceID { var r [16]byte _, err := random.Read(r[:]) if err != nil { panic(err) } - return data.NewTraceID(r) + return pdata.NewTraceID(r) } -func generateSpanID(random io.Reader) data.SpanID { +func generatePDataSpanID(random io.Reader) pdata.SpanID { var r [8]byte _, err := random.Read(r[:]) if err != nil { panic(err) } - return data.NewSpanID(r) + return pdata.NewSpanID(r) } diff --git a/internal/goldendataset/resource_generator.go b/internal/goldendataset/resource_generator.go index 4a1015b44829a..396242e628d3f 100644 --- a/internal/goldendataset/resource_generator.go +++ b/internal/goldendataset/resource_generator.go @@ -15,14 +15,13 @@ package goldendataset import ( - otlpcommon "go.opentelemetry.io/collector/internal/data/protogen/common/v1" - otlpresource "go.opentelemetry.io/collector/internal/data/protogen/resource/v1" + "go.opentelemetry.io/collector/consumer/pdata" "go.opentelemetry.io/collector/translator/conventions" ) -// GenerateResource generates a OTLP Resource object with representative attributes for the +// GenerateResource generates a PData Resource object with representative attributes for the // underlying resource type specified by the rscID input parameter. -func GenerateResource(rscID PICTInputResource) otlpresource.Resource { +func GenerateResource(rscID PICTInputResource) pdata.Resource { var attrs map[string]interface{} switch rscID { case ResourceNil: @@ -44,16 +43,12 @@ func GenerateResource(rscID PICTInputResource) otlpresource.Resource { default: attrs = generateEmptyAttributes() } - var dropped uint32 - if len(attrs) < 10 { - dropped = 0 - } else { - dropped = uint32(len(attrs) % 4) - } - return otlpresource.Resource{ - Attributes: convertMapToAttributeKeyValues(attrs), - DroppedAttributesCount: dropped, + resource := pdata.NewResource() + attributeMap := convertMapToAttributeMap(attrs) + if attributeMap != nil { + attributeMap.CopyTo(resource.Attributes()) } + return resource } func generateNilAttributes() map[string]interface{} { @@ -70,12 +65,10 @@ func generateOnpremVMAttributes() map[string]interface{} { attrMap[conventions.AttributeServiceName] = "customers" attrMap[conventions.AttributeServiceNamespace] = "production" attrMap[conventions.AttributeServiceVersion] = "semver:0.7.3" - subMap := make(map[string]interface{}) - subMap["public"] = "tc-prod9.internal.example.com" - subMap["internal"] = "172.18.36.18" - attrMap[conventions.AttributeHostName] = &otlpcommon.KeyValueList{ - Values: convertMapToAttributeKeyValues(subMap), - } + subMap := pdata.NewAttributeMap() + subMap.InsertString("public", "tc-prod9.internal.example.com") + subMap.InsertString("internal", "172.18.36.18") + attrMap[conventions.AttributeHostName] = subMap attrMap[conventions.AttributeHostImageID] = "661ADFA6-E293-4870-9EFA-1AA052C49F18" attrMap[conventions.AttributeTelemetrySDKLanguage] = conventions.AttributeSDKLangValueJava attrMap[conventions.AttributeTelemetrySDKName] = "opentelemetry" @@ -153,13 +146,11 @@ func generateFassAttributes() map[string]interface{} { func generateExecAttributes() map[string]interface{} { attrMap := make(map[string]interface{}) attrMap[conventions.AttributeProcessExecutableName] = "otelcol" - parts := make([]otlpcommon.AnyValue, 3) - parts[0] = otlpcommon.AnyValue{Value: &otlpcommon.AnyValue_StringValue{StringValue: "otelcol"}} - parts[1] = otlpcommon.AnyValue{Value: &otlpcommon.AnyValue_StringValue{StringValue: "--config=/etc/otel-collector-config.yaml"}} - parts[2] = otlpcommon.AnyValue{Value: &otlpcommon.AnyValue_StringValue{StringValue: "--mem-ballast-size-mib=683"}} - attrMap[conventions.AttributeProcessCommandLine] = &otlpcommon.ArrayValue{ - Values: parts, - } + parts := pdata.NewAttributeValueArray() + parts.ArrayVal().Append(pdata.NewAttributeValueString("otelcol")) + parts.ArrayVal().Append(pdata.NewAttributeValueString("--config=/etc/otel-collector-config.yaml")) + parts.ArrayVal().Append(pdata.NewAttributeValueString("--mem-ballast-size-mib=683")) + attrMap["conventions.AttributeProcessCommandLine"] = parts attrMap[conventions.AttributeProcessExecutablePath] = "/usr/local/bin/otelcol" attrMap[conventions.AttributeProcessID] = 2020 attrMap[conventions.AttributeProcessOwner] = "otel" diff --git a/internal/goldendataset/resource_generator_test.go b/internal/goldendataset/resource_generator_test.go index d13a2dab9e3b4..2be3955c2501b 100644 --- a/internal/goldendataset/resource_generator_test.go +++ b/internal/goldendataset/resource_generator_test.go @@ -18,8 +18,6 @@ import ( "testing" "github.com/stretchr/testify/assert" - - otlpresource "go.opentelemetry.io/collector/internal/data/protogen/resource/v1" ) func TestGenerateResource(t *testing.T) { @@ -27,23 +25,10 @@ func TestGenerateResource(t *testing.T) { ResourceK8sCloud, ResourceFaas, ResourceExec} for _, rscID := range resourceIds { rsc := GenerateResource(rscID) - if rscID == ResourceNil { - assert.Nil(t, rsc.Attributes) + if rscID == ResourceNil || rscID == ResourceEmpty { + assert.Equal(t, 0, rsc.Attributes().Len()) } else { - assert.NotNil(t, rsc.Attributes) - } - // test marshal/unmarshal - bytes, err := rsc.Marshal() - if err != nil { - assert.Fail(t, err.Error()) - } - if len(bytes) > 0 { - copy := &otlpresource.Resource{} - err = copy.Unmarshal(bytes) - if err != nil { - assert.Fail(t, err.Error()) - } - assert.EqualValues(t, len(rsc.Attributes), len(copy.Attributes)) + assert.True(t, rsc.Attributes().Len() > 0) } } } diff --git a/internal/goldendataset/span_generator.go b/internal/goldendataset/span_generator.go index e9cd22354cde7..be93c8b243898 100644 --- a/internal/goldendataset/span_generator.go +++ b/internal/goldendataset/span_generator.go @@ -19,16 +19,14 @@ import ( "io" "time" - "go.opentelemetry.io/collector/internal/data" - otlpcommon "go.opentelemetry.io/collector/internal/data/protogen/common/v1" - otlptrace "go.opentelemetry.io/collector/internal/data/protogen/trace/v1" + "go.opentelemetry.io/collector/consumer/pdata" "go.opentelemetry.io/collector/translator/conventions" ) -var statusCodeMap = map[PICTInputStatus]otlptrace.Status_StatusCode{ - SpanStatusUnset: otlptrace.Status_STATUS_CODE_UNSET, - SpanStatusOk: otlptrace.Status_STATUS_CODE_OK, - SpanStatusError: otlptrace.Status_STATUS_CODE_ERROR, +var statusCodeMap = map[PICTInputStatus]pdata.StatusCode{ + SpanStatusUnset: pdata.StatusCodeUnset, + SpanStatusOk: pdata.StatusCodeOk, + SpanStatusError: pdata.StatusCodeError, } var statusMsgMap = map[PICTInputStatus]string{ @@ -37,7 +35,7 @@ var statusMsgMap = map[PICTInputStatus]string{ SpanStatusError: "Error", } -// GenerateSpans generates a slice of OTLP Span objects with the number of spans specified by the count input +// GenerateSpans generates a slice of pdata.Span objects with the number of spans specified by the count input // parameter. The startPos parameter specifies the line in the PICT tool-generated, test parameter // combination records file specified by the pictFile parameter to start reading from. When the end record // is reached it loops back to the first record. The random parameter injects the random number generator @@ -47,18 +45,18 @@ var statusMsgMap = map[PICTInputStatus]string{ // The return values are the slice with the generated spans, the starting position for the next generation // run and the error which caused the spans generation to fail. If err is not nil, the spans slice will // have nil values. -func GenerateSpans(count int, startPos int, pictFile string, random io.Reader) ([]*otlptrace.Span, int, error) { +func GenerateSpans(count int, startPos int, pictFile string, random io.Reader) ([]pdata.Span, int, error) { pairsData, err := loadPictOutputFile(pictFile) if err != nil { return nil, 0, err } pairsTotal := len(pairsData) - spanList := make([]*otlptrace.Span, count) + spanList := make([]pdata.Span, count) index := startPos + 1 var inputs []string var spanInputs *PICTSpanInputs - var traceID data.TraceID - var parentID data.SpanID + var traceID pdata.TraceID + var parentID pdata.SpanID for i := 0; i < count; i++ { if index >= pairsTotal { index = 1 @@ -75,20 +73,20 @@ func GenerateSpans(count int, startPos int, pictFile string, random io.Reader) ( } switch spanInputs.Parent { case SpanParentRoot: - traceID = generateTraceID(random) - parentID = data.NewSpanID([8]byte{}) + traceID = generatePDataTraceID(random) + parentID = pdata.NewSpanID([8]byte{}) case SpanParentChild: // use existing if available if traceID.IsEmpty() { - traceID = generateTraceID(random) + traceID = generatePDataTraceID(random) } if parentID.IsEmpty() { - parentID = generateSpanID(random) + parentID = generatePDataSpanID(random) } } spanName := generateSpanName(spanInputs) spanList[i] = GenerateSpan(traceID, parentID, spanName, spanInputs, random) - parentID = spanList[i].SpanId + parentID = spanList[i].SpanID() index++ } return spanList, index, nil @@ -99,7 +97,7 @@ func generateSpanName(spanInputs *PICTSpanInputs) string { spanInputs.Attributes, spanInputs.Events, spanInputs.Links, spanInputs.Status) } -// GenerateSpan generates a single OTLP Span based on the input values provided. They are: +// GenerateSpan generates a single pdata.Span based on the input values provided. They are: // traceID - the trace ID to use, should not be nil // parentID - the parent span ID or nil if it is a root span // spanName - the span name, should not be blank @@ -107,29 +105,38 @@ func generateSpanName(spanInputs *PICTSpanInputs) string { // random - the random number generator to use in generating ID values // // The generated span is returned. -func GenerateSpan(traceID data.TraceID, parentID data.SpanID, spanName string, spanInputs *PICTSpanInputs, - random io.Reader) *otlptrace.Span { +func GenerateSpan(traceID pdata.TraceID, parentID pdata.SpanID, spanName string, spanInputs *PICTSpanInputs, + random io.Reader) pdata.Span { endTime := time.Now().Add(-50 * time.Microsecond) - return &otlptrace.Span{ - TraceId: traceID, - SpanId: generateSpanID(random), - TraceState: generateTraceState(spanInputs.Tracestate), - ParentSpanId: parentID, - Name: spanName, - Kind: lookupSpanKind(spanInputs.Kind), - StartTimeUnixNano: uint64(endTime.Add(-215 * time.Millisecond).UnixNano()), - EndTimeUnixNano: uint64(endTime.UnixNano()), - Attributes: generateSpanAttributes(spanInputs.Attributes, spanInputs.Status), - DroppedAttributesCount: 0, - Events: generateSpanEvents(spanInputs.Events), - DroppedEventsCount: 0, - Links: generateSpanLinks(spanInputs.Links, random), - DroppedLinksCount: 0, - Status: generateStatus(spanInputs.Status), + span := pdata.NewSpan() + span.SetTraceID(traceID) + span.SetSpanID(generatePDataSpanID(random)) + span.SetTraceState(generateTraceState(spanInputs.Tracestate)) + span.SetParentSpanID(parentID) + span.SetName(spanName) + span.SetKind(lookupSpanKind(spanInputs.Kind)) + span.SetStartTimestamp(pdata.Timestamp(endTime.Add(-215 * time.Millisecond).UnixNano())) + span.SetEndTimestamp(pdata.Timestamp(endTime.UnixNano())) + spanAttributes := generateSpanAttributes(spanInputs.Attributes, spanInputs.Status) + if spanAttributes != nil { + spanAttributes.CopyTo(span.Attributes()) } + span.SetDroppedAttributesCount(0) + spanEvents := generateSpanEvents(spanInputs.Events) + if spanEvents != nil { + spanEvents.CopyTo(span.Events()) + } + span.SetDroppedEventsCount(0) + spanLinks := generateSpanLinks(spanInputs.Links, random) + if spanLinks != nil { + spanLinks.CopyTo(span.Links()) + } + span.SetDroppedLinksCount(0) + generateStatus(spanInputs.Status).CopyTo(span.Status()) + return span } -func generateTraceState(tracestate PICTInputTracestate) string { +func generateTraceState(tracestate PICTInputTracestate) pdata.TraceState { switch tracestate { case TraceStateOne: return "lasterror=f39cd56cc44274fd5abd07ef1164246d10ce2955" @@ -142,26 +149,26 @@ func generateTraceState(tracestate PICTInputTracestate) string { } } -func lookupSpanKind(kind PICTInputKind) otlptrace.Span_SpanKind { +func lookupSpanKind(kind PICTInputKind) pdata.SpanKind { switch kind { case SpanKindClient: - return otlptrace.Span_SPAN_KIND_CLIENT + return pdata.SpanKindClient case SpanKindServer: - return otlptrace.Span_SPAN_KIND_SERVER + return pdata.SpanKindServer case SpanKindProducer: - return otlptrace.Span_SPAN_KIND_PRODUCER + return pdata.SpanKindProducer case SpanKindConsumer: - return otlptrace.Span_SPAN_KIND_CONSUMER + return pdata.SpanKindConsumer case SpanKindInternal: - return otlptrace.Span_SPAN_KIND_INTERNAL + return pdata.SpanKindInternal case SpanKindUnspecified: fallthrough default: - return otlptrace.Span_SPAN_KIND_UNSPECIFIED + return pdata.SpanKindUnspecified } } -func generateSpanAttributes(spanTypeID PICTInputAttributes, statusStr PICTInputStatus) []otlpcommon.KeyValue { +func generateSpanAttributes(spanTypeID PICTInputAttributes, statusStr PICTInputStatus) *pdata.AttributeMap { includeStatus := SpanStatusUnset != statusStr var attrs map[string]interface{} switch spanTypeID { @@ -202,17 +209,17 @@ func generateSpanAttributes(spanTypeID PICTInputAttributes, statusStr PICTInputS default: attrs = generateGRPCClientAttributes() } - return convertMapToAttributeKeyValues(attrs) + return convertMapToAttributeMap(attrs) } -func generateStatus(statusStr PICTInputStatus) otlptrace.Status { +func generateStatus(statusStr PICTInputStatus) pdata.SpanStatus { if SpanStatusUnset == statusStr { - return otlptrace.Status{} - } - return otlptrace.Status{ - Code: statusCodeMap[statusStr], - Message: statusMsgMap[statusStr], + return pdata.NewSpanStatus() } + spanStatus := pdata.NewSpanStatus() + spanStatus.SetCode(statusCodeMap[statusStr]) + spanStatus.SetMessage(statusMsgMap[statusStr]) + return spanStatus } func generateDatabaseSQLAttributes() map[string]interface{} { @@ -408,20 +415,16 @@ func generateMaxCountAttributes(includeStatus bool) map[string]interface{} { attrMap["ai-sampler.absolute"] = false attrMap["ai-sampler.maxhops"] = int64(6) attrMap["application.create.location"] = "https://api.opentelemetry.io/blog/posts/806673B9-4F4D-4284-9635-3A3E3E3805BE" - stages := make([]otlpcommon.AnyValue, 3) - stages[0] = otlpcommon.AnyValue{Value: &otlpcommon.AnyValue_StringValue{StringValue: "Launch"}} - stages[1] = otlpcommon.AnyValue{Value: &otlpcommon.AnyValue_StringValue{StringValue: "Injestion"}} - stages[2] = otlpcommon.AnyValue{Value: &otlpcommon.AnyValue_StringValue{StringValue: "Validation"}} - attrMap["application.stages"] = &otlpcommon.ArrayValue{ - Values: stages, - } - subMap := make(map[string]interface{}) - subMap["UIx"] = false - subMap["UI4"] = true - subMap["flow-alt3"] = false - attrMap["application.abflags"] = &otlpcommon.KeyValueList{ - Values: convertMapToAttributeKeyValues(subMap), - } + stages := pdata.NewAttributeValueArray() + stages.ArrayVal().Append(pdata.NewAttributeValueString("Launch")) + stages.ArrayVal().Append(pdata.NewAttributeValueString("Injestion")) + stages.ArrayVal().Append(pdata.NewAttributeValueString("Validation")) + attrMap["application.stages"] = stages + subMap := pdata.NewAttributeMap() + subMap.InsertBool("UIx", false) + subMap.InsertBool("UI4", true) + subMap.InsertBool("flow-alt3", false) + attrMap["application.abflags"] = subMap attrMap["application.thread"] = "proc-pool-14" attrMap["application.session"] = "" attrMap["application.persist.size"] = int64(1172184) @@ -435,28 +438,28 @@ func generateMaxCountAttributes(includeStatus bool) map[string]interface{} { return attrMap } -func generateSpanEvents(eventCnt PICTInputSpanChild) []*otlptrace.Span_Event { +func generateSpanEvents(eventCnt PICTInputSpanChild) *pdata.SpanEventSlice { + spanEvents := pdata.NewSpanEventSlice() if SpanChildCountNil == eventCnt { return nil } listSize := calculateListSize(eventCnt) - eventList := make([]*otlptrace.Span_Event, listSize) for i := 0; i < listSize; i++ { - eventList[i] = generateSpanEvent(i) + spanEvents.Append(generateSpanEvent(i)) } - return eventList + return &spanEvents } -func generateSpanLinks(linkCnt PICTInputSpanChild, random io.Reader) []*otlptrace.Span_Link { +func generateSpanLinks(linkCnt PICTInputSpanChild, random io.Reader) *pdata.SpanLinkSlice { + spanLinks := pdata.NewSpanLinkSlice() if SpanChildCountNil == linkCnt { return nil } listSize := calculateListSize(linkCnt) - linkList := make([]*otlptrace.Span_Link, listSize) for i := 0; i < listSize; i++ { - linkList[i] = generateSpanLink(random, i) + spanLinks.Append(generateSpanLink(random, i)) } - return linkList + return &spanLinks } func calculateListSize(listCnt PICTInputSpanChild) int { @@ -474,18 +477,20 @@ func calculateListSize(listCnt PICTInputSpanChild) int { } } -func generateSpanEvent(index int) *otlptrace.Span_Event { +func generateSpanEvent(index int) pdata.SpanEvent { + spanEvent := pdata.NewSpanEvent() t := time.Now().Add(-75 * time.Microsecond) name, attributes := generateEventNameAndAttributes(index) - return &otlptrace.Span_Event{ - TimeUnixNano: uint64(t.UnixNano()), - Name: name, - Attributes: attributes, - DroppedAttributesCount: 0, + spanEvent.SetTimestamp(pdata.Timestamp(t.UnixNano())) + spanEvent.SetName(name) + if attributes != nil { + attributes.CopyTo(spanEvent.Attributes()) } + spanEvent.SetDroppedAttributesCount(0) + return spanEvent } -func generateEventNameAndAttributes(index int) (string, []otlpcommon.KeyValue) { +func generateEventNameAndAttributes(index int) (string, *pdata.AttributeMap) { switch index % 4 { case 0, 3: attrMap := make(map[string]interface{}) @@ -497,9 +502,9 @@ func generateEventNameAndAttributes(index int) (string, []otlpcommon.KeyValue) { attrMap[conventions.AttributeMessageID] = int64(index / 4) attrMap[conventions.AttributeMessageCompressedSize] = int64(17 * index) attrMap[conventions.AttributeMessageUncompressedSize] = int64(24 * index) - return "message", convertMapToAttributeKeyValues(attrMap) + return "message", convertMapToAttributeMap(attrMap) case 1: - return "custom", convertMapToAttributeKeyValues(map[string]interface{}{ + return "custom", convertMapToAttributeMap(map[string]interface{}{ "app.inretry": true, "app.progress": 0.6, "app.statemap": "14|5|202"}) @@ -508,17 +513,19 @@ func generateEventNameAndAttributes(index int) (string, []otlpcommon.KeyValue) { } } -func generateSpanLink(random io.Reader, index int) *otlptrace.Span_Link { - return &otlptrace.Span_Link{ - TraceId: generateTraceID(random), - SpanId: generateSpanID(random), - TraceState: "", - Attributes: generateLinkAttributes(index), - DroppedAttributesCount: 0, +func generateSpanLink(random io.Reader, index int) pdata.SpanLink { + spanLink := pdata.NewSpanLink() + spanLink.SetTraceID(generatePDataTraceID(random)) + spanLink.SetSpanID(generatePDataSpanID(random)) + spanLink.SetTraceState("") + if index%4 != 2 { + generateLinkAttributes(index).CopyTo(spanLink.Attributes()) } + spanLink.SetDroppedAttributesCount(0) + return spanLink } -func generateLinkAttributes(index int) []otlpcommon.KeyValue { +func generateLinkAttributes(index int) *pdata.AttributeMap { if index%4 == 2 { return nil } @@ -528,5 +535,5 @@ func generateLinkAttributes(index int) []otlpcommon.KeyValue { attrMap["app.progress"] = 0.6 attrMap["app.statemap"] = "14|5|202" } - return convertMapToAttributeKeyValues(attrMap) + return convertMapToAttributeMap(attrMap) } diff --git a/internal/goldendataset/span_generator_test.go b/internal/goldendataset/span_generator_test.go index 1a54836712fc2..2a1ff8ef4f21a 100644 --- a/internal/goldendataset/span_generator_test.go +++ b/internal/goldendataset/span_generator_test.go @@ -20,13 +20,12 @@ import ( "github.com/stretchr/testify/assert" - "go.opentelemetry.io/collector/internal/data" - otlptrace "go.opentelemetry.io/collector/internal/data/protogen/trace/v1" + "go.opentelemetry.io/collector/consumer/pdata" ) func TestGenerateParentSpan(t *testing.T) { random := rand.Reader - traceID := generateTraceID(random) + traceID := generatePDataTraceID(random) spanInputs := &PICTSpanInputs{ Parent: SpanParentRoot, Tracestate: TraceStateEmpty, @@ -36,17 +35,17 @@ func TestGenerateParentSpan(t *testing.T) { Links: SpanChildCountOne, Status: SpanStatusOk, } - span := GenerateSpan(traceID, data.NewSpanID([8]byte{}), "/gotest-parent", spanInputs, random) - assert.Equal(t, traceID, span.TraceId) - assert.True(t, span.ParentSpanId.IsEmpty()) - assert.Equal(t, 11, len(span.Attributes)) - assert.Equal(t, otlptrace.Status_STATUS_CODE_OK, span.Status.Code) + span := GenerateSpan(traceID, pdata.NewSpanID([8]byte{}), "/gotest-parent", spanInputs, random) + assert.Equal(t, traceID, span.TraceID()) + assert.True(t, span.ParentSpanID().IsEmpty()) + assert.Equal(t, 11, span.Attributes().Len()) + assert.Equal(t, pdata.StatusCodeOk, span.Status().Code()) } func TestGenerateChildSpan(t *testing.T) { random := rand.Reader - traceID := generateTraceID(random) - parentID := generateSpanID(random) + traceID := generatePDataTraceID(random) + parentID := generatePDataSpanID(random) spanInputs := &PICTSpanInputs{ Parent: SpanParentChild, Tracestate: TraceStateEmpty, @@ -57,10 +56,10 @@ func TestGenerateChildSpan(t *testing.T) { Status: SpanStatusOk, } span := GenerateSpan(traceID, parentID, "get_test_info", spanInputs, random) - assert.Equal(t, traceID, span.TraceId) - assert.Equal(t, parentID, span.ParentSpanId) - assert.Equal(t, 12, len(span.Attributes)) - assert.Equal(t, otlptrace.Status_STATUS_CODE_OK, span.Status.Code) + assert.Equal(t, traceID, span.TraceID()) + assert.Equal(t, parentID, span.ParentSpanID()) + assert.Equal(t, 12, span.Attributes().Len()) + assert.Equal(t, pdata.StatusCodeOk, span.Status().Code()) } func TestGenerateSpans(t *testing.T) { diff --git a/internal/goldendataset/traces_generator.go b/internal/goldendataset/traces_generator.go index 4cbd807f915a9..0078060802d7f 100644 --- a/internal/goldendataset/traces_generator.go +++ b/internal/goldendataset/traces_generator.go @@ -20,10 +20,6 @@ import ( "math/rand" "go.opentelemetry.io/collector/consumer/pdata" - "go.opentelemetry.io/collector/internal" - otlpcollectortrace "go.opentelemetry.io/collector/internal/data/protogen/collector/trace/v1" - otlpcommon "go.opentelemetry.io/collector/internal/data/protogen/common/v1" - otlptrace "go.opentelemetry.io/collector/internal/data/protogen/trace/v1" ) // GenerateTraces generates a slice of OTLP ResourceSpans objects based on the PICT-generated pairwise @@ -51,31 +47,31 @@ func GenerateTraces(tracePairsFile string, spanPairsFile string) ([]pdata.Traces if spanErr != nil { err = spanErr } - traces[index-1] = pdata.TracesFromInternalRep( - internal.TracesFromOtlp(&otlpcollectortrace.ExportTraceServiceRequest{ - ResourceSpans: []*otlptrace.ResourceSpans{rscSpan}, - })) + resourceSpansSlice := pdata.NewResourceSpansSlice() + resourceSpansSlice.Append(rscSpan) + traces[index-1] = pdata.NewTraces() + resourceSpansSlice.CopyTo(traces[index-1].ResourceSpans()) } return traces, err } -// generateResourceSpan generates a single OTLP ResourceSpans populated based on the provided inputs. They are: +// generateResourceSpan generates a single PData ResourceSpans populated based on the provided inputs. They are: // tracingInputs - the pairwise combination of field value variations for this ResourceSpans // spanPairsFile - the file with the PICT-generated parameter combinations to generate spans for // random - the random number generator to use in generating ID values // // The generated resource spans. If err is not nil, some or all of the resource spans fields will be nil. func generateResourceSpan(tracingInputs *PICTTracingInputs, spanPairsFile string, - random io.Reader) (*otlptrace.ResourceSpans, error) { - libSpans, err := generateLibrarySpansArray(tracingInputs, spanPairsFile, random) - return &otlptrace.ResourceSpans{ - Resource: GenerateResource(tracingInputs.Resource), - InstrumentationLibrarySpans: libSpans, - }, err + random io.Reader) (pdata.ResourceSpans, error) { + resourceSpan := pdata.NewResourceSpans() + libSpansSlice, err := generateLibrarySpansArray(tracingInputs, spanPairsFile, random) + libSpansSlice.CopyTo(resourceSpan.InstrumentationLibrarySpans()) + GenerateResource(tracingInputs.Resource).CopyTo(resourceSpan.Resource()) + return resourceSpan, err } func generateLibrarySpansArray(tracingInputs *PICTTracingInputs, spanPairsFile string, - random io.Reader) ([]*otlptrace.InstrumentationLibrarySpans, error) { + random io.Reader) (pdata.InstrumentationLibrarySpansSlice, error) { var count int switch tracingInputs.InstrumentationLibrary { case LibraryNone: @@ -86,23 +82,28 @@ func generateLibrarySpansArray(tracingInputs *PICTTracingInputs, spanPairsFile s count = 2 } var err error - libSpans := make([]*otlptrace.InstrumentationLibrarySpans, count) + var libSpans *pdata.InstrumentationLibrarySpans + instrumentationLibrarySpansSlice := pdata.NewInstrumentationLibrarySpansSlice() for i := 0; i < count; i++ { - libSpans[i], err = generateLibrarySpans(tracingInputs, i, spanPairsFile, random) + libSpans, err = generateLibrarySpans(tracingInputs, i, spanPairsFile, random) + if err != nil { + instrumentationLibrarySpansSlice.Append(*libSpans) + } } - return libSpans, err + return instrumentationLibrarySpansSlice, err } func generateLibrarySpans(tracingInputs *PICTTracingInputs, index int, spanPairsFile string, - random io.Reader) (*otlptrace.InstrumentationLibrarySpans, error) { + random io.Reader) (*pdata.InstrumentationLibrarySpans, error) { + instrumentationLibrarySpans := pdata.NewInstrumentationLibrarySpans() spanCaseCount, err := countTotalSpanCases(spanPairsFile) if err != nil { return nil, err } - var spans []*otlptrace.Span + var spans []pdata.Span switch tracingInputs.Spans { case LibrarySpansNone: - spans = make([]*otlptrace.Span, 0) + spans = make([]pdata.Span, 0) case LibrarySpansOne: spans, _, err = GenerateSpans(1, 0, spanPairsFile, random) case LibrarySpansSeveral: @@ -112,10 +113,13 @@ func generateLibrarySpans(tracingInputs *PICTTracingInputs, index int, spanPairs default: spans, _, err = GenerateSpans(16, 0, spanPairsFile, random) } - return &otlptrace.InstrumentationLibrarySpans{ - InstrumentationLibrary: generateInstrumentationLibrary(tracingInputs, index), - Spans: spans, - }, err + spanSlice := pdata.NewSpanSlice() + for _, span := range spans { + spanSlice.Append(span) + } + generateInstrumentationLibrary(tracingInputs, index).CopyTo(instrumentationLibrarySpans.InstrumentationLibrary()) + spanSlice.CopyTo(instrumentationLibrarySpans.Spans()) + return &instrumentationLibrarySpans, err } func countTotalSpanCases(spanPairsFile string) (int, error) { @@ -127,9 +131,10 @@ func countTotalSpanCases(spanPairsFile string) (int, error) { return count, err } -func generateInstrumentationLibrary(tracingInputs *PICTTracingInputs, index int) otlpcommon.InstrumentationLibrary { +func generateInstrumentationLibrary(tracingInputs *PICTTracingInputs, index int) pdata.InstrumentationLibrary { + instrumentationLibrary := pdata.NewInstrumentationLibrary() if LibraryNone == tracingInputs.InstrumentationLibrary { - return otlpcommon.InstrumentationLibrary{} + return instrumentationLibrary } nameStr := fmt.Sprintf("%s-%s-%s-%d", tracingInputs.Resource, tracingInputs.InstrumentationLibrary, tracingInputs.Spans, index) @@ -137,8 +142,7 @@ func generateInstrumentationLibrary(tracingInputs *PICTTracingInputs, index int) if index > 0 { verStr = "" } - return otlpcommon.InstrumentationLibrary{ - Name: nameStr, - Version: verStr, - } + instrumentationLibrary.SetName(nameStr) + instrumentationLibrary.SetVersion(verStr) + return instrumentationLibrary } diff --git a/translator/internaldata/resource_to_oc_test.go b/translator/internaldata/resource_to_oc_test.go index 2eadb14c9c125..dc8765ec2c231 100644 --- a/translator/internaldata/resource_to_oc_test.go +++ b/translator/internaldata/resource_to_oc_test.go @@ -28,9 +28,6 @@ import ( "google.golang.org/protobuf/testing/protocmp" "go.opentelemetry.io/collector/consumer/pdata" - "go.opentelemetry.io/collector/internal" - otlpcollectortrace "go.opentelemetry.io/collector/internal/data/protogen/collector/trace/v1" - otlptrace "go.opentelemetry.io/collector/internal/data/protogen/trace/v1" "go.opentelemetry.io/collector/internal/goldendataset" "go.opentelemetry.io/collector/internal/occonventions" "go.opentelemetry.io/collector/translator/conventions" @@ -206,9 +203,8 @@ func TestResourceToOCAndBack(t *testing.T) { } for _, test := range tests { t.Run(string(test), func(t *testing.T) { - traces := pdata.TracesFromInternalRep(internal.TracesFromOtlp(&otlpcollectortrace.ExportTraceServiceRequest{ - ResourceSpans: []*otlptrace.ResourceSpans{{Resource: goldendataset.GenerateResource(test)}}, - })) + traces := pdata.NewTraces() + goldendataset.GenerateResource(test).CopyTo(traces.ResourceSpans().AppendEmpty().Resource()) expected := traces.ResourceSpans().At(0).Resource() ocNode, ocResource := internalResourceToOC(expected) actual := pdata.NewResource()