Rename Telemetry Builder (because it's not really a Builder) (#1753)

* Uses the telemetrry provider strategys with refactor

Signed-off-by: ChrisJBurns <[email protected]>

* removes redundant type checks

Signed-off-by: ChrisJBurns <[email protected]>

* renames builder/build to assembler/assemble to remove builder
connotation

Signed-off-by: ChrisJBurns <[email protected]>

* duplicate comment

Signed-off-by: ChrisJBurns <[email protected]>

---------

Signed-off-by: ChrisJBurns <[email protected]>

Author: ChrisJBurns

docs/server/docs.go

@@ -19,43 +19,43 @@ import (
 // Config holds the configuration for OpenTelemetry instrumentation.
 type Config struct {
 	// Endpoint is the OTLP endpoint URL
-	Endpoint string
+	Endpoint string `json:"endpoint"`
 
 	// ServiceName is the service name for telemetry
-	ServiceName string
+	ServiceName string `json:"serviceName"`
 
 	// ServiceVersion is the service version for telemetry
-	ServiceVersion string
+	ServiceVersion string `json:"serviceVersion"`
 
 	// TracingEnabled controls whether distributed tracing is enabled
 	// When false, no tracer provider is created even if an endpoint is configured
-	TracingEnabled bool
+	TracingEnabled bool `json:"tracingEnabled"`
 
 	// MetricsEnabled controls whether OTLP metrics are enabled
 	// When false, OTLP metrics are not sent even if an endpoint is configured
 	// This is independent of EnablePrometheusMetricsPath
-	MetricsEnabled bool
+	MetricsEnabled bool `json:"metricsEnabled"`
 
 	// SamplingRate is the trace sampling rate (0.0-1.0)
 	// Only used when TracingEnabled is true
-	SamplingRate float64
+	SamplingRate float64 `json:"samplingRate"`
 
 	// Headers contains authentication headers for the OTLP endpoint
-	Headers map[string]string
+	Headers map[string]string `json:"headers"`
 
 	// Insecure indicates whether to use HTTP instead of HTTPS for the OTLP endpoint
-	Insecure bool
+	Insecure bool `json:"insecure"`
 
 	// EnablePrometheusMetricsPath controls whether to expose Prometheus-style /metrics endpoint
 	// The metrics are served on the main transport port at /metrics
 	// This is separate from OTLP metrics which are sent to the Endpoint
-	EnablePrometheusMetricsPath bool
+	EnablePrometheusMetricsPath bool `json:"enablePrometheusMetricsPath"`
 
 	// EnvironmentVariables is a list of environment variable names that should be
 	// included in telemetry spans as attributes. Only variables in this list will
 	// be read from the host machine and included in spans for observability.
 	// Example: []string{"NODE_ENV", "DEPLOYMENT_ENV", "SERVICE_VERSION"}
-	EnvironmentVariables []string
+	EnvironmentVariables []string `json:"environmentVariables"`
 }
 
 // DefaultConfig returns a default telemetry configuration.
@@ -90,20 +90,19 @@ func NewProvider(ctx context.Context, config Config) (*Provider, error) {
 		return nil, err
 	}
 
-	// Use the new factory pattern
-	telemetryConfig := providers.Config{
-		ServiceName:                 config.ServiceName,
-		ServiceVersion:              config.ServiceVersion,
-		OTLPEndpoint:                config.Endpoint,
-		Headers:                     config.Headers,
-		Insecure:                    config.Insecure,
-		TracingEnabled:              config.TracingEnabled,
-		MetricsEnabled:              config.MetricsEnabled,
-		SamplingRate:                config.SamplingRate,
-		EnablePrometheusMetricsPath: config.EnablePrometheusMetricsPath,
+	telemetryOptions := []providers.ProviderOption{
+		providers.WithServiceName(config.ServiceName),
+		providers.WithServiceVersion(config.ServiceVersion),
+		providers.WithOTLPEndpoint(config.Endpoint),
+		providers.WithHeaders(config.Headers),
+		providers.WithInsecure(config.Insecure),
+		providers.WithTracingEnabled(config.TracingEnabled),
+		providers.WithMetricsEnabled(config.MetricsEnabled),
+		providers.WithSamplingRate(config.SamplingRate),
+		providers.WithEnablePrometheusMetricsPath(config.EnablePrometheusMetricsPath),
 	}
 
-	telemetryProviders, err := providers.WithConfig(telemetryConfig).Build(ctx)
+	telemetryProviders, err := providers.NewCompositeProvider(ctx, telemetryOptions...)
 	if err != nil {
 		return nil, fmt.Errorf("failed to build telemetry providers: %w", err)
 	}

docs/server/swagger.json

@@ -10,12 +10,6 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"go.opentelemetry.io/otel/metric/noop"
-	sdkmetric "go.opentelemetry.io/otel/sdk/metric"
-	"go.opentelemetry.io/otel/sdk/resource"
-	semconv "go.opentelemetry.io/otel/semconv/v1.21.0"
-
-	"github.com/stacklok/toolhive/pkg/telemetry/providers"
 )
 
 // TestTelemetryProviderValidation tests the five main telemetry configuration scenarios
@@ -164,112 +158,6 @@ func TestTelemetryProviderValidation(t *testing.T) {
 	}
 }
 
-// TestUnifiedMeterStrategyConfiguration tests the unified meter strategy configuration
-func TestUnifiedMeterStrategyConfiguration(t *testing.T) {
-	t.Parallel()
-	ctx := context.Background()
-
-	tests := []struct {
-		name        string
-		strategy    *providers.UnifiedMeterStrategy
-		config      providers.Config
-		expectError bool
-		description string
-	}{
-		{
-			name: "OTLP only",
-			strategy: &providers.UnifiedMeterStrategy{
-				EnableOTLP:       true,
-				EnablePrometheus: false,
-			},
-			config: providers.Config{
-				ServiceName:  "test",
-				OTLPEndpoint: "localhost:4318",
-				Insecure:     true,
-			},
-			expectError: false,
-			description: "Should create meter provider with OTLP reader only",
-		},
-		{
-			name: "Prometheus only",
-			strategy: &providers.UnifiedMeterStrategy{
-				EnableOTLP:       false,
-				EnablePrometheus: true,
-			},
-			config: providers.Config{
-				ServiceName: "test",
-			},
-			expectError: false,
-			description: "Should create meter provider with Prometheus reader only",
-		},
-		{
-			name: "Both OTLP and Prometheus",
-			strategy: &providers.UnifiedMeterStrategy{
-				EnableOTLP:       true,
-				EnablePrometheus: true,
-			},
-			config: providers.Config{
-				ServiceName:  "test",
-				OTLPEndpoint: "localhost:4318",
-				Insecure:     true,
-			},
-			expectError: false,
-			description: "Should create meter provider with both readers",
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt // capture range variable
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			// Create resource for testing
-			res, err := createTestResource(ctx, tt.config)
-			require.NoError(t, err)
-
-			// Test meter provider creation
-			result, err := tt.strategy.CreateMeterProvider(ctx, tt.config, res)
-
-			if tt.expectError {
-				require.Error(t, err)
-				return
-			}
-
-			require.NoError(t, err, tt.description)
-			require.NotNil(t, result)
-			require.NotNil(t, result.MeterProvider)
-
-			// Validate provider type
-			if tt.strategy.EnableOTLP || tt.strategy.EnablePrometheus {
-				// Should be SDK meter provider when any reader is enabled
-				assert.IsType(t, &sdkmetric.MeterProvider{}, result.MeterProvider,
-					"Should create SDK meter provider when readers are configured")
-			} else {
-				// Should be no-op when nothing is enabled
-				assert.IsType(t, noop.MeterProvider{}, result.MeterProvider,
-					"Should create no-op meter provider when no readers are configured")
-			}
-
-			// Validate Prometheus handler
-			if tt.strategy.EnablePrometheus {
-				assert.NotNil(t, result.PrometheusHandler,
-					"Should have Prometheus handler when Prometheus is enabled")
-			} else {
-				assert.Nil(t, result.PrometheusHandler,
-					"Should not have Prometheus handler when Prometheus is disabled")
-			}
-
-			// Test shutdown if available - ignore connection errors during test shutdown
-			if result.ShutdownFunc != nil {
-				err := result.ShutdownFunc(ctx)
-				if err != nil && !isConnectionError(err) {
-					t.Errorf("Shutdown error (non-connection): %v", err)
-				}
-			}
-		})
-	}
-}
-
 // getProviderTypeName returns a readable type name for telemetry providers
 func getProviderTypeName(provider interface{}) string {
 	t := reflect.TypeOf(provider)
@@ -279,16 +167,6 @@ func getProviderTypeName(provider interface{}) string {
 	return t.PkgPath()[len("go.opentelemetry.io/otel/"):] + "." + t.Name()
 }
 
-// createTestResource creates a resource for testing
-func createTestResource(ctx context.Context, config providers.Config) (*resource.Resource, error) {
-	return resource.New(ctx,
-		resource.WithAttributes(
-			semconv.ServiceName(config.ServiceName),
-			semconv.ServiceVersion("1.0.0"),
-		),
-	)
-}
-
 // isConnectionError checks if the error is a connection-related error that can be ignored in tests
 func isConnectionError(err error) bool {
 	errorStr := err.Error()