cringe

enshi_back/routes/routesSetup.go

@@ -1,6 +1,7 @@
 package routes
 
 import (
+	"context"
 	"enshi/middleware"
 	"enshi/middleware/getters"
 	"enshi/routes/authRoutes"
@@ -10,16 +11,28 @@ import (
 	"enshi/routes/userProfileRoutes"
 	userroutes "enshi/routes/userRoutes"
 	voteroutes "enshi/routes/voteRoutes"
-	"io"
 	"log"
 	"net/http"
+	"os"
 	"strings"
 
 	"github.com/gin-gonic/gin"
-	"github.com/opentracing-contrib/go-gin/ginhttp"
-	"github.com/opentracing/opentracing-go"
-	"github.com/uber/jaeger-client-go"
-	jaegercfg "github.com/uber/jaeger-client-go/config"
+
+	"go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
+	"google.golang.org/grpc/credentials"
+
+	"go.opentelemetry.io/otel/sdk/resource"
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
+)
+
+var (
+	serviceName  = os.Getenv("SERVICE_NAME")
+	collectorURL = os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
+	insecure     = os.Getenv("INSECURE_MODE")
 )
 
 func testCookie(c *gin.Context) {
@@ -48,40 +61,55 @@ func testAuth(c *gin.Context) {
 	)
 }
 
-func initJaeger(service string) (opentracing.Tracer, io.Closer, error) {
-	cfg := jaegercfg.Configuration{
-		ServiceName: service,
-		Sampler: &jaegercfg.SamplerConfig{
-			Type:  jaeger.SamplerTypeConst, // sample every trace; for production consider probabilistic sampling
-			Param: 1,
-		},
-		Reporter: &jaegercfg.ReporterConfig{
-			LogSpans:           true,
-			LocalAgentHostPort: "localhost:6831", // make sure this matches your Docker settings
-		},
+func initTracer() func(context.Context) error {
+
+	var secureOption otlptracegrpc.Option
+
+	if strings.ToLower(insecure) == "false" || insecure == "0" || strings.ToLower(insecure) == "f" {
+		secureOption = otlptracegrpc.WithTLSCredentials(credentials.NewClientTLSFromCert(nil, ""))
+	} else {
+		secureOption = otlptracegrpc.WithInsecure()
 	}
 
-	tracer, closer, err := cfg.NewTracer()
-	return tracer, closer, err
+	exporter, err := otlptrace.New(
+		context.Background(),
+		otlptracegrpc.NewClient(
+			secureOption,
+			otlptracegrpc.WithEndpoint(collectorURL),
+		),
+	)
+
+	if err != nil {
+		log.Fatalf("Failed to create exporter: %v", err)
+	}
+	resources, err := resource.New(
+		context.Background(),
+		resource.WithAttributes(
+			attribute.String("service.name", serviceName),
+			attribute.String("library.language", "go"),
+		),
+	)
+	if err != nil {
+		log.Fatalf("Could not set resources: %v", err)
+	}
+
+	otel.SetTracerProvider(
+		sdktrace.NewTracerProvider(
+			sdktrace.WithSampler(sdktrace.AlwaysSample()),
+			sdktrace.WithBatcher(exporter),
+			sdktrace.WithResource(resources),
+		),
+	)
+	return exporter.Shutdown
 }
 
 func SetupRotes(g *gin.Engine) error {
 	InitMiddlewareProvider()
 
-	// Initialize Jaeger Tracer
-	tracer, closer, err := initJaeger("go-gin-jaeger-example")
-	if err != nil {
-		log.Fatalf("Could not initialize jaeger tracer: %s", err.Error())
-	}
-	defer closer.Close()
-
-	// Set the global tracer (thread-safe and available everywhere)
-	opentracing.SetGlobalTracer(tracer)
-
-	// Attach the OpenTracing middleware to Gin.
-	// This middleware will extract any incoming tracing information and start a server span.
-	g.Use(ginhttp.Middleware(tracer))
+	cleanup := initTracer()
+	defer cleanup(context.Background())
 
+	g.Use(otelgin.Middleware(serviceName))
 	g.Use(middleware.CORSMiddleware())
 	g.Use(middleware.TargetMiddleware())