cart and checkout

pkg/telemetry/logs.go

@@ -0,0 +1,88 @@
+// Package telemetry holds shared OpenTelemetry setup helpers used by the
+// service main packages (cart, checkout, profile, …).
+package telemetry
+
+import (
+	"context"
+	"math/rand/v2"
+	"os"
+	"strconv"
+
+	"go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc"
+	"go.opentelemetry.io/otel/sdk/log"
+)
+
+// NewLoggerProvider builds the OTLP log provider from the environment, or returns
+// (nil, nil) when logs are disabled — in which case the caller MUST skip
+// global.SetLoggerProvider and the shutdown registration.
+//
+// Env:
+//
+//	OTEL_LOGS_ENABLED       "1"/"true"/"yes"/"on" to enable the OTLP log pipeline.
+//	                        Default OFF: the batch processor clones its record ring
+//	                        on every export, which profiling showed to be the
+//	                        dominant heap allocator in these services. Traces and
+//	                        metrics are always on regardless of this flag.
+//	OTEL_LOGS_SAMPLE_RATIO  fraction of records to export, 0.0–1.0 (default 1.0).
+//	                        e.g. 0.1 keeps ~10% of logs. Dropped records never reach
+//	                        the batch ring, so allocation churn falls ~proportionally.
+func NewLoggerProvider(ctx context.Context) (*log.LoggerProvider, error) {
+	if !logsEnabled() {
+		return nil, nil
+	}
+	exporter, err := otlploggrpc.New(ctx)
+	if err != nil {
+		return nil, err
+	}
+	var proc log.Processor = log.NewBatchProcessor(exporter)
+	if ratio := sampleRatio(); ratio < 1.0 {
+		proc = &samplingProcessor{next: proc, ratio: ratio}
+	}
+	return log.NewLoggerProvider(log.WithProcessor(proc)), nil
+}
+
+func logsEnabled() bool {
+	switch os.Getenv("OTEL_LOGS_ENABLED") {
+	case "1", "true", "TRUE", "True", "yes", "on":
+		return true
+	default:
+		return false
+	}
+}
+
+func sampleRatio() float64 {
+	v := os.Getenv("OTEL_LOGS_SAMPLE_RATIO")
+	if v == "" {
+		return 1.0
+	}
+	r, err := strconv.ParseFloat(v, 64)
+	if err != nil || r < 0 {
+		return 1.0
+	}
+	if r > 1 {
+		return 1.0
+	}
+	return r
+}
+
+// samplingProcessor forwards a random `ratio` fraction of records to the wrapped
+// processor and drops the rest before they reach the (allocation-heavy) batch
+// ring. This is head sampling: cheap, stateless, and per-record independent.
+type samplingProcessor struct {
+	next  log.Processor
+	ratio float64
+}
+
+func (s *samplingProcessor) Enabled(ctx context.Context, param log.EnabledParameters) bool {
+	return s.next.Enabled(ctx, param)
+}
+
+func (s *samplingProcessor) OnEmit(ctx context.Context, record *log.Record) error {
+	if rand.Float64() >= s.ratio {
+		return nil // dropped by sampling
+	}
+	return s.next.OnEmit(ctx, record)
+}
+
+func (s *samplingProcessor) Shutdown(ctx context.Context) error   { return s.next.Shutdown(ctx) }
+func (s *samplingProcessor) ForceFlush(ctx context.Context) error { return s.next.ForceFlush(ctx) }

pkg/telemetry/otel.go

@@ -0,0 +1,97 @@
+package telemetry
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
+	"go.opentelemetry.io/otel/log/global"
+	"go.opentelemetry.io/otel/propagation"
+	"go.opentelemetry.io/otel/sdk/metric"
+	"go.opentelemetry.io/otel/sdk/trace"
+)
+
+// SetupOTelSDK bootstraps the OpenTelemetry pipeline (propagator + traces +
+// metrics, and an opt-in logger — see NewLoggerProvider). It is shared by every
+// service main package; the service name comes from OTEL_RESOURCE_ATTRIBUTES, so
+// the same setup works everywhere. If it returns no error, call the returned
+// shutdown for proper cleanup.
+func SetupOTelSDK(ctx context.Context) (func(context.Context) error, error) {
+	var shutdownFuncs []func(context.Context) error
+	var err error
+
+	// shutdown calls the registered cleanup functions, joining their errors.
+	shutdown := func(ctx context.Context) error {
+		var err error
+		for _, fn := range shutdownFuncs {
+			err = errors.Join(err, fn(ctx))
+		}
+		shutdownFuncs = nil
+		return err
+	}
+
+	// handleErr runs shutdown and surfaces all errors.
+	handleErr := func(inErr error) {
+		err = errors.Join(inErr, shutdown(ctx))
+	}
+
+	otel.SetTextMapPropagator(newPropagator())
+
+	tracerProvider, err := newTracerProvider()
+	if err != nil {
+		handleErr(err)
+		return shutdown, err
+	}
+	shutdownFuncs = append(shutdownFuncs, tracerProvider.Shutdown)
+	otel.SetTracerProvider(tracerProvider)
+
+	meterProvider, err := newMeterProvider()
+	if err != nil {
+		handleErr(err)
+		return shutdown, err
+	}
+	shutdownFuncs = append(shutdownFuncs, meterProvider.Shutdown)
+	otel.SetMeterProvider(meterProvider)
+
+	// Logger provider is opt-in via OTEL_LOGS_ENABLED; nil means logs are off.
+	// Traces + metrics above are always on.
+	loggerProvider, err := NewLoggerProvider(ctx)
+	if err != nil {
+		handleErr(err)
+		return shutdown, err
+	}
+	if loggerProvider != nil {
+		shutdownFuncs = append(shutdownFuncs, loggerProvider.Shutdown)
+		global.SetLoggerProvider(loggerProvider)
+	}
+
+	return shutdown, err
+}
+
+func newPropagator() propagation.TextMapPropagator {
+	return propagation.NewCompositeTextMapPropagator(
+		propagation.TraceContext{},
+		propagation.Baggage{},
+	)
+}
+
+func newTracerProvider() (*trace.TracerProvider, error) {
+	traceExporter, err := otlptracegrpc.New(context.Background())
+	if err != nil {
+		return nil, err
+	}
+	return trace.NewTracerProvider(
+		trace.WithBatcher(traceExporter, trace.WithBatchTimeout(time.Second)),
+	), nil
+}
+
+func newMeterProvider() (*metric.MeterProvider, error) {
+	exporter, err := otlpmetricgrpc.New(context.Background())
+	if err != nil {
+		return nil, err
+	}
+	return metric.NewMeterProvider(metric.WithReader(metric.NewPeriodicReader(exporter))), nil
+}