Promotes trace and span IDs to top level (#329)

* Promotes trace and span IDs to top level

* Add tests too

* Show that we handle garbage

* Make test slightly more insightful

* Remove commentted code

* APPEASE THE LINTER

* Need to specify lower case d

Author: Garbett1

processor/loghouseprocessor/processor.go

@@ -4,6 +4,8 @@
 package loghouseprocessor // import "github.com/open-telemetry/opentelemetry-collector-contrib/processor/loghouseprocessor"
 import (
 	"context"
+	"encoding/hex"
+	"errors"
 	"fmt"
 	"regexp"
 	"strconv"
@@ -135,12 +137,65 @@ func parseSeverity(l *plog.LogRecord) error {
 func processJSONLog(l *plog.LogRecord) {
 	_ = parseSeverity(l)
 	extractBody(l)
+	promoteTraceAndSpan(l)
 	isCH := parseCHTimestamp(l)
 	if isCH {
 		parseCHSeverity(l)
 	}
 }
 
+// Both funcs copied from: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/pkg/ottl/contexts/internal/ids.go#L25
+
+func ParseSpanID(spanIDStr string) (pcommon.SpanID, error) {
+	var id pcommon.SpanID
+	if hex.DecodedLen(len(spanIDStr)) != len(id) {
+		return pcommon.SpanID{}, errors.New("span ids must be 16 hex characters")
+	}
+	_, err := hex.Decode(id[:], []byte(spanIDStr))
+	if err != nil {
+		return pcommon.SpanID{}, err
+	}
+	return id, nil
+}
+
+func ParseTraceID(traceIDStr string) (pcommon.TraceID, error) {
+	var id pcommon.TraceID
+	if hex.DecodedLen(len(traceIDStr)) != len(id) {
+		return pcommon.TraceID{}, errors.New("trace ids must be 32 hex characters")
+	}
+	_, err := hex.Decode(id[:], []byte(traceIDStr))
+	if err != nil {
+		return pcommon.TraceID{}, err
+	}
+	return id, nil
+}
+
+func promoteTraceAndSpan(l *plog.LogRecord) {
+	var (
+		traceID pcommon.TraceID
+		spanID  pcommon.SpanID
+	)
+	if tid, ok := l.Attributes().Get("traceId"); ok {
+		parsed, err := ParseTraceID(tid.Str())
+		if err != nil {
+			return
+		}
+		traceID = parsed
+	}
+	if sid, ok := l.Attributes().Get("spanId"); ok {
+		parsed, err := ParseSpanID(sid.Str())
+		if err != nil {
+			return
+		}
+		spanID = parsed
+	}
+	// No point having one or the other, we must always do both
+	if !traceID.IsEmpty() && !spanID.IsEmpty() {
+		l.SetTraceID(traceID)
+		l.SetSpanID(spanID)
+	}
+}
+
 var (
 	k8sTimestampRe = regexp.MustCompile(`\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d*Z`)
 	chTimestampRe  = regexp.MustCompile(`\d{4}.\d{2}.\d{2} \d{2}:\d{2}:\d{2}.\d*`)

processor/loghouseprocessor/processor_test.go

@@ -6,6 +6,8 @@ package loghouseprocessor
 import (
 	"testing"
 
+	"go.opentelemetry.io/collector/pdata/pcommon"
+
 	"github.com/stretchr/testify/assert"
 	"go.opentelemetry.io/collector/pdata/plog"
 )
@@ -244,23 +246,43 @@ func Test_processLine(t *testing.T) {
 	})
 }
 
-// func assertAttr(t *testing.T, expected, key string, log *plog.LogRecord) {
-// 	val, ok := log.Attributes().Get(key)
-// 	assert.True(t, ok)
-// 	assert.Equal(t, expected, val.Str())
-// }
-//  TODO for testing that metrics get updated
-// func getCounter() metric.Int64Counter {
-// 	meterProvider := sdkmetric.NewMeterProvider()
-//
-// 	meter := meterProvider.Meter("xoyo-logs")
-// 	observedLogsCtr, err := meter.Int64Counter(
-// 		"loghouse_observed_logs",
-// 		metric.WithDescription("Number of log records that were not routed to some or all exporters"),
-// 	)
-// 	if err != nil {
-// 		panic(err)
-// 	}
-// 	return observedLogsCtr
-//
-// }
+func Test_promoteTraceAndSpan(t *testing.T) {
+	type expect struct {
+		trace pcommon.TraceID
+		span  pcommon.SpanID
+	}
+	tests := []struct {
+		name     string
+		args     map[string]any
+		expected expect
+	}{
+		{name: "missing both", args: map[string]any(nil), expected: expect{
+			trace: pcommon.TraceID{},
+			span:  pcommon.SpanID{},
+		}},
+		{name: "have both", args: map[string]any{"traceId": "00000000000000000000000000000001", "spanId": "0000000000000001"}, expected: expect{
+			trace: pcommon.TraceID{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x01},
+			span:  pcommon.SpanID{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x01},
+		}},
+		{name: "one passed it, so ignore", args: map[string]any{"traceId": "00000000000000000000000000000001"}, expected: expect{
+			trace: pcommon.TraceID{},
+			span:  pcommon.SpanID{},
+		}},
+		{name: "garbage, also ignore", args: map[string]any{"traceId": "00000000000000000000000000000001", "spanId": "blah"}, expected: expect{
+			trace: pcommon.TraceID{},
+			span:  pcommon.SpanID{},
+		}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			l := plog.NewLogRecord()
+			err := l.Attributes().FromRaw(tt.args)
+			if err != nil {
+				t.Fatalf("failed to parse from the args")
+			}
+			promoteTraceAndSpan(&l)
+			assert.Equal(t, tt.expected.span, l.SpanID())
+			assert.Equal(t, tt.expected.trace, l.TraceID())
+		})
+	}
+}