Files

297 lines
9.1 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"
"math"
"net"
"net/http"
"net/url"
"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"
"mtusi-messenger/internal/platform/tlsconfig"
)
// Shutdown flushes and closes providers. It is safe to call once.
type Shutdown func(context.Context) error
var globalLogProvider *sdklog.LoggerProvider
// 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
}
traceEndpoint, err := telemetryEndpoint("TRACES")
if err != nil {
return nil, err
}
metricEndpoint, err := telemetryEndpoint("METRICS")
if err != nil {
return nil, err
}
logEndpoint, err := telemetryEndpoint("LOGS")
if err != nil {
return nil, err
}
interval, err := metricInterval()
if err != nil {
return nil, err
}
sampler, err := samplerFromEnv()
if err != nil {
return nil, err
}
clientTLS, err := tlsconfig.NewClientFromEnv("")
if err != nil {
return nil, fmt.Errorf("configure telemetry tls: %w", err)
}
transport := &http.Transport{
Proxy: http.ProxyFromEnvironment,
DialContext: (&net.Dialer{
Timeout: 3 * time.Second,
KeepAlive: 30 * time.Second,
}).DialContext,
TLSClientConfig: clientTLS,
TLSHandshakeTimeout: 3 * time.Second,
ResponseHeaderTimeout: 5 * time.Second,
IdleConnTimeout: 30 * time.Second,
MaxIdleConnsPerHost: 4,
}
httpClient := &http.Client{
Transport: transport,
Timeout: 5 * time.Second,
CheckRedirect: func(*http.Request, []*http.Request) error {
return errors.New("telemetry: redirects are not permitted")
},
}
// 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,
otlptracehttp.WithEndpointURL(traceEndpoint),
otlptracehttp.WithHTTPClient(httpClient),
)
if err != nil {
return nil, fmt.Errorf("create trace exporter: %w", err)
}
metricExporter, err := otlpmetrichttp.New(ctx,
otlpmetrichttp.WithEndpointURL(metricEndpoint),
otlpmetrichttp.WithHTTPClient(httpClient),
)
if err != nil {
transport.CloseIdleConnections()
return nil, errors.Join(fmt.Errorf("create metric exporter: %w", err), traceExporter.Shutdown(ctx))
}
logExporter, err := otlploghttp.New(ctx,
otlploghttp.WithEndpointURL(logEndpoint),
otlploghttp.WithHTTPClient(httpClient),
)
if err != nil {
transport.CloseIdleConnections()
return nil, errors.Join(
fmt.Errorf("create log exporter: %w", err),
traceExporter.Shutdown(ctx),
metricExporter.Shutdown(ctx),
)
}
tracerProvider := sdktrace.NewTracerProvider(
sdktrace.WithResource(res),
sdktrace.WithSampler(sampler),
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(interval),
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()
var shutdownOnce sync.Once
var shutdownErr error
return func(shutdownCtx context.Context) error {
shutdownOnce.Do(func() {
// Each flush is bounded by both a small budget and the caller's
// overall shutdown deadline. Never revive a cancelled shutdown.
flush := func(fn func(context.Context) error) error {
ctx, cancel := context.WithTimeout(shutdownCtx, 2*time.Second)
defer cancel()
return fn(ctx)
}
shutdownErr = errors.Join(
flush(tracerProvider.Shutdown),
flush(meterProvider.Shutdown),
flush(loggerProvider.Shutdown),
)
transport.CloseIdleConnections()
})
return shutdownErr
}, 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, error) {
raw := strings.TrimSpace(os.Getenv("OTEL_METRIC_EXPORT_INTERVAL"))
if raw == "" {
return 15 * time.Second, nil
}
ms, err := strconv.ParseInt(raw, 10, 64)
if err != nil || ms <= 0 || ms > math.MaxInt64/int64(time.Millisecond) {
return 0, errors.New("telemetry: invalid otel_metric_export_interval")
}
return time.Duration(ms) * time.Millisecond, nil
}
func samplerFromEnv() (sdktrace.Sampler, error) {
name := strings.ToLower(strings.TrimSpace(os.Getenv("OTEL_TRACES_SAMPLER")))
ratio := 1.0
if raw := strings.TrimSpace(os.Getenv("OTEL_TRACES_SAMPLER_ARG")); raw != "" {
parsed, err := strconv.ParseFloat(raw, 64)
if err != nil || math.IsNaN(parsed) || parsed < 0 || parsed > 1 {
return nil, errors.New("telemetry: invalid otel_traces_sampler_arg")
}
ratio = parsed
}
switch name {
case "always_off":
return sdktrace.NeverSample(), nil
case "always_on":
return sdktrace.AlwaysSample(), nil
case "parentbased_always_off":
return sdktrace.ParentBased(sdktrace.NeverSample()), nil
case "traceidratio":
return sdktrace.TraceIDRatioBased(ratio), nil
case "parentbased_traceidratio":
return sdktrace.ParentBased(sdktrace.TraceIDRatioBased(ratio)), nil
case "", "parentbased_always_on":
return sdktrace.ParentBased(sdktrace.AlwaysSample()), nil
default:
return nil, errors.New("telemetry: invalid otel_traces_sampler")
}
}
// Signal-specific OTLP settings override the generic settings. Endpoint parsing
// happens here because SDK environment parsing otherwise silently uses defaults.
func telemetryEndpoint(signal string) (string, error) {
prefix := "OTEL_EXPORTER_OTLP_" + signal + "_"
setting := func(suffix string) string {
if value := strings.TrimSpace(os.Getenv(prefix + suffix)); value != "" {
return value
}
return strings.TrimSpace(os.Getenv("OTEL_EXPORTER_OTLP_" + suffix))
}
if raw := setting("INSECURE"); raw != "" {
insecure, err := strconv.ParseBool(raw)
if err != nil || insecure {
return "", errors.New("telemetry: otlp insecure transport is not permitted")
}
}
if protocol := setting("PROTOCOL"); protocol != "" && protocol != "http/protobuf" {
return "", errors.New("telemetry: otlp protocol must be http/protobuf")
}
raw := strings.TrimSpace(os.Getenv(prefix + "ENDPOINT"))
isSignalEndpoint := raw != ""
if raw == "" {
raw = strings.TrimSpace(os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT"))
}
if raw == "" {
raw = "https://otel-collector:4318"
}
u, err := url.Parse(raw)
if err != nil || u.Scheme != "https" || u.Hostname() == "" || u.User != nil {
return "", errors.New("telemetry: otlp endpoint must be an https url without credentials")
}
if u.RawQuery != "" || u.Fragment != "" {
return "", errors.New("telemetry: otlp endpoint must not contain a query or fragment")
}
if !isSignalEndpoint || u.Path == "" {
u.Path = strings.TrimRight(u.Path, "/") + "/v1/" + strings.ToLower(signal)
u.RawPath = ""
}
return u.String(), nil
}