Add transaction.{sampled, type} as span event attribute

Author: lahsivjar

enrichments/trace/config/config.go

@@ -79,8 +79,10 @@ type SpanEventConfig struct {
 	// TimestampUs is a temporary attribute to enable higher
 	// resolution timestamps in Elasticsearch. For more details see:
 	// https://github.com/elastic/opentelemetry-dev/issues/374.
-	TimestampUs    AttributeConfig `mapstructure:"timestamp_us"`
-	ProcessorEvent AttributeConfig `mapstructure:"processor_event"`
+	TimestampUs        AttributeConfig `mapstructure:"timestamp_us"`
+	TransactionSampled AttributeConfig `mapstructure:"transaction_sampled"`
+	TransactionType    AttributeConfig `mapstructure:"transaction_type"`
+	ProcessorEvent     AttributeConfig `mapstructure:"processor_event"`
 
 	// For exceptions/errors
 	ErrorID               AttributeConfig `mapstructure:"error_id"`
@@ -133,6 +135,8 @@ func Enabled() Config {
 		},
 		SpanEvent: SpanEventConfig{
 			TimestampUs:           AttributeConfig{Enabled: true},
+			TransactionSampled:    AttributeConfig{Enabled: true},
+			TransactionType:       AttributeConfig{Enabled: true},
 			ProcessorEvent:        AttributeConfig{Enabled: true},
 			ErrorID:               AttributeConfig{Enabled: true},
 			ErrorExceptionHandled: AttributeConfig{Enabled: true},

enrichments/trace/internal/elastic/span.go

@@ -73,6 +73,8 @@ type spanEnrichmentContext struct {
 
 	spanStatusCode ptrace.StatusCode
 
+	// TODO (lahsivjar): Refactor span enrichment to better utilize isTransaction
+	isTransaction            bool
 	isMessaging              bool
 	isRPC                    bool
 	isHTTP                   bool
@@ -153,20 +155,22 @@ func (s *spanEnrichmentContext) Enrich(span ptrace.Span, cfg config.Config) {
 		return true
 	})
 
-	// Ensure all dependent attributes are handled.
 	s.normalizeAttributes()
-
-	isElasticTxn := isElasticTransaction(span)
-	if isElasticTxn {
-		s.enrichTransaction(span, cfg.Transaction)
-	} else {
-		s.enrichSpan(span, cfg.Span)
-	}
+	s.isTransaction = isElasticTransaction(span)
+	s.enrich(span, cfg)
 
 	spanEvents := span.Events()
 	for i := 0; i < spanEvents.Len(); i++ {
 		var c spanEventEnrichmentContext
-		c.enrich(spanEvents.At(i), cfg.SpanEvent)
+		c.enrich(s, spanEvents.At(i), cfg.SpanEvent)
+	}
+}
+
+func (s *spanEnrichmentContext) enrich(span ptrace.Span, cfg config.Config) {
+	if s.isTransaction {
+		s.enrichTransaction(span, cfg.Transaction)
+	} else {
+		s.enrichSpan(span, cfg.Span)
 	}
 }
 
@@ -178,7 +182,7 @@ func (s *spanEnrichmentContext) enrichTransaction(
 		span.Attributes().PutInt(AttributeTimestampUs, getTimestampUs(span.StartTimestamp()))
 	}
 	if cfg.Sampled.Enabled {
-		span.Attributes().PutBool(AttributeTransactionSampled, true)
+		span.Attributes().PutBool(AttributeTransactionSampled, s.getSampled())
 	}
 	if cfg.ID.Enabled {
 		span.Attributes().PutStr(AttributeTransactionID, span.SpanID().String())
@@ -200,7 +204,7 @@ func (s *spanEnrichmentContext) enrichTransaction(
 		span.Attributes().PutInt(AttributeTransactionDurationUs, getDurationUs(span))
 	}
 	if cfg.Type.Enabled {
-		s.setTxnType(span)
+		span.Attributes().PutStr(AttributeTransactionType, s.getTxnType())
 	}
 	if cfg.Result.Enabled {
 		s.setTxnResult(span)
@@ -252,15 +256,20 @@ func (s *spanEnrichmentContext) normalizeAttributes() {
 	}
 }
 
-func (s *spanEnrichmentContext) setTxnType(span ptrace.Span) {
+func (s *spanEnrichmentContext) getSampled() bool {
+	// Assumes that the method is called only for transaction
+	return true
+}
+
+func (s *spanEnrichmentContext) getTxnType() string {
 	txnType := "unknown"
 	switch {
 	case s.isMessaging:
 		txnType = "messaging"
 	case s.isRPC, s.isHTTP:
 		txnType = "request"
 	}
-	span.Attributes().PutStr(AttributeTransactionType, txnType)
+	return txnType
 }
 
 func (s *spanEnrichmentContext) setTxnResult(span ptrace.Span) {
@@ -430,6 +439,7 @@ type spanEventEnrichmentContext struct {
 }
 
 func (s *spanEventEnrichmentContext) enrich(
+	parentCtx *spanEnrichmentContext,
 	se ptrace.SpanEvent,
 	cfg config.SpanEventConfig,
 ) {
@@ -481,6 +491,16 @@ func (s *spanEventEnrichmentContext) enrich(
 		}
 		se.Attributes().PutStr(AttributeErrorGroupingKey, hex.EncodeToString(hash.Sum(nil)))
 	}
+
+	// Transaction type and sampled are added as span event enrichment only for errors
+	if parentCtx.isTransaction && s.exception {
+		if cfg.TransactionSampled.Enabled {
+			se.Attributes().PutBool(AttributeTransactionSampled, parentCtx.getSampled())
+		}
+		if cfg.TransactionType.Enabled {
+			se.Attributes().PutStr(AttributeTransactionType, parentCtx.getTxnType())
+		}
+	}
 }
 
 // getRepresentativeCount returns the number of spans represented by an

enrichments/trace/internal/elastic/span_test.go

@@ -764,13 +764,15 @@ func TestSpanEventEnrich(t *testing.T) {
 	ts := pcommon.NewTimestampFromTime(now)
 	for _, tc := range []struct {
 		name          string
+		parent        ptrace.Span
 		input         ptrace.SpanEvent
 		config        config.SpanEventConfig
 		errorID       bool // indicates if the error ID should be present in the result
 		enrichedAttrs map[string]any
 	}{
 		{
-			name: "not_exception",
+			name:   "not_exception",
+			parent: ptrace.NewSpan(),
 			input: func() ptrace.SpanEvent {
 				event := ptrace.NewSpanEvent()
 				event.SetTimestamp(ts)
@@ -783,7 +785,44 @@ func TestSpanEventEnrich(t *testing.T) {
 			},
 		},
 		{
-			name: "exception",
+			name: "exception_with_elastic_txn",
+			parent: func() ptrace.Span {
+				// No parent, elastic txn
+				span := ptrace.NewSpan()
+				return span
+			}(),
+			input: func() ptrace.SpanEvent {
+				event := ptrace.NewSpanEvent()
+				event.SetName("exception")
+				event.SetTimestamp(ts)
+				event.Attributes().PutStr(semconv.AttributeExceptionType, "java.net.ConnectionError")
+				event.Attributes().PutStr(semconv.AttributeExceptionMessage, "something is wrong")
+				event.Attributes().PutStr(semconv.AttributeExceptionStacktrace, `Exception in thread "main" java.lang.RuntimeException: Test exception\\n at com.example.GenerateTrace.methodB(GenerateTrace.java:13)\\n at com.example.GenerateTrace.methodA(GenerateTrace.java:9)\\n at com.example.GenerateTrace.main(GenerateTrace.java:5)`)
+				return event
+			}(),
+			config:  config.Enabled().SpanEvent,
+			errorID: true,
+			enrichedAttrs: map[string]any{
+				AttributeTimestampUs:           ts.AsTime().UnixMicro(),
+				AttributeProcessorEvent:        "error",
+				AttributeErrorExceptionHandled: true,
+				AttributeErrorGroupingKey: func() string {
+					hash := md5.New()
+					hash.Write([]byte("java.net.ConnectionError"))
+					return hex.EncodeToString(hash.Sum(nil))
+				}(),
+				AttributeTransactionSampled: true,
+				AttributeTransactionType:    "unknown",
+			},
+		},
+		{
+			name: "exception_with_elastic_span",
+			parent: func() ptrace.Span {
+				// Parent, elastic span
+				span := ptrace.NewSpan()
+				span.SetParentSpanID([8]byte{8, 9, 10, 11, 12, 13, 14})
+				return span
+			}(),
 			input: func() ptrace.SpanEvent {
 				event := ptrace.NewSpanEvent()
 				event.SetName("exception")
@@ -815,13 +854,12 @@ func TestSpanEventEnrich(t *testing.T) {
 				expectedAttrs[k] = v
 			}
 
-			span := ptrace.NewSpan()
-			tc.input.MoveTo(span.Events().AppendEmpty())
-			EnrichSpan(span, config.Config{
+			tc.input.MoveTo(tc.parent.Events().AppendEmpty())
+			EnrichSpan(tc.parent, config.Config{
 				SpanEvent: tc.config,
 			})
 
-			actual := span.Events().At(0).Attributes()
+			actual := tc.parent.Events().At(0).Attributes()
 			errorID, ok := actual.Get(AttributeErrorID)
 			assert.Equal(t, tc.errorID, ok, "error_id must be present for exception and must not be present for non-exception")
 			if tc.errorID {