Add OpenTelemetry instrumentation with middleware-only approach

cmd/greet/main.go

@@ -14,6 +14,6 @@ func main() {
 	if len(os.Args) > 1 {
 		name = os.Args[1]
 	}
-	
+
 	fmt.Println(service.Greet(context.Background(), name))
-}
+}

cmd/server/main.go

@@ -11,8 +11,10 @@ import (
 
 	"DanceLessonsCoach/pkg/config"
 	"DanceLessonsCoach/pkg/server"
+	"DanceLessonsCoach/pkg/telemetry"
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
 )
 
 func main() {
@@ -20,11 +22,11 @@ func main() {
 	zerolog.SetGlobalLevel(zerolog.TraceLevel)
 	zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
 	consoleWriter := zerolog.ConsoleWriter{Out: os.Stderr}
-	
+
 	// Check if JSON logging is requested via environment variable
 	// This allows JSON logging even during config loading
 	jsonLogging := os.Getenv("DLC_LOGGING_JSON") == "true"
-	
+
 	if jsonLogging {
 		// JSON output for structured logging
 		log.Logger = log.Output(os.Stderr)
@@ -50,6 +52,27 @@ func main() {
 
 	log.Info().Bool("json_logging", cfg.Logging.JSON).Msg("Logging configured")
 
+	// Initialize OpenTelemetry if enabled
+	var tracerProvider *sdktrace.TracerProvider
+	if cfg.GetTelemetryEnabled() {
+		log.Info().Msg("Initializing OpenTelemetry tracing")
+
+		telemetrySetup := &telemetry.Setup{
+			ServiceName:  cfg.GetServiceName(),
+			OTLPEndpoint: cfg.GetOTLPEndpoint(),
+			Insecure:     cfg.GetTelemetryInsecure(),
+			SamplerType:  cfg.GetSamplerType(),
+			SamplerRatio: cfg.GetSamplerRatio(),
+		}
+
+		var err error
+		if tracerProvider, err = telemetrySetup.InitializeTracing(context.Background()); err != nil {
+			log.Error().Err(err).Msg("Failed to initialize OpenTelemetry, continuing without tracing")
+		} else {
+			log.Info().Msg("OpenTelemetry tracing initialized successfully")
+		}
+	}
+
 	// Setup signal context for graceful shutdown
 	rootCtx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
 	defer stop()
@@ -60,7 +83,7 @@ func main() {
 
 	// Create ongoing context for active requests
 	ongoingCtx, stopOngoingGracefully := context.WithCancel(context.Background())
-	
+
 	// Create readiness context to control readiness state
 	readyCtx, readyCancel := context.WithCancel(context.Background())
 	defer readyCancel()
@@ -68,10 +91,10 @@ func main() {
 	// Start server in goroutine
 	server := server.NewServer(cfg, readyCtx)
 	serverCtx, serverStop := context.WithCancel(ctx)
-	
+
 	go func() {
 		log.Info().Str("address", cfg.GetServerAddress()).Msg("Server running")
-		
+
 		srv := &http.Server{
 			Addr:    cfg.GetServerAddress(),
 			Handler: server.Router(),
@@ -79,14 +102,14 @@ func main() {
 				return ongoingCtx
 			},
 		}
-		
+
 		// Start the HTTP server in a separate goroutine
 		go func() {
 			if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
 				log.Error().Err(err).Msg("Server error")
 			}
 		}()
-		
+
 		// Wait for signal
 		<-rootCtx.Done()
 		stop()
@@ -99,28 +122,37 @@ func main() {
 		// Give time for readiness check to propagate (simplified for our case)
 		time.Sleep(1 * time.Second)
 		log.Info().Msg("Readiness check propagated, now waiting for ongoing requests to finish.")
-		
+
 		// Create shutdown context with timeout from config
 		shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), cfg.Shutdown.Timeout)
 		defer shutdownCancel()
-		
+
 		if err := srv.Shutdown(shutdownCtx); err != nil {
 			log.Error().Err(err).Msg("Server shutdown failed")
 		} else {
 			log.Info().Msg("Server shutdown complete")
 		}
-		
+
 		// Stop ongoing requests context
 		stopOngoingGracefully()
 		cancel()
 		serverStop()
 		log.Info().Msg("Server exited")
-		
+
+		// Shutdown OpenTelemetry tracer provider
+		if tracerProvider != nil {
+			if err := telemetry.Shutdown(context.Background(), tracerProvider); err != nil {
+				log.Error().Err(err).Msg("Failed to shutdown OpenTelemetry tracer provider")
+			} else {
+				log.Info().Msg("OpenTelemetry tracer provider shutdown complete")
+			}
+		}
+
 		// Force log flush by writing to stderr directly
 		// This ensures logs are written before process exits
 		time.Sleep(100 * time.Millisecond)
 	}()
-	
+
 	// Wait for shutdown
 	<-serverCtx.Done()
-}
+}