forked from mtusi2026/mtusi2026lab7
297 lines
9.1 KiB
Go
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
|
|
}
|