First commit

Signed-off-by: Remy Chantenay <[email protected]>

.github/workflows/main.yaml

@@ -16,10 +16,10 @@ jobs:
     - name: Set up Go
       uses: actions/setup-go@v4
       with:
-        go-version: '1.21'
+        go-version: '1.23'
 
     - name: Install golangci-lint
-      run: go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.54.2
+      run: go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.61.0
 
     - name: Install govulncheck
       run: go install golang.org/x/vuln/cmd/govulncheck@latest
@@ -33,7 +33,3 @@ jobs:
     - name: Testing
       run: make test
 
-    - name: Upload coverage reports to Codecov
-      uses: codecov/codecov-action@v3
-      env:
-        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

README.md

@@ -1,13 +1,48 @@
 # otel-tag
-Simple package that extracts OpenTelemetry span attributes from a struct based on tags.
+Simple package that extracts OpenTelemetry [span attributes](https://opentelemetry.io/docs/demo/telemetry-features/manual-span-attributes/) and [baggage members](https://opentelemetry.io/docs/concepts/signals/baggage/) from a struct based on tags.
 
 ## Shortcomings
-- Do not support embedded structs.
+- Does not support basic type pointers (only struct pointers).
+
+## Usage
+```go
+package main
+
+import (
+	"context"
+
+	"go.opentelemetry.io/otel/baggage"
+	"go.opentelemetry.io/otel/trace"
+
+	oteltag "github.com/remychantenay/otel-tag"
+)
+
+type User struct {
+	ID        string `otel:"app.user.id"`
+	Username  string `otel:"app.user.username"`
+	IsPremium bool   `otel:"app.user.premium"`
+
+	UserDetails UserDetails
+}
+
+type UserDetails struct {
+	Website string `otel:"app.user.website,omitempty"`
+	Bio     string // Not tagged, will be ignored.
+}
+
+func main() {
+	// Span attributes.
+	_, span := tracer.Start(context.Background(), "someOperation",
+		trace.WithAttributes(oteltag.SpanAttributes(m)...),
+	)
+	defer span.End()
+
+	// Baggage Members.
+	members := oteltag.BaggageMembers(m)
+	bag, _ := baggage.New(members...)
+	ctx := baggage.ContextWithBaggage(context.Background(), bag)
+}
+```
 
 ## License
 Apache License Version 2.0
-
-TODO
-- Shit! What about attribute name prefix???! Init?
-- Remove t.Log() calls in tests
-- Complete README.md with example

baggage.go

@@ -12,7 +12,12 @@ import (
 // BaggageMembers takes in a struct and spits out OpenTelemetry baggage members
 // based on the struct tags.
 func BaggageMembers(res any) []baggage.Member {
-	structValue := reflect.ValueOf(res)
+	return structToBaggageMembers(res)
+}
+
+// structToBaggageMembers returns a slice of [baggage.Member] for a struct.
+func structToBaggageMembers(s any) []baggage.Member {
+	structValue := reflect.ValueOf(s)
 	structType := structValue.Type()
 	fieldCount := structValue.NumField()
 
@@ -22,28 +27,46 @@ func BaggageMembers(res any) []baggage.Member {
 
 	members := make([]baggage.Member, 0, fieldCount)
 	for i := 0; i < fieldCount; i++ {
-		tag := internal.ExtractTag(structValue, i)
+		field, fieldValue := structType.Field(i), structValue.Field(i)
+		if field.Type.Kind() == reflect.Struct {
+			members = append(members, structToBaggageMembers(fieldValue.Interface())...)
+		} else if field.Type.Kind() == reflect.Pointer { // Known shortcoming, assuming a pointer can only be a struct.
+			members = append(members, structToBaggageMembers(fieldValue.Elem().Interface())...)
+		} else {
+			member := basicTypeToBaggageMember(structType, structValue, i)
+			if member.Key() == "" {
+				continue
+			}
 
-		if len(tag) == 0 || tag == valIgnore {
-			continue
+			members = append(members, member)
 		}
+	}
 
-		var omitEmpty bool
-		before, after, found := strings.Cut(tag, ",")
-		if found {
-			tag = before
-			if after == valOmitEmpty {
-				omitEmpty = true
-			}
-		}
+	return members
+}
 
-		field, value := structType.Field(i), structValue.Field(i)
+// basicTypeToBaggageMember returns an [attribute.Member] for a basic type.
+func basicTypeToBaggageMember(structType reflect.Type, structValue reflect.Value, index int) baggage.Member {
+	tag := internal.ExtractTag(structValue, index)
 
-		member, zeroValue := internal.BaggageMember(field, value, tag)
-		if !zeroValue || !omitEmpty {
-			members = append(members, member)
+	if tag == "" {
+		return baggage.Member{}
+	}
+
+	var omitEmpty bool
+	before, after, found := strings.Cut(tag, ",")
+	if found {
+		tag = before
+		if after == flagOmitEmpty {
+			omitEmpty = true
 		}
 	}
 
-	return members
+	field, fieldValue := structType.Field(index), structValue.Field(index)
+	attr, zeroValue := internal.BaggageMember(field, fieldValue, tag)
+	if zeroValue && omitEmpty {
+		return baggage.Member{}
+	}
+
+	return attr
 }

baggage_test.go

@@ -11,20 +11,31 @@ import (
 
 func TestBaggageMembers(t *testing.T) {
 	t.Run("when non-zero values - should add all members to baggage", func(t *testing.T) {
-		const wantMemberCount = 12
+		const wantMemberCount = 10
+
+		want := map[string]string{
+			"val_str":           "a_string",
+			"val_int":           "42",
+			"val_int64":         "42000000000",
+			"val_float64":       "99.718281828",
+			"val_bool":          "true",
+			"val_str_slice":     "a_string_1,a_string_2,a_string_3",
+			"val_int_slice":     "1,2,3",
+			"val_int64_slice":   "100000,200000,300000",
+			"val_float64_slice": "1.1,2.2,3.3",
+			"val_bool_slice":    "true,false,true,false",
+		}
 
-		m := model{
+		m := testModel{
 			ValStr:          "a_string",
 			ValInt:          42,
 			ValInt64:        42000000000,
-			ValFloat32:      3.14,
 			ValFloat64:      99.718281828,
 			ValBool:         true,
 			ValStrSlice:     []string{"a_string_1", "a_string_2", "a_string_3"},
 			ValIntSlice:     []int{1, 2, 3},
 			ValInt64Slice:   []int64{100000, 200000, 300000},
-			ValFloat32Slice: []float32{1.1, 2.2, 3.3},
-			ValFloat64Slice: []float64{4.4, 5.5, 6.6},
+			ValFloat64Slice: []float64{1.1, 2.2, 3.3},
 			ValBoolSlice:    []bool{true, false, true, false},
 		}
 
@@ -38,15 +49,22 @@ func TestBaggageMembers(t *testing.T) {
 			t.Errorf("\ngot %d members\nwant %d", memberCount, wantMemberCount)
 		}
 
-		for i := range bag.Members() {
-			t.Log(bag.Members()[i].Key())
+		for k, v := range want {
+			member := bag.Member(k)
+			if member.Value() != v {
+				t.Errorf("\ngot %q for member %q\nwant %q", member.Value(), k, v)
+			}
 		}
 	})
 
 	t.Run("when zero values and omitted - should not add members to baggage", func(t *testing.T) {
 		const wantMemberCount = 1
 
-		m := model{ValBool: true}
+		want := map[string]string{
+			"val_bool": "true",
+		}
+
+		m := testModel{ValBool: true}
 
 		members := oteltag.BaggageMembers(m)
 		bag, _ := baggage.New(members...)
@@ -57,11 +75,22 @@ func TestBaggageMembers(t *testing.T) {
 		if memberCount != wantMemberCount {
 			t.Errorf("\ngot %d members\nwant %d", memberCount, wantMemberCount)
 		}
+
+		for k, v := range want {
+			member := bag.Member(k)
+			if member.Value() != v {
+				t.Errorf("\ngot %q for member %q\nwant %q", member.Value(), k, v)
+			}
+		}
 	})
 
 	t.Run("when zero values and not omitted - should add members to baggage", func(t *testing.T) {
 		const wantMemberCount = 1
 
+		want := map[string]string{
+			"val_str_not_omitted": "",
+		}
+
 		m := struct {
 			ValStrNotOmitted string `otel:"val_str_not_omitted"`
 		}{
@@ -78,8 +107,31 @@ func TestBaggageMembers(t *testing.T) {
 			t.Errorf("\ngot %d members\nwant %d", memberCount, wantMemberCount)
 		}
 
-		for i := range bag.Members() {
-			t.Log(bag.Members()[i].Key())
+		for k, v := range want {
+			member := bag.Member(k)
+			if member.Value() != v {
+				t.Errorf("\ngot %q for member %q\nwant %q", member.Value(), k, v)
+			}
+		}
+	})
+
+	t.Run("when fields are not tagged - should not add members to baggage", func(t *testing.T) {
+		const wantMemberCount = 0
+
+		m := struct {
+			ValStrIgnored string
+		}{
+			ValStrIgnored: "a_string",
+		}
+
+		members := oteltag.BaggageMembers(m)
+		bag, _ := baggage.New(members...)
+		ctx := baggage.ContextWithBaggage(context.Background(), bag)
+		bag = baggage.FromContext(ctx)
+
+		memberCount := len(bag.Members())
+		if memberCount != wantMemberCount {
+			t.Errorf("\ngot %d members\nwant %d", memberCount, wantMemberCount)
 		}
 	})
 }

benchmark_test.go

@@ -4,11 +4,12 @@ import (
 	"context"
 	"testing"
 
-	oteltag "github.com/remychantenay/otel-tag"
 	"go.opentelemetry.io/otel/attribute"
 	sdktrace "go.opentelemetry.io/otel/sdk/trace"
 	"go.opentelemetry.io/otel/sdk/trace/tracetest"
 	"go.opentelemetry.io/otel/trace"
+
+	oteltag "github.com/remychantenay/otel-tag"
 )
 
 var (
@@ -34,18 +35,16 @@ func BenchmarkSpanAttributes_With(b *testing.B) {
 	b.ResetTimer()
 	b.RunParallel(func(pb *testing.PB) {
 		for pb.Next() {
-			m := model{
+			m := testModel{
 				ValStr:          "a_string",
 				ValInt:          42,
 				ValInt64:        42000000000,
-				ValFloat32:      3.14,
 				ValFloat64:      99.718281828,
 				ValBool:         true,
 				ValStrSlice:     []string{"a_string_1", "a_string_2", "a_string_3"},
 				ValIntSlice:     []int{1, 2, 3},
 				ValInt64Slice:   []int64{100000, 200000, 300000},
-				ValFloat32Slice: []float32{1.1, 2.2, 3.3},
-				ValFloat64Slice: []float64{4.4, 5.5, 6.6},
+				ValFloat64Slice: []float64{1.1, 2.2, 3.3},
 				ValBoolSlice:    []bool{true, false, true, false},
 			}