[exporter/awsxray] Add span links and messenger field translation to …

…x-ray exporter. (open-telemetry#20313)

Add link span link support and support for the messaging field.

We are conforming to the OTel spec:
- https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/api.md#specifying-links
- https://github.com/open-telemetry/opentelemetry-specification/blob/main/semantic_conventions/trace/messaging.yaml#L110

.chloggen/awsxray-support-span-links-and-messaging-field.yaml

@@ -0,0 +1,16 @@
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: enhancement
+
+# The name of the component, or a single word describing the area of concern, (e.g. filelogreceiver)
+component: awsxrayexporter
+
+# A brief description of the change. Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Adding translation support for span links for the aws x-ray exporter
+
+# One or more tracking issues related to the change
+issues: [20353]
+
+# (Optional) One or more lines of additional information to render under the primary note.
+# These lines will be padded with 2 spaces and then inserted directly into the document.
+# Use pipe (|) for multiline entries.
+subtext:

.gitignore

@@ -1,4 +1,5 @@
 local/
+vendor/
 
 # GoLand IDEA
 /.idea/

exporter/awsxrayexporter/internal/translator/segment.go

@@ -107,10 +107,15 @@ func MakeSegment(span ptrace.Span, resource pcommon.Resource, indexedAttrs []str
  sqlfiltered, sql = makeSQL(span, awsfiltered)
  additionalAttrs = addSpecialAttributes(sqlfiltered, indexedAttrs, attributes)
  user, annotations, metadata = makeXRayAttributes(additionalAttrs, resource, storeResource, indexedAttrs, indexAllAttrs)
+ spanLinks, makeSpanLinkErr = makeSpanLinks(span.Links())
  name string
  namespace string
  )
 
+ if makeSpanLinkErr != nil {
+ return nil, makeSpanLinkErr
+ }
+
  // X-Ray segment names are service names, unlike span names which are methods. Try to find a service name.
 
  // support x-ray specific service name attributes as segment name if it exists
@@ -221,6 +226,7 @@ func MakeSegment(span ptrace.Span, resource pcommon.Resource, indexedAttrs []str
  Annotations: annotations,
  Metadata: metadata,
  Type: awsxray.String(segmentType),
+ Links: spanLinks,
  }, nil
 }
 

exporter/awsxrayexporter/internal/translator/span_links.go

@@ -0,0 +1,43 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package translator // import "github.com/open-telemetry/opentelemetry-collector-contrib/exporter/awsxrayexporter/internal/translator"
+
+import (
+ "go.opentelemetry.io/collector/pdata/pcommon"
+ "go.opentelemetry.io/collector/pdata/ptrace"
+
+ awsxray "github.com/open-telemetry/opentelemetry-collector-contrib/internal/aws/xray"
+)
+
+func makeSpanLinks(links ptrace.SpanLinkSlice) ([]awsxray.SpanLinkData, error) {
+ var spanLinkDataArray []awsxray.SpanLinkData
+
+ for i := 0; i < links.Len(); i++ {
+ var spanLinkData awsxray.SpanLinkData
+ var link = links.At(i)
+
+ var spanID = link.SpanID().String()
+ traceID, err := convertToAmazonTraceID(link.TraceID())
+
+ if err != nil {
+ return nil, err
+ }
+
+ spanLinkData.SpanID = &spanID
+ spanLinkData.TraceID = &traceID
+
+ if link.Attributes().Len() > 0 {
+ spanLinkData.Attributes = make(map[string]interface{})
+
+ link.Attributes().Range(func(k string, v pcommon.Value) bool {
+ spanLinkData.Attributes[k] = v.AsRaw()
+ return true
+ })
+ }
+
+ spanLinkDataArray = append(spanLinkDataArray, spanLinkData)
+ }
+
+ return spanLinkDataArray, nil
+}

exporter/awsxrayexporter/internal/translator/span_links_test.go

@@ -0,0 +1,231 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package translator // import "github.com/open-telemetry/opentelemetry-collector-contrib/exporter/awsxrayexporter/internal/translator"
+
+import (
+ "encoding/binary"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/stretchr/testify/assert"
+ "go.opentelemetry.io/collector/pdata/ptrace"
+)
+
+func TestSpanLinkSimple(t *testing.T) {
+ spanName := "ProcessingMessage"
+ parentSpanID := newSegmentID()
+ attributes := make(map[string]interface{})
+ resource := constructDefaultResource()
+ span := constructServerSpan(parentSpanID, spanName, ptrace.StatusCodeOk, "OK", attributes)
+
+ var traceID = newTraceID()
+
+ spanLink := span.Links().AppendEmpty()
+ spanLink.SetTraceID(traceID)
+ spanLink.SetSpanID(newSegmentID())
+
+ segment, _ := MakeSegment(span, resource, nil, false, nil)
+
+ var convertedTraceID, _ = convertToAmazonTraceID(traceID)
+
+ assert.Equal(t, 1, len(segment.Links))
+ assert.Equal(t, spanLink.SpanID().String(), *segment.Links[0].SpanID)
+ assert.Equal(t, convertedTraceID, *segment.Links[0].TraceID)
+ assert.Equal(t, 0, len(segment.Links[0].Attributes))
+
+ jsonStr, _ := MakeSegmentDocumentString(span, resource, nil, false, nil)
+
+ assert.True(t, strings.Contains(jsonStr, "links"))
+ assert.False(t, strings.Contains(jsonStr, "attributes"))
+ assert.True(t, strings.Contains(jsonStr, convertedTraceID))
+ assert.True(t, strings.Contains(jsonStr, spanLink.SpanID().String()))
+}
+
+func TestSpanLinkEmpty(t *testing.T) {
+ spanName := "ProcessingMessage"
+ parentSpanID := newSegmentID()
+ attributes := make(map[string]interface{})
+ resource := constructDefaultResource()
+ span := constructServerSpan(parentSpanID, spanName, ptrace.StatusCodeOk, "OK", attributes)
+
+ segment, _ := MakeSegment(span, resource, nil, false, nil)
+
+ assert.Equal(t, 0, len(segment.Links))
+
+ jsonStr, _ := MakeSegmentDocumentString(span, resource, nil, false, nil)
+
+ assert.False(t, strings.Contains(jsonStr, "links"))
+}
+
+func TestOldSpanLinkError(t *testing.T) {
+ spanName := "ProcessingMessage"
+ parentSpanID := newSegmentID()
+ attributes := make(map[string]interface{})
+ resource := constructDefaultResource()
+ span := constructServerSpan(parentSpanID, spanName, ptrace.StatusCodeOk, "OK", attributes)
+
+ const maxAge = 60 * 60 * 24 * 30
+ ExpiredEpoch := time.Now().Unix() - maxAge - 1
+
+ var traceID = newTraceID()
+ binary.BigEndian.PutUint32(traceID[0:4], uint32(ExpiredEpoch))
+
+ spanLink := span.Links().AppendEmpty()
+ spanLink.SetTraceID(traceID)
+ spanLink.SetSpanID(newSegmentID())
+
+ _, error1 := MakeSegment(span, resource, nil, false, nil)
+
+ assert.NotNil(t, error1)
+
+ _, error2 := MakeSegmentDocumentString(span, resource, nil, false, nil)
+
+ assert.NotNil(t, error2)
+}
+
+func TestTwoSpanLinks(t *testing.T) {
+ spanName := "ProcessingMessage"
+ parentSpanID := newSegmentID()
+ attributes := make(map[string]interface{})
+ resource := constructDefaultResource()
+ span := constructServerSpan(parentSpanID, spanName, ptrace.StatusCodeOk, "OK", attributes)
+
+ var traceID1 = newTraceID()
+
+ spanLink1 := span.Links().AppendEmpty()
+ spanLink1.SetTraceID(traceID1)
+ spanLink1.SetSpanID(newSegmentID())
+ spanLink1.Attributes().PutStr("myKey1", "ABC")
+
+ var traceID2 = newTraceID()
+
+ spanLink2 := span.Links().AppendEmpty()
+ spanLink2.SetTraceID(traceID2)
+ spanLink2.SetSpanID(newSegmentID())
+ spanLink2.Attributes().PutInt("myKey2", 1234)
+
+ segment, _ := MakeSegment(span, resource, nil, false, nil)
+
+ var convertedTraceID1, _ = convertToAmazonTraceID(traceID1)
+ var convertedTraceID2, _ = convertToAmazonTraceID(traceID2)
+
+ assert.Equal(t, 2, len(segment.Links))
+ assert.Equal(t, spanLink1.SpanID().String(), *segment.Links[0].SpanID)
+ assert.Equal(t, convertedTraceID1, *segment.Links[0].TraceID)
+
+ assert.Equal(t, 1, len(segment.Links[0].Attributes))
+ assert.Equal(t, "ABC", segment.Links[0].Attributes["myKey1"])
+
+ assert.Equal(t, spanLink2.SpanID().String(), *segment.Links[1].SpanID)
+ assert.Equal(t, convertedTraceID2, *segment.Links[1].TraceID)
+ assert.Equal(t, 1, len(segment.Links[0].Attributes))
+ assert.Equal(t, int64(1234), segment.Links[1].Attributes["myKey2"])
+
+ jsonStr, _ := MakeSegmentDocumentString(span, resource, nil, false, nil)
+
+ assert.True(t, strings.Contains(jsonStr, "attributes"))
+ assert.True(t, strings.Contains(jsonStr, "links"))
+ assert.True(t, strings.Contains(jsonStr, "myKey1"))
+ assert.True(t, strings.Contains(jsonStr, "myKey2"))
+ assert.True(t, strings.Contains(jsonStr, "ABC"))
+ assert.True(t, strings.Contains(jsonStr, "1234"))
+ assert.True(t, strings.Contains(jsonStr, convertedTraceID1))
+ assert.True(t, strings.Contains(jsonStr, convertedTraceID2))
+}
+
+func TestSpanLinkComplexAttributes(t *testing.T) {
+ spanName := "ProcessingMessage"
+ parentSpanID := newSegmentID()
+ attributes := make(map[string]interface{})
+ resource := constructDefaultResource()
+ span := constructServerSpan(parentSpanID, spanName, ptrace.StatusCodeOk, "OK", attributes)
+
+ spanLink := span.Links().AppendEmpty()
+ spanLink.SetTraceID(newTraceID())
+ spanLink.SetSpanID(newSegmentID())
+ spanLink.Attributes().PutStr("myKey1", "myValue")
+ spanLink.Attributes().PutBool("myKey2", true)
+ spanLink.Attributes().PutInt("myKey3", 112233)
+ spanLink.Attributes().PutDouble("myKey4", 3.1415)
+
+ var slice1 = spanLink.Attributes().PutEmptySlice("myKey5")
+ slice1.AppendEmpty().SetStr("apple")
+ slice1.AppendEmpty().SetStr("pear")
+ slice1.AppendEmpty().SetStr("banana")
+
+ var slice2 = spanLink.Attributes().PutEmptySlice("myKey6")
+ slice2.AppendEmpty().SetBool(true)
+ slice2.AppendEmpty().SetBool(false)
+ slice2.AppendEmpty().SetBool(false)
+ slice2.AppendEmpty().SetBool(true)
+
+ var slice3 = spanLink.Attributes().PutEmptySlice("myKey7")
+ slice3.AppendEmpty().SetInt(1234)
+ slice3.AppendEmpty().SetInt(5678)
+ slice3.AppendEmpty().SetInt(9012)
+
+ var slice4 = spanLink.Attributes().PutEmptySlice("myKey8")
+ slice4.AppendEmpty().SetDouble(2.718)
+ slice4.AppendEmpty().SetDouble(1.618)
+
+ segment, _ := MakeSegment(span, resource, nil, false, nil)
+
+ assert.Equal(t, 1, len(segment.Links))
+ assert.Equal(t, 8, len(segment.Links[0].Attributes))
+
+ assert.Equal(t, "myValue", segment.Links[0].Attributes["myKey1"])
+ assert.Equal(t, true, segment.Links[0].Attributes["myKey2"])
+ assert.Equal(t, int64(112233), segment.Links[0].Attributes["myKey3"])
+ assert.Equal(t, 3.1415, segment.Links[0].Attributes["myKey4"])
+
+ assert.Equal(t, "apple", segment.Links[0].Attributes["myKey5"].([]interface{})[0])
+ assert.Equal(t, "pear", segment.Links[0].Attributes["myKey5"].([]interface{})[1])
+ assert.Equal(t, "banana", segment.Links[0].Attributes["myKey5"].([]interface{})[2])
+
+ assert.Equal(t, true, segment.Links[0].Attributes["myKey6"].([]interface{})[0])
+ assert.Equal(t, false, segment.Links[0].Attributes["myKey6"].([]interface{})[1])
+ assert.Equal(t, false, segment.Links[0].Attributes["myKey6"].([]interface{})[2])
+ assert.Equal(t, true, segment.Links[0].Attributes["myKey6"].([]interface{})[0])
+
+ assert.Equal(t, int64(1234), segment.Links[0].Attributes["myKey7"].([]interface{})[0])
+ assert.Equal(t, int64(5678), segment.Links[0].Attributes["myKey7"].([]interface{})[1])
+ assert.Equal(t, int64(9012), segment.Links[0].Attributes["myKey7"].([]interface{})[2])
+
+ assert.Equal(t, 2.718, segment.Links[0].Attributes["myKey8"].([]interface{})[0])
+ assert.Equal(t, 1.618, segment.Links[0].Attributes["myKey8"].([]interface{})[1])
+
+ jsonStr, _ := MakeSegmentDocumentString(span, resource, nil, false, nil)
+
+ assert.True(t, strings.Contains(jsonStr, "links"))
+
+ assert.True(t, strings.Contains(jsonStr, "myKey1"))
+ assert.True(t, strings.Contains(jsonStr, "myValue"))
+
+ assert.True(t, strings.Contains(jsonStr, "myKey2"))
+ assert.True(t, strings.Contains(jsonStr, "true"))
+
+ assert.True(t, strings.Contains(jsonStr, "myKey3"))
+ assert.True(t, strings.Contains(jsonStr, "112233"))
+
+ assert.True(t, strings.Contains(jsonStr, "myKey4"))
+ assert.True(t, strings.Contains(jsonStr, "3.1415"))
+
+ assert.True(t, strings.Contains(jsonStr, "myKey5"))
+ assert.True(t, strings.Contains(jsonStr, "apple"))
+ assert.True(t, strings.Contains(jsonStr, "pear"))
+ assert.True(t, strings.Contains(jsonStr, "banana"))
+
+ assert.True(t, strings.Contains(jsonStr, "myKey6"))
+ assert.True(t, strings.Contains(jsonStr, "false"))
+
+ assert.True(t, strings.Contains(jsonStr, "myKey7"))
+ assert.True(t, strings.Contains(jsonStr, "1234"))
+ assert.True(t, strings.Contains(jsonStr, "5678"))
+ assert.True(t, strings.Contains(jsonStr, "9012"))
+
+ assert.True(t, strings.Contains(jsonStr, "myKey8"))
+ assert.True(t, strings.Contains(jsonStr, "2.718"))
+ assert.True(t, strings.Contains(jsonStr, "1.618"))
+}

internal/aws/xray/tracesegment.go

@@ -29,10 +29,11 @@ type Segment struct {
  StartTime *float64 `json:"start_time"`
 
  // Segment-only optional fields
- Service *ServiceData `json:"service,omitempty"`
- Origin *string `json:"origin,omitempty"`
- User *string `json:"user,omitempty"`
- ResourceARN *string `json:"resource_arn,omitempty"`
+ Service *ServiceData `json:"service,omitempty"`
+ Origin *string `json:"origin,omitempty"`
+ User *string `json:"user,omitempty"`
+ ResourceARN *string `json:"resource_arn,omitempty"`
+ Links []SpanLinkData `json:"links,omitempty"`
 
  // Optional fields for both Segment and subsegments
  TraceID *string `json:"trace_id,omitempty"`
@@ -265,3 +266,10 @@ type ServiceData struct {
  CompilerVersion *string `json:"compiler_version,omitempty"`
  Compiler *string `json:"compiler,omitempty"`
 }
+
+// SpanLinkData provides the shape for unmarshalling the span links in the span link field.
+type SpanLinkData struct {
+ TraceID *string `json:"trace_id"`
+ SpanID *string `json:"id"`
+ Attributes map[string]interface{} `json:"attributes,omitempty"`
+}