OpenTelemetry

// Package otelinit builds one TracerProvider per service and sets it as
// the global default, alongside a W3C-standard propagator, so every
// service adopting OpenTelemetry does it identically instead of each
// reinventing exporter configuration.
package otelinit

import (
	"context"
	"time"

	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
	"go.opentelemetry.io/otel/propagation"
	"go.opentelemetry.io/otel/sdk/resource"
	sdktrace "go.opentelemetry.io/otel/sdk/trace"
	semconv "go.opentelemetry.io/otel/semconv/v1.26.0"
)

// Shutdown flushes any spans still queued in the batch processor and must
// be called during graceful shutdown, before the process exits — spans
// created in the final seconds before shutdown are otherwise silently lost.
type Shutdown func(context.Context) error

// Init points the OTLP exporter at collectorAddr (this module's Jaeger
// container, listening for OTLP directly — no separate collector process
// needed). A 5-second connect/export timeout bounds the worst case: if the
// exporter is unreachable, spans are dropped after this timeout rather
// than blocking application goroutines indefinitely.
func Init(ctx context.Context, service, collectorAddr string) (Shutdown, error) {
	exporter, err := otlptracegrpc.New(ctx,
		otlptracegrpc.WithEndpoint(collectorAddr),
		otlptracegrpc.WithInsecure(),
		otlptracegrpc.WithTimeout(5*time.Second),
	)
	if err != nil {
		return nil, err
	}

	res, err := resource.New(ctx, resource.WithAttributes(semconv.ServiceName(service)))
	if err != nil {
		return nil, err
	}

	tp := sdktrace.NewTracerProvider(
		sdktrace.WithBatcher(exporter),
		sdktrace.WithResource(res),
	)

	otel.SetTracerProvider(tp)
	otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(
		propagation.TraceContext{}, // W3C traceparent — what this module propagates everywhere
		propagation.Baggage{},
	))

	return tp.Shutdown, nil
}

package middleware

import (
	"github.com/gin-gonic/gin"
	"go.opentelemetry.io/otel/codes"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/propagation"
	"go.opentelemetry.io/otel/trace"
)

var tracer = otel.Tracer("organization")

// Tracing extracts any incoming W3C traceparent header via the global
// propagator (set once in pkg/otelinit.Init) and starts a span as its
// child. A request with no traceparent header at all — the common case
// for any request entering this platform from outside — extracts an
// empty span context, and Start simply begins a brand new trace rather
// than failing; there is no such thing as a malformed trace here, only
// the presence or absence of a parent to attach to.
func Tracing() gin.HandlerFunc {
	return func(c *gin.Context) {
		ctx := otel.GetTextMapPropagator().Extract(
			c.Request.Context(),
			propagation.HeaderCarrier(c.Request.Header),
		)

		ctx, span := tracer.Start(ctx, c.FullPath(),
			trace.WithSpanKind(trace.SpanKindServer),
		)
		defer span.End()

		c.Request = c.Request.WithContext(ctx)
		c.Next()

		if c.Writer.Status() >= 500 {
			span.SetStatus(codes.Error, "request failed")
		}
	}
}

func New(orgHandler *handler.OrganizationHandler, m *metrics.Metrics, logger zerolog.Logger) *gin.Engine {
	engine := gin.New()
	engine.Use(middleware.Tracing())
	engine.Use(middleware.RequestID(logger))
	engine.Use(gin.Recovery())
	engine.Use(middleware.ErrorHandler())
	engine.Use(m.Middleware())

	// routes unchanged below this line

func ForRequest(base zerolog.Logger, requestID, traceID string) zerolog.Logger {
	ctx := base.With()
	if requestID != "" {
		ctx = ctx.Str("request_id", requestID)
	}
	if traceID != "" {
		ctx = ctx.Str("trace_id", traceID)
	}
	return ctx.Logger()
}

		id := c.GetHeader("X-Request-ID")
		if id == "" {
			id = uuid.NewString()
		}
		c.Header("X-Request-ID", id)

		ctx := context.WithValue(c.Request.Context(), requestIDKey, id)
		traceID := trace.SpanContextFromContext(c.Request.Context()).TraceID().String()
		ctx = logging.NewContext(ctx, logging.ForRequest(logger, id, traceID))
		c.Request = c.Request.WithContext(ctx)

	shutdownTracing, err := otelinit.Init(context.Background(), "organization", "jaeger:4317")
	if err != nil {
		logger.Error().Err(err).Msg("otel init failed")
		os.Exit(1)
	}
	defer func() {
		if err := shutdownTracing(context.Background()); err != nil {
			logger.Error().Err(err).Msg("otel shutdown failed")
		}
	}()

	// pool, repo, svc, handlers, router, internal server — all unchanged
	// below this line

	span := trace.SpanFromContext(ctx)
	span.SetAttributes(attribute.String("org_id", org.ID.String()))