otelconf: add support for OTEL_EXPERIMENTAL_CONFIG_FILE

CHANGELOG.md

@@ -16,6 +16,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 - Add unmarshaling and validation for `CardinalityLimits` and `SpanLimits` to v1.0.0 model in `go.opentelemetry.io/contrib/otelconf`. (#8043)
 - Add unmarshaling and validation for `BatchLogRecordProcessor`, `BatchSpanProcessor`, and `PeriodicMetricReader` to v1.0.0 model in `go.opentelemetry.io/contrib/otelconf`. (#8049)
 - Add unmarshaling and validation for `TextMapPropagator` to v1.0.0 model in `go.opentelemetry.io/contrib/otelconf`. (#8052)
+- Updated `go.opentelemetry.io/contrib/otelconf` to include the [v1.0.0-rc2](https://github.com/open-telemetry/opentelemetry-configuration/releases/tag/v1.0.0-rc.2) release candidate of schema which includes backwards incompatible changes. (#8026)
 
 ### Changed
 

otelconf/config.go

@@ -0,0 +1,219 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+// Package otelconf provides an OpenTelemetry declarative configuration SDK.
+package otelconf // import "go.opentelemetry.io/contrib/otelconf"
+
+import (
+	"context"
+	"errors"
+	"log"
+	"os"
+
+	"go.opentelemetry.io/otel"
+	apilog "go.opentelemetry.io/otel/log"
+	"go.opentelemetry.io/otel/log/global"
+	nooplog "go.opentelemetry.io/otel/log/noop"
+	"go.opentelemetry.io/otel/metric"
+	noopmetric "go.opentelemetry.io/otel/metric/noop"
+	sdklog "go.opentelemetry.io/otel/sdk/log"
+	sdkmetric "go.opentelemetry.io/otel/sdk/metric"
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
+	"go.opentelemetry.io/otel/trace"
+	nooptrace "go.opentelemetry.io/otel/trace/noop"
+	yaml "go.yaml.in/yaml/v3"
+
+	"go.opentelemetry.io/contrib/otelconf/internal/provider"
+)
+
+// SDK is a struct that contains all the providers
+// configured via the configuration model.
+type SDK struct {
+	meterProvider  metric.MeterProvider
+	tracerProvider trace.TracerProvider
+	loggerProvider apilog.LoggerProvider
+	shutdown       shutdownFunc
+}
+
+// TracerProvider returns a configured trace.TracerProvider.
+func (s *SDK) TracerProvider() trace.TracerProvider {
+	return s.tracerProvider
+}
+
+// MeterProvider returns a configured metric.MeterProvider.
+func (s *SDK) MeterProvider() metric.MeterProvider {
+	return s.meterProvider
+}
+
+// LoggerProvider returns a configured apilog.LoggerProvider.
+func (s *SDK) LoggerProvider() apilog.LoggerProvider {
+	return s.loggerProvider
+}
+
+// Shutdown calls shutdown on all configured providers.
+func (s *SDK) Shutdown(ctx context.Context) error {
+	return s.shutdown(ctx)
+}
+
+var noopSDK = SDK{
+	loggerProvider: nooplog.LoggerProvider{},
+	meterProvider:  noopmetric.MeterProvider{},
+	tracerProvider: nooptrace.TracerProvider{},
+	shutdown:       func(context.Context) error { return nil },
+}
+
+var sdk *SDK
+
+// init checks the local environment and uses the file set in the variable
+// `OTEL_EXPERIMENTAL_CONFIG_FILE` to configure the SDK automatically.
+func init() {
+	// look for the env variable
+	filename, ok := os.LookupEnv("OTEL_EXPERIMENTAL_CONFIG_FILE")
+	if !ok {
+		return
+	}
+	b, err := os.ReadFile(filename)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Parse a configuration file into an OpenTelemetryConfiguration model.
+	c, err := ParseYAML(b)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Create SDK components with the parsed configuration.
+	s, err := NewSDK(WithOpenTelemetryConfiguration(*c))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Set the global providers.
+	otel.SetTracerProvider(s.TracerProvider())
+	otel.SetMeterProvider(s.MeterProvider())
+	global.SetLoggerProvider(s.LoggerProvider())
+	sdk = &s
+}
+
+// Shutdown calls the shutdown function of the global SDK instantiated if
+func Shutdown(ctx context.Context) {
+	if sdk == nil {
+		return
+	}
+	if err := sdk.Shutdown(ctx); err != nil {
+		log.Fatal(err)
+	}
+}
+
+// NewSDK creates SDK providers based on the configuration model.
+func NewSDK(opts ...ConfigurationOption) (SDK, error) {
+	o := configOptions{
+		ctx: context.Background(),
+	}
+	for _, opt := range opts {
+		o = opt.apply(o)
+	}
+	if o.opentelemetryConfig.Disabled != nil && *o.opentelemetryConfig.Disabled {
+		return noopSDK, nil
+	}
+
+	r, err := newResource(o.opentelemetryConfig.Resource)
+	if err != nil {
+		return noopSDK, err
+	}
+
+	mp, mpShutdown, err := meterProvider(o, r)
+	if err != nil {
+		return noopSDK, err
+	}
+
+	tp, tpShutdown, err := tracerProvider(o, r)
+	if err != nil {
+		return noopSDK, err
+	}
+
+	lp, lpShutdown, err := loggerProvider(o, r)
+	if err != nil {
+		return noopSDK, err
+	}
+
+	return SDK{
+		meterProvider:  mp,
+		tracerProvider: tp,
+		loggerProvider: lp,
+		shutdown: func(ctx context.Context) error {
+			return errors.Join(mpShutdown(ctx), tpShutdown(ctx), lpShutdown(ctx))
+		},
+	}, nil
+}
+
+// ConfigurationOption configures options for providers.
+type ConfigurationOption interface {
+	apply(configOptions) configOptions
+}
+
+type configurationOptionFunc func(configOptions) configOptions
+
+func (fn configurationOptionFunc) apply(cfg configOptions) configOptions {
+	return fn(cfg)
+}
+
+// WithContext sets the context.Context for the SDK.
+func WithContext(ctx context.Context) ConfigurationOption {
+	return configurationOptionFunc(func(c configOptions) configOptions {
+		c.ctx = ctx
+		return c
+	})
+}
+
+// WithOpenTelemetryConfiguration sets the OpenTelemetryConfiguration used
+// to produce the SDK.
+func WithOpenTelemetryConfiguration(cfg OpenTelemetryConfiguration) ConfigurationOption {
+	return configurationOptionFunc(func(c configOptions) configOptions {
+		c.opentelemetryConfig = cfg
+		return c
+	})
+}
+
+// WithLoggerProviderOptions appends LoggerProviderOptions used for constructing
+// the LoggerProvider. OpenTelemetryConfiguration takes precedence over these options.
+func WithLoggerProviderOptions(opts ...sdklog.LoggerProviderOption) ConfigurationOption {
+	return configurationOptionFunc(func(c configOptions) configOptions {
+		c.loggerProviderOptions = append(c.loggerProviderOptions, opts...)
+		return c
+	})
+}
+
+// WithMeterProviderOptions appends metric.Options used for constructing the
+// MeterProvider. OpenTelemetryConfiguration takes precedence over these options.
+func WithMeterProviderOptions(opts ...sdkmetric.Option) ConfigurationOption {
+	return configurationOptionFunc(func(c configOptions) configOptions {
+		c.meterProviderOptions = append(c.meterProviderOptions, opts...)
+		return c
+	})
+}
+
+// WithTracerProviderOptions appends TracerProviderOptions used for constructing
+// the TracerProvider. OpenTelemetryConfiguration takes precedence over these options.
+func WithTracerProviderOptions(opts ...sdktrace.TracerProviderOption) ConfigurationOption {
+	return configurationOptionFunc(func(c configOptions) configOptions {
+		c.tracerProviderOptions = append(c.tracerProviderOptions, opts...)
+		return c
+	})
+}
+
+// ParseYAML parses a YAML configuration file into an OpenTelemetryConfiguration.
+func ParseYAML(file []byte) (*OpenTelemetryConfiguration, error) {
+	file, err := provider.ReplaceEnvVars(file)
+	if err != nil {
+		return nil, err
+	}
+	var cfg OpenTelemetryConfiguration
+	err = yaml.Unmarshal(file, &cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	return &cfg, nil
+}

otelconf/config_common.go

@@ -5,12 +5,16 @@ package otelconf // import "go.opentelemetry.io/contrib/otelconf"
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"reflect"
 
 	"go.opentelemetry.io/otel/baggage"
 	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 (
@@ -22,6 +26,8 @@ type configOptions struct {
 	ctx                   context.Context
 	opentelemetryConfig   OpenTelemetryConfiguration
 	loggerProviderOptions []sdklog.LoggerProviderOption
+	meterProviderOptions  []sdkmetric.Option
+	tracerProviderOptions []sdktrace.TracerProviderOption
 }
 
 type shutdownFunc func(context.Context) error
@@ -123,6 +129,30 @@ func newErrInvalid(id string) error {
 	return &errInvalid{Identifier: id}
 }
 
+// unmarshalSamplerTypes handles always_on and always_off sampler unmarshaling.
+func unmarshalSamplerTypes(raw map[string]any, plain *Sampler) {
+	// always_on can be nil, must check and set here
+	if _, ok := raw["always_on"]; ok {
+		plain.AlwaysOn = AlwaysOnSampler{}
+	}
+	// always_off can be nil, must check and set here
+	if _, ok := raw["always_off"]; ok {
+		plain.AlwaysOff = AlwaysOffSampler{}
+	}
+}
+
+// unmarshalMetricProducer handles opencensus metric producer unmarshaling.
+func unmarshalMetricProducer(raw map[string]any, plain *MetricProducer) {
+	// opencensus can be nil, must check and set here
+	if v, ok := raw["opencensus"]; ok && v == nil {
+		delete(raw, "opencensus")
+		plain.Opencensus = OpenCensusMetricProducer{}
+	}
+	if len(raw) > 0 {
+		plain.AdditionalProperties = raw
+	}
+}
+
 // validatePeriodicMetricReader handles validation for PeriodicMetricReader.
 func validatePeriodicMetricReader(plain *PeriodicMetricReader) error {
 	if plain.Timeout != nil && 0 > *plain.Timeout {
@@ -245,3 +275,91 @@ func createHeadersConfig(headers []NameStringValuePair, headersList *string) (ma
 	}
 	return result, nil
 }
+
+var enumValuesAttributeType = []any{
+	nil,
+	"string",
+	"bool",
+	"int",
+	"double",
+	"string_array",
+	"bool_array",
+	"int_array",
+	"double_array",
+}
+
+// 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
+}
+
+// validateStringField validates a string field is present and correct type.
+func validateStringField(raw map[string]any, fieldName string) (string, error) {
+	v, ok := raw[fieldName]
+	if !ok {
+		return "", fmt.Errorf("cannot unmarshal field %s in NameStringValuePair required", fieldName)
+	}
+	str, ok := v.(string)
+	if !ok {
+		return "", fmt.Errorf("cannot unmarshal field %s in NameStringValuePair must be string", fieldName)
+	}
+	return str, nil
+}