refactor(issue-342): simplify otel app builder middleware

Author: Zaba505

appbuilder/appbuilder_test.go

@@ -19,36 +19,36 @@ func TestRecover(t *testing.T) {
 	t.Run("will return an error", func(t *testing.T) {
 		t.Run("if the underlying App returns an error", func(t *testing.T) {
 			buildErr := errors.New("failed to build")
-			builder := Recover(bedrock.AppBuilderFunc[config](func(ctx context.Context, cfg config) (bedrock.App, error) {
+			builder := Recover(bedrock.AppBuilderFunc[struct{}](func(ctx context.Context, cfg struct{}) (bedrock.App, error) {
 				return nil, buildErr
 			}))
 
-			_, err := builder.Build(context.Background(), config{})
+			_, err := builder.Build(context.Background(), struct{}{})
 			if !assert.Equal(t, buildErr, err) {
 				return
 			}
 		})
 
 		t.Run("if the underlying App panics with an error value", func(t *testing.T) {
 			buildErr := errors.New("failed to build")
-			builder := Recover(bedrock.AppBuilderFunc[config](func(ctx context.Context, cfg config) (bedrock.App, error) {
+			builder := Recover(bedrock.AppBuilderFunc[struct{}](func(ctx context.Context, cfg struct{}) (bedrock.App, error) {
 				panic(buildErr)
 				return nil, nil
 			}))
 
-			_, err := builder.Build(context.Background(), config{})
+			_, err := builder.Build(context.Background(), struct{}{})
 			if !assert.ErrorIs(t, err, buildErr) {
 				return
 			}
 		})
 
 		t.Run("if the underlying App panics with a non-error value", func(t *testing.T) {
-			builder := Recover(bedrock.AppBuilderFunc[config](func(ctx context.Context, cfg config) (bedrock.App, error) {
+			builder := Recover(bedrock.AppBuilderFunc[struct{}](func(ctx context.Context, cfg struct{}) (bedrock.App, error) {
 				panic("hello world")
 				return nil, nil
 			}))
 
-			_, err := builder.Build(context.Background(), config{})
+			_, err := builder.Build(context.Background(), struct{}{})
 
 			var perr bedrock.PanicError
 			if !assert.ErrorAs(t, err, &perr) {

appbuilder/otel.go

@@ -9,88 +9,56 @@ import (
 	"context"
 
 	"github.com/z5labs/bedrock"
-
+	"github.com/z5labs/bedrock/app"
 	"go.opentelemetry.io/otel"
-	"go.opentelemetry.io/otel/log"
 	"go.opentelemetry.io/otel/log/global"
-	"go.opentelemetry.io/otel/metric"
-	"go.opentelemetry.io/otel/propagation"
-	"go.opentelemetry.io/otel/trace"
 )
 
-// TextMapPropagatorInitializer
-type TextMapPropagatorInitializer interface {
-	InitTextMapPropogator(context.Context) (propagation.TextMapPropagator, error)
+// OTelInitializer represents anything which can initialize the OTel SDK.
+type OTelInitializer interface {
+	InitializeOTel(context.Context) error
 }
 
-// TracerProviderInitializer
-type TracerProviderInitializer interface {
-	InitTracerProvider(context.Context) (trace.TracerProvider, error)
-}
+// OTel is a [bedrock.AppBuilder] middleware which initializes the OTel SDK.
+// It also ensures that the OTel SDK is properly shutdown when the built [bedrock.App]
+// stops running.
+func OTel[T OTelInitializer](builder bedrock.AppBuilder[T]) bedrock.AppBuilder[T] {
+	return bedrock.AppBuilderFunc[T](func(ctx context.Context, cfg T) (bedrock.App, error) {
+		err := cfg.InitializeOTel(ctx)
+		if err != nil {
+			return nil, err
+		}
 
-// MeterProviderInitializer
-type MeterProviderInitializer interface {
-	InitMeterProvider(context.Context) (metric.MeterProvider, error)
-}
+		base, err := builder.Build(ctx, cfg)
+		if err != nil {
+			return nil, err
+		}
 
-// LoggerProviderInitializer
-type LoggerProviderInitializer interface {
-	InitLoggerProvider(context.Context) (log.LoggerProvider, error)
+		base = app.WithLifecycleHooks(base, app.Lifecycle{
+			PostRun: app.ComposeLifecycleHooks(
+				tryShutdown(otel.GetTracerProvider()),
+				tryShutdown(otel.GetMeterProvider()),
+				tryShutdown(global.GetLoggerProvider()),
+			),
+		})
+		return base, nil
+	})
 }
 
-// OTelInitializer
-type OTelInitializer interface {
-	TextMapPropagatorInitializer
-	TracerProviderInitializer
-	MeterProviderInitializer
-	LoggerProviderInitializer
+type shutdowner interface {
+	Shutdown(context.Context) error
 }
 
-// OTel
-func OTel[T OTelInitializer](builder bedrock.AppBuilder[T]) bedrock.AppBuilder[T] {
-	return bedrock.AppBuilderFunc[T](func(ctx context.Context, cfg T) (bedrock.App, error) {
-		fs := []func(context.Context) error{
-			func(ctx context.Context) error {
-				tmp, err := cfg.InitTextMapPropogator(ctx)
-				if err != nil || tmp == nil {
-					return err
-				}
-				otel.SetTextMapPropagator(tmp)
-				return nil
-			},
-			func(ctx context.Context) error {
-				tp, err := cfg.InitTracerProvider(ctx)
-				if err != nil || tp == nil {
-					return err
-				}
-				otel.SetTracerProvider(tp)
-				return nil
-			},
-			func(ctx context.Context) error {
-				mp, err := cfg.InitMeterProvider(ctx)
-				if err != nil || mp == nil {
-					return err
-				}
-				otel.SetMeterProvider(mp)
-				return nil
-			},
-			func(ctx context.Context) error {
-				lp, err := cfg.InitLoggerProvider(ctx)
-				if err != nil || lp == nil {
-					return err
-				}
-				global.SetLoggerProvider(lp)
-				return nil
-			},
+func tryShutdown(v any) app.LifecycleHookFunc {
+	return func(ctx context.Context) error {
+		if v == nil {
+			return nil
 		}
 
-		for _, f := range fs {
-			err := f(ctx)
-			if err != nil {
-				return nil, err
-			}
+		s, ok := v.(shutdowner)
+		if !ok {
+			return nil
 		}
-
-		return builder.Build(ctx, cfg)
-	})
+		return s.Shutdown(ctx)
+	}
 }