update tests

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

Author: codeboten

otelconf/config_common.go

@@ -5,7 +5,6 @@ package otelconf // import "go.opentelemetry.io/contrib/otelconf"
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"reflect"
@@ -14,7 +13,6 @@ import (
 	sdklog "go.opentelemetry.io/otel/sdk/log"
 	sdkmetric "go.opentelemetry.io/otel/sdk/metric"
 	sdktrace "go.opentelemetry.io/otel/sdk/trace"
-	yaml "go.yaml.in/yaml/v3"
 )
 
 const (
@@ -323,66 +321,3 @@ func supportedHistogramAggregation(in ExporterDefaultHistogramAggregation) error
 	}
 	return newErrInvalid(fmt.Sprintf("invalid histogram aggregation (expected one of %#v): %#v", enumValuesOTLPMetricDefaultHistogramAggregation, in))
 }
-
-// MarshalUnmarshaler combines marshal and unmarshal operations.
-type MarshalUnmarshaler interface {
-	Marshal(v any) ([]byte, error)
-	Unmarshal(data []byte, v any) error
-}
-
-// jsonCodec implements MarshalUnmarshaler for JSON.
-type jsonCodec struct{}
-
-func (jsonCodec) Marshal(v any) ([]byte, error) {
-	return json.Marshal(v)
-}
-
-func (jsonCodec) Unmarshal(data []byte, v any) error {
-	return json.Unmarshal(data, v)
-}
-
-// yamlCodec implements MarshalUnmarshaler for YAML.
-type yamlCodec struct{}
-
-func (yamlCodec) Marshal(v any) ([]byte, error) {
-	return yaml.Marshal(v)
-}
-
-func (yamlCodec) Unmarshal(data []byte, v any) error {
-	return yaml.Unmarshal(data, v)
-}
-
-// setConfigDefaults sets default values for disabled and log_level.
-func setConfigDefaults(raw map[string]any, plain *OpenTelemetryConfiguration, codec MarshalUnmarshaler) error {
-	// Configure if the SDK is disabled or not.
-	// If omitted or null, false is used.
-	plain.Disabled = ptr(false)
-	if v, ok := raw["disabled"]; ok && v != nil {
-		marshaled, err := codec.Marshal(v)
-		if err != nil {
-			return err
-		}
-		var disabled bool
-		if err := codec.Unmarshal(marshaled, &disabled); err != nil {
-			return err
-		}
-		plain.Disabled = &disabled
-	}
-
-	// Configure the log level of the internal logger used by the SDK.
-	// If omitted, info is used.
-	plain.LogLevel = ptr("info")
-	if v, ok := raw["log_level"]; ok && v != nil {
-		marshaled, err := codec.Marshal(v)
-		if err != nil {
-			return err
-		}
-		var logLevel string
-		if err := codec.Unmarshal(marshaled, &logLevel); err != nil {
-			return err
-		}
-		plain.LogLevel = &logLevel
-	}
-
-	return nil
-}

otelconf/config_json.go

@@ -320,114 +320,110 @@ func (j *BatchSpanProcessor) UnmarshalJSON(b []byte) error {
 
 // UnmarshalJSON implements json.Unmarshaler.
 func (j *OpenTelemetryConfiguration) UnmarshalJSON(b []byte) error {
-	var raw map[string]any
-	if err := json.Unmarshal(b, &raw); err != nil {
-		return errors.Join(newErrUnmarshal(j), err)
+	type Plain OpenTelemetryConfiguration
+	type shadow struct {
+		Plain
+		FileFormat                 json.RawMessage `json:"file_format"`
+		LoggerProvider             json.RawMessage `json:"logger_provider"`
+		MeterProvider              json.RawMessage `json:"meter_provider"`
+		TracerProvider             json.RawMessage `json:"tracer_provider"`
+		Propagator                 json.RawMessage `json:"propagator"`
+		Resource                   json.RawMessage `json:"resource"`
+		InstrumentationDevelopment json.RawMessage `json:"instrumentation/development"`
+		AttributeLimits            json.RawMessage `json:"attribute_limits"`
+		Disabled                   json.RawMessage `json:"disabled"`
+		LogLevel                   json.RawMessage `json:"log_level"`
 	}
-	if _, ok := raw["file_format"]; raw != nil && !ok {
-		return errors.New("field file_format in OpenTelemetryConfiguration: required")
+	var sh shadow
+	if err := json.Unmarshal(b, &sh); err != nil {
+		return errors.Join(newErrUnmarshal(j), err)
 	}
-	type Plain OpenTelemetryConfiguration
-	var plain Plain
 
-	if v, ok := raw["logger_provider"]; ok && v != nil {
-		marshaled, err := json.Marshal(v)
-		if err != nil {
-			return errors.Join(newErrUnmarshal(j), err)
-		}
-		var lp LoggerProviderJson
-		if err := json.Unmarshal(marshaled, &lp); err != nil {
-			return errors.Join(newErrUnmarshal(j), err)
-		}
-		plain.LoggerProvider = &lp
+	if len(sh.FileFormat) == 0 {
+		return newErrRequired(j, "file_format")
 	}
 
-	if v, ok := raw["meter_provider"]; ok && v != nil {
-		marshaled, err := json.Marshal(v)
-		if err != nil {
-			return errors.Join(newErrUnmarshal(j), err)
-		}
-
-		var mp MeterProviderJson
-		if err := json.Unmarshal(marshaled, &mp); err != nil {
-			return errors.Join(newErrUnmarshal(j), err)
-		}
-		plain.MeterProvider = &mp
+	if err := json.Unmarshal(sh.FileFormat, &sh.Plain.FileFormat); err != nil {
+		return errors.Join(newErrUnmarshal(j), err)
 	}
 
-	if v, ok := raw["tracer_provider"]; ok && v != nil {
-		marshaled, err := json.Marshal(v)
-		if err != nil {
+	if sh.LoggerProvider != nil {
+		var l LoggerProviderJson
+		if err := json.Unmarshal(sh.LoggerProvider, &l); err != nil {
 			return errors.Join(newErrUnmarshal(j), err)
 		}
+		sh.Plain.LoggerProvider = &l
+	}
 
-		var tp TracerProviderJson
-		if err := json.Unmarshal(marshaled, &tp); err != nil {
+	if sh.MeterProvider != nil {
+		var m MeterProviderJson
+		if err := json.Unmarshal(sh.MeterProvider, &m); err != nil {
 			return errors.Join(newErrUnmarshal(j), err)
 		}
-		plain.TracerProvider = &tp
+		sh.Plain.MeterProvider = &m
 	}
 
-	if v, ok := raw["propagator"]; ok && v != nil {
-		marshaled, err := json.Marshal(v)
-		if err != nil {
+	if sh.TracerProvider != nil {
+		var t TracerProviderJson
+		if err := json.Unmarshal(sh.TracerProvider, &t); err != nil {
 			return errors.Join(newErrUnmarshal(j), err)
 		}
+		sh.Plain.TracerProvider = &t
+	}
 
+	if sh.Propagator != nil {
 		var p PropagatorJson
-		if err := json.Unmarshal(marshaled, &p); err != nil {
+		if err := json.Unmarshal(sh.Propagator, &p); err != nil {
 			return errors.Join(newErrUnmarshal(j), err)
 		}
-		plain.Propagator = &p
+		sh.Plain.Propagator = &p
 	}
 
-	if v, ok := raw["resource"]; ok && v != nil {
-		marshaled, err := json.Marshal(v)
-		if err != nil {
-			return errors.Join(newErrUnmarshal(j), err)
-		}
-
+	if sh.Resource != nil {
 		var r ResourceJson
-		if err := json.Unmarshal(marshaled, &r); err != nil {
+		if err := json.Unmarshal(sh.Resource, &r); err != nil {
 			return errors.Join(newErrUnmarshal(j), err)
 		}
-		plain.Resource = &r
+		sh.Plain.Resource = &r
 	}
 
-	if v, ok := raw["instrumentation/development"]; ok && v != nil {
-		marshaled, err := json.Marshal(v)
-		if err != nil {
+	if sh.InstrumentationDevelopment != nil {
+		var r InstrumentationJson
+		if err := json.Unmarshal(sh.InstrumentationDevelopment, &r); err != nil {
 			return errors.Join(newErrUnmarshal(j), err)
 		}
+		sh.Plain.InstrumentationDevelopment = &r
+	}
 
-		var i InstrumentationJson
-		if err := json.Unmarshal(marshaled, &i); err != nil {
+	if sh.AttributeLimits != nil {
+		var r AttributeLimits
+		if err := json.Unmarshal(sh.AttributeLimits, &r); err != nil {
 			return errors.Join(newErrUnmarshal(j), err)
 		}
-		plain.InstrumentationDevelopment = &i
+		sh.Plain.AttributeLimits = &r
 	}
 
-	if v, ok := raw["attribute_limits"]; ok && v != nil {
-		marshaled, err := json.Marshal(v)
-		if err != nil {
+	if sh.Disabled != nil {
+		if err := json.Unmarshal(sh.Disabled, &sh.Plain.Disabled); err != nil {
 			return errors.Join(newErrUnmarshal(j), err)
 		}
+	} else {
+		// Configure if the SDK is disabled or not.
+		// If omitted or null, false is used.
+		sh.Plain.Disabled = ptr(false)
+	}
 
-		var a AttributeLimits
-		if err := json.Unmarshal(marshaled, &a); err != nil {
+	if sh.LogLevel != nil {
+		if err := json.Unmarshal(sh.LogLevel, &sh.Plain.LogLevel); err != nil {
 			return errors.Join(newErrUnmarshal(j), err)
 		}
-		plain.AttributeLimits = &a
-	}
-
-	plainConfig := (*OpenTelemetryConfiguration)(&plain)
-	if err := setConfigDefaults(raw, plainConfig, jsonCodec{}); err != nil {
-		return errors.Join(newErrUnmarshal(j), err)
+	} else {
+		// Configure the log level of the internal logger used by the SDK.
+		// If omitted, info is used.
+		sh.Plain.LogLevel = ptr("info")
 	}
 
-	plain.FileFormat = fmt.Sprintf("%v", raw["file_format"])
-
-	*j = OpenTelemetryConfiguration(plain)
+	*j = OpenTelemetryConfiguration(sh.Plain)
 	return nil
 }
 

otelconf/config_test.go

@@ -981,12 +981,23 @@ func TestUnmarshalOpenTelemetryConfiguration(t *testing.T) {
 		wantType *OpenTelemetryConfiguration
 	}{
 		{
-			name:    "valid empty config",
-			input:   `valid_empty`,
-			wantErr: nil,
+			name:     "invalid config missing required file_format",
+			input:    `missing_file_format`,
+			wantErr:  newErrRequired(&OpenTelemetryConfiguration{}, "file_format"),
+			wantType: &OpenTelemetryConfiguration{},
+		},
+		{
+			name:     "file_format invalid",
+			input:    `invalid_file_format`,
+			wantErr:  newErrUnmarshal(&OpenTelemetryConfiguration{}),
+			wantType: &OpenTelemetryConfiguration{},
+		},
+		{
+			name:  "valid defaults config",
+			input: `valid_defaults`,
 			wantType: &OpenTelemetryConfiguration{
 				Disabled:   ptr(false),
-				FileFormat: "0.1",
+				FileFormat: "1.0",
 				LogLevel:   ptr("info"),
 			},
 		},