config: add SDK.Shutdown method

config/config.go

@@ -5,6 +5,7 @@ package config // import "go.opentelemetry.io/contrib/config"
 
 import (
 	"context"
+	"errors"
 
 	"go.opentelemetry.io/otel/metric"
 	"go.opentelemetry.io/otel/trace"
@@ -15,11 +16,18 @@ type configOptions struct {
 	opentelemetryConfig OpenTelemetryConfiguration
 }
 
+type shutdownFunc func(context.Context) error
+
+func noopShutdown(context.Context) error {
+	return nil
+}
+
 // SDK is a struct that contains all the providers
 // configured via the configuration model.
 type SDK struct {
 	meterProvider  metric.MeterProvider
 	tracerProvider trace.TracerProvider
+	shutdown       shutdownFunc
 }
 
 // TracerProvider returns a configured trace.TracerProvider.
@@ -32,6 +40,11 @@ func (s *SDK) MeterProvider() metric.MeterProvider {
 	return s.meterProvider
 }
 
+// Shutdown calls shutdown on all configured providers.
+func (s *SDK) Shutdown(ctx context.Context) error {
+	return s.shutdown(ctx)
+}
+
 // NewSDK creates SDK providers based on the configuration model.
 //
 // Caution: The implementation only returns noop providers.
@@ -41,9 +54,16 @@ func NewSDK(opts ...ConfigurationOption) (SDK, error) {
 		o = opt.apply(o)
 	}
 
+	mp, mpShutdown := initMeterProvider(o)
+	tp, tpShutdown := initTracerProvider(o)
+
 	return SDK{
-		meterProvider:  initMeterProvider(o),
-		tracerProvider: initTracerProvider(o),
+		meterProvider:  mp,
+		tracerProvider: tp,
+		shutdown: func(ctx context.Context) error {
+			err := mpShutdown(ctx)
+			return errors.Join(err, tpShutdown(ctx))
+		},
 	}, nil
 }
 

config/config_test.go

@@ -23,6 +23,7 @@ func TestNewSDK(t *testing.T) {
 		wantTracerProvider any
 		wantMeterProvider  any
 		wantErr            error
+		wantShutdownErr    error
 	}{
 		{
 			name:               "no-configuration",
@@ -47,5 +48,6 @@ func TestNewSDK(t *testing.T) {
 		require.Equal(t, tt.wantErr, err)
 		assert.IsType(t, tt.wantTracerProvider, sdk.TracerProvider())
 		assert.IsType(t, tt.wantMeterProvider, sdk.MeterProvider())
+		require.Equal(t, tt.wantShutdownErr, sdk.Shutdown(context.Background()))
 	}
 }

config/metric.go

@@ -9,9 +9,10 @@ import (
 	sdkmetric "go.opentelemetry.io/otel/sdk/metric"
 )
 
-func initMeterProvider(cfg configOptions) metric.MeterProvider {
+func initMeterProvider(cfg configOptions) (metric.MeterProvider, shutdownFunc) {
 	if cfg.opentelemetryConfig.MeterProvider == nil {
-		return noop.NewMeterProvider()
+		return noop.NewMeterProvider(), noopShutdown
 	}
-	return sdkmetric.NewMeterProvider()
+	mp := sdkmetric.NewMeterProvider()
+	return mp, mp.Shutdown
 }

config/metric_test.go

@@ -17,13 +17,16 @@ func TestInitMeterProvider(t *testing.T) {
 		name         string
 		cfg          configOptions
 		wantProvider metric.MeterProvider
+		wantErr      error
 	}{
 		{
 			name:         "no-meter-provider-configured",
 			wantProvider: noop.NewMeterProvider(),
 		},
 	}
 	for _, tt := range tests {
-		require.Equal(t, tt.wantProvider, initMeterProvider(tt.cfg))
+		mp, err := initMeterProvider(tt.cfg)
+		require.Equal(t, tt.wantProvider, mp)
+		require.NoError(t, tt.wantErr, err)
 	}
 }

config/trace.go

@@ -9,9 +9,10 @@ import (
 	"go.opentelemetry.io/otel/trace/noop"
 )
 
-func initTracerProvider(cfg configOptions) trace.TracerProvider {
+func initTracerProvider(cfg configOptions) (trace.TracerProvider, shutdownFunc) {
 	if cfg.opentelemetryConfig.TracerProvider == nil {
-		return noop.NewTracerProvider()
+		return noop.NewTracerProvider(), noopShutdown
 	}
-	return sdktrace.NewTracerProvider()
+	tp := sdktrace.NewTracerProvider()
+	return tp, tp.Shutdown
 }

config/trace_test.go

@@ -17,13 +17,16 @@ func TestInitTracerPovider(t *testing.T) {
 		name         string
 		cfg          configOptions
 		wantProvider trace.TracerProvider
+		wantErr      error
 	}{
 		{
 			name:         "no-tracer-provider-configured",
 			wantProvider: noop.NewTracerProvider(),
 		},
 	}
 	for _, tt := range tests {
-		require.Equal(t, tt.wantProvider, initTracerProvider(tt.cfg))
+		tp, err := initTracerProvider(tt.cfg)
+		require.Equal(t, tt.wantProvider, tp)
+		require.NoError(t, tt.wantErr, err)
 	}
 }