forked from mtusi2026/mtusi2026lab6
186 lines
5.5 KiB
Go
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())
|
|
}
|
|
}
|