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) }