Files
2026-11-06 17:30:30 +03:00

186 lines
5.5 KiB
Go

// Package telemetry wires OpenTelemetry traces, metrics and logs to OTLP and
// provides the small set of instruments used by the application. Telemetry is
// best-effort: a missing Collector must never fail startup or readiness.
package telemetry
import (
"context"
"errors"
"fmt"
"os"
"strconv"
"strings"
"sync"
"time"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp"
"go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp"
"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
"go.opentelemetry.io/otel/propagation"
sdklog "go.opentelemetry.io/otel/sdk/log"
sdkmetric "go.opentelemetry.io/otel/sdk/metric"
"go.opentelemetry.io/otel/sdk/resource"
sdktrace "go.opentelemetry.io/otel/sdk/trace"
semconv "go.opentelemetry.io/otel/semconv/v1.37.0"
"mtusi-messenger/internal/platform/instanceid"
)
// Shutdown flushes and closes providers. It is safe to call once.
type Shutdown func(context.Context) error
var (
globalLogProvider *sdklog.LoggerProvider
shutdownOnce sync.Once
)
// Enabled reports whether TELEMETRY_ENABLED is not explicitly disabled.
func Enabled() bool {
return strings.ToLower(strings.TrimSpace(os.Getenv("TELEMETRY_ENABLED"))) != "0"
}
// Setup configures global OTel providers. Exporters are asynchronous and do
// not connect synchronously; an unreachable Collector only produces bounded
// background export failures.
func Setup(ctx context.Context, serviceName, version string) (Shutdown, error) {
if !Enabled() {
return func(context.Context) error { return nil }, nil
}
// resource.Default carries the SDK's schema URL (currently 1.43.0); using a
// different semconv schema in NewWithAttributes conflicts. The code resource
// is schemaless, while the SDK still provides telemetry.sdk.* attributes.
res, err := resource.Merge(
resource.Default(),
resource.NewSchemaless(
semconv.ServiceName(serviceName),
semconv.ServiceVersion(defaultVersion(version)),
semconv.ServiceInstanceID(instanceid.FromEnvOrHostname()),
semconv.DeploymentEnvironmentName("lab"),
),
)
if err != nil {
return nil, fmt.Errorf("build telemetry resource: %w", err)
}
traceExporter, err := otlptracehttp.New(ctx)
if err != nil {
return nil, fmt.Errorf("create trace exporter: %w", err)
}
metricExporter, err := otlpmetrichttp.New(ctx)
if err != nil {
return nil, fmt.Errorf("create metric exporter: %w", err)
}
logExporter, err := otlploghttp.New(ctx)
if err != nil {
return nil, fmt.Errorf("create log exporter: %w", err)
}
tracerProvider := sdktrace.NewTracerProvider(
sdktrace.WithResource(res),
sdktrace.WithSampler(samplerFromEnv()),
sdktrace.WithBatcher(traceExporter,
sdktrace.WithMaxQueueSize(2048),
sdktrace.WithMaxExportBatchSize(512),
sdktrace.WithBatchTimeout(5*time.Second),
sdktrace.WithExportTimeout(5*time.Second),
),
)
meterProvider := sdkmetric.NewMeterProvider(
sdkmetric.WithResource(res),
sdkmetric.WithReader(sdkmetric.NewPeriodicReader(
metricExporter,
sdkmetric.WithInterval(metricInterval()),
sdkmetric.WithTimeout(5*time.Second),
)),
)
loggerProvider := sdklog.NewLoggerProvider(
sdklog.WithResource(res),
sdklog.WithProcessor(sdklog.NewBatchProcessor(
logExporter,
sdklog.WithExportInterval(5*time.Second),
sdklog.WithExportTimeout(5*time.Second),
sdklog.WithMaxQueueSize(2048),
sdklog.WithExportMaxBatchSize(512),
)),
)
otel.SetTracerProvider(tracerProvider)
otel.SetMeterProvider(meterProvider)
otel.SetLoggerProvider(loggerProvider)
otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(
propagation.TraceContext{},
propagation.Baggage{},
))
globalLogProvider = loggerProvider
initMetrics()
return func(shutdownCtx context.Context) error {
var errs []error
shutdownOnce.Do(func() {
// Each provider gets its own bounded budget. Sharing one short context
// lets a slow trace flush starve the metric/log flush on shutdown.
flush := func(fn func(context.Context) error) error {
ctx, cancel := context.WithTimeout(context.WithoutCancel(shutdownCtx), 2*time.Second)
defer cancel()
return fn(ctx)
}
errs = append(errs,
flush(tracerProvider.Shutdown),
flush(meterProvider.Shutdown),
flush(loggerProvider.Shutdown),
)
})
return errors.Join(errs...)
}, nil
}
// GlobalLoggerProvider exposes the configured log provider for the slog fanout.
func GlobalLoggerProvider() *sdklog.LoggerProvider {
return globalLogProvider
}
func defaultVersion(version string) string {
if strings.TrimSpace(version) == "" {
return "dev"
}
return version
}
func metricInterval() time.Duration {
raw := strings.TrimSpace(os.Getenv("OTEL_METRIC_EXPORT_INTERVAL"))
if raw == "" {
return 15 * time.Second
}
ms, err := strconv.Atoi(raw)
if err != nil || ms <= 0 {
return 15 * time.Second
}
return time.Duration(ms) * time.Millisecond
}
func samplerFromEnv() sdktrace.Sampler {
name := strings.ToLower(strings.TrimSpace(os.Getenv("OTEL_TRACES_SAMPLER")))
ratio := 1.0
if raw := strings.TrimSpace(os.Getenv("OTEL_TRACES_SAMPLER_ARG")); raw != "" {
if parsed, err := strconv.ParseFloat(raw, 64); err == nil {
ratio = parsed
}
}
switch name {
case "always_off":
return sdktrace.NeverSample()
case "traceidratio":
return sdktrace.TraceIDRatioBased(ratio)
case "parentbased_traceidratio":
return sdktrace.ParentBased(sdktrace.TraceIDRatioBased(ratio))
default:
// The lab needs complete traces to prove the upload -> worker chain.
return sdktrace.ParentBased(sdktrace.AlwaysSample())
}
}