common/tracing/tracing.go

package tracing

import (
	"context"
	"os"

	"go.ntppool.org/common/logger"
	"go.ntppool.org/common/version"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/exporters/otlp/otlptrace"
	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
	"go.opentelemetry.io/otel/propagation"
	"go.opentelemetry.io/otel/sdk/resource"
	otelsdktrace "go.opentelemetry.io/otel/sdk/trace"
	semconv "go.opentelemetry.io/otel/semconv/v1.21.0"
	"go.opentelemetry.io/otel/trace"
)

// https://github.com/open-telemetry/opentelemetry-go/blob/main/exporters/otlp/otlptrace/otlptracehttp/example_test.go

type TpShutdownFunc func(ctx context.Context) error

func Tracer() trace.Tracer {
	traceProvider := otel.GetTracerProvider()
	return traceProvider.Tracer("ntppool-tracer")
}

type TracerConfig struct {
	ServiceName string
	Environment string
}

var emptyTpShutdownFunc = func(_ context.Context) error {
	return nil
}

func InitTracer(ctx context.Context, cfg *TracerConfig) (TpShutdownFunc, error) {

	log := logger.Setup()

	// exporter, err := srv.newStdoutExporter(os.Stdout)

	var err error
	var exporter otelsdktrace.SpanExporter

	if otlpEndPoint := os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT"); len(otlpEndPoint) > 0 {
		exporter, err = newOLTPExporter(ctx)
	}

	if err != nil {
		return emptyTpShutdownFunc, err
	}

	if exporter == nil {
		log.Warn("tracing not configured")
		return emptyTpShutdownFunc, nil
	}

	tp := otelsdktrace.NewTracerProvider(
		otelsdktrace.WithSampler(otelsdktrace.AlwaysSample()),
		otelsdktrace.WithBatcher(exporter),
		otelsdktrace.WithResource(newResource(cfg)),
	)

	otel.SetTracerProvider(tp)
	otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(propagation.TraceContext{}, propagation.Baggage{}))

	return tp.Shutdown, nil
}

func newOLTPExporter(ctx context.Context) (otelsdktrace.SpanExporter, error) {
	client := otlptracehttp.NewClient()
	exporter, err := otlptrace.New(ctx, client)
	if err != nil {
		logger.Setup().Error("creating OTLP trace exporter", "err", err)
	}
	return exporter, err
}

// func (srv *Server) newStdoutExporter(w io.Writer) (sdktrace.SpanExporter, error) {
// 	return stdouttrace.New(
// 		stdouttrace.WithWriter(w),
// 		// Use human-readable output.
// 		stdouttrace.WithPrettyPrint(),
// 		// Do not print timestamps for the demo.
// 		stdouttrace.WithoutTimestamps(),
// 	)
// }

// newResource returns a resource describing this application.
func newResource(cfg *TracerConfig) *resource.Resource {
	r, err := resource.Merge(
		resource.Default(),
		resource.NewWithAttributes(
			semconv.SchemaURL,
			semconv.ServiceNameKey.String(cfg.ServiceName),
			semconv.ServiceVersionKey.String(version.Version()),
			attribute.String("environment", cfg.Environment),
		),
	)
	if err != nil {
		panic(err)
	}

	return r
}