otelconf: unmarshal TextMapPropagator

Adds unmarshaling code for TextMapPropagator which includes supporting nillable values for the different propagators.

Part of splitting open-telemetry#8026

Signed-off-by: alex boten <[email protected]>

Author: codeboten

otelconf/config_common.go

@@ -5,6 +5,34 @@ package otelconf // import "go.opentelemetry.io/contrib/otelconf"
 
 import "fmt"
 
+// unmarshalTextMapPropagatorTypes handles all propagator type unmarshaling.
+func unmarshalTextMapPropagatorTypes(raw map[string]any, plain *TextMapPropagator) {
+	// the value for b3 is nillable, if so, set it here
+	if v, ok := raw["b3"]; ok && v == nil {
+		plain.B3 = B3Propagator{}
+	}
+	// the value for b3multi is nillable, if so, set it here
+	if v, ok := raw["b3multi"]; ok && v == nil {
+		plain.B3Multi = B3MultiPropagator{}
+	}
+	// the value for baggage is nillable, if so, set it here
+	if v, ok := raw["baggage"]; ok && v == nil {
+		plain.Baggage = BaggagePropagator{}
+	}
+	// the value for jaeger is nillable, if so, set it here
+	if v, ok := raw["jaeger"]; ok && v == nil {
+		plain.Jaeger = JaegerPropagator{}
+	}
+	// the value for ottrace is nillable, if so, set it here
+	if v, ok := raw["ottrace"]; ok && v == nil {
+		plain.Ottrace = OpenTracingPropagator{}
+	}
+	// the value for tracecontext is nillable, if so, set it here
+	if v, ok := raw["tracecontext"]; ok && v == nil {
+		plain.Tracecontext = TraceContextPropagator{}
+	}
+}
+
 // validateBatchLogRecordProcessor handles validation for BatchLogRecordProcessor.
 func validateBatchLogRecordProcessor(plain *BatchLogRecordProcessor) error {
 	if plain.ExportTimeout != nil && 0 > *plain.ExportTimeout {

otelconf/config_json.go

@@ -8,6 +8,22 @@ import (
 	"errors"
 )
 
+// UnmarshalJSON implements json.Unmarshaler.
+func (j *TextMapPropagator) UnmarshalJSON(b []byte) error {
+	var raw map[string]any
+	if err := json.Unmarshal(b, &raw); err != nil {
+		return errors.Join(errors.New("unmarshaling error TextMapPropagator"))
+	}
+	type Plain TextMapPropagator
+	var plain Plain
+	if err := json.Unmarshal(b, &plain); err != nil {
+		return errors.Join(errors.New("unmarshaling error TextMapPropagator"))
+	}
+	unmarshalTextMapPropagatorTypes(raw, (*TextMapPropagator)(&plain))
+	*j = TextMapPropagator(plain)
+	return nil
+}
+
 // UnmarshalJSON implements json.Unmarshaler.
 func (j *BatchLogRecordProcessor) UnmarshalJSON(b []byte) error {
 	var raw map[string]any

otelconf/config_test.go

@@ -10,6 +10,51 @@ import (
 	"go.yaml.in/yaml/v3"
 )
 
+func TestUnmarshalTextMapPropagator(t *testing.T) {
+	for _, tt := range []struct {
+		name       string
+		yamlConfig []byte
+		jsonConfig []byte
+		wantErr    string
+	}{
+		{
+			name:       "valid with b3 propagator",
+			jsonConfig: []byte(`{"b3":{}}`),
+			yamlConfig: []byte("b3: {}\n"),
+		},
+		{
+			name:       "valid with all propagators nil",
+			jsonConfig: []byte(`{"b3":null,"b3multi":null,"baggage":null,"jaeger":null,"ottrace":null,"tracecontext":null}`),
+			yamlConfig: []byte("b3:\nb3multi:\nbaggage:\njaeger:\nottrace:\ntracecontext:\n"),
+		},
+		{
+			name:       "invalid data",
+			jsonConfig: []byte(`{"b3":2000}`),
+			yamlConfig: []byte("b3: !!str str"),
+			wantErr:    "unmarshaling error TextMapPropagator",
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			tmp := TextMapPropagator{}
+			err := tmp.UnmarshalJSON(tt.jsonConfig)
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), tt.wantErr)
+			} else {
+				require.NoError(t, err)
+			}
+			tmp = TextMapPropagator{}
+			err = yaml.Unmarshal(tt.yamlConfig, &tmp)
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), tt.wantErr)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
 func TestUnmarshalBatchLogRecordProcessor(t *testing.T) {
 	for _, tt := range []struct {
 		name       string

otelconf/config_yaml.go

@@ -9,6 +9,22 @@ import (
 	"go.yaml.in/yaml/v3"
 )
 
+// UnmarshalYAML implements yaml.Unmarshaler.
+func (j *TextMapPropagator) UnmarshalYAML(node *yaml.Node) error {
+	var raw map[string]any
+	if err := node.Decode(&raw); err != nil {
+		return errors.Join(errors.New("unmarshaling error TextMapPropagator"))
+	}
+	type Plain TextMapPropagator
+	var plain Plain
+	if err := node.Decode(&plain); err != nil {
+		return errors.Join(errors.New("unmarshaling error TextMapPropagator"))
+	}
+	unmarshalTextMapPropagatorTypes(raw, (*TextMapPropagator)(&plain))
+	*j = TextMapPropagator(plain)
+	return nil
+}
+
 // UnmarshalYAML implements yaml.Unmarshaler.
 func (j *BatchLogRecordProcessor) UnmarshalYAML(node *yaml.Node) error {
 	var raw map[string]any