forked from mtusi2026/mtusi2026lab6
227 lines
8.9 KiB
Go
227 lines
8.9 KiB
Go
// Package telemetry — OpenTelemetry SDK для API, relay и worker.
|
||
//
|
||
// Три сигнала уходят по OTLP/HTTP в Collector (OTEL_EXPORTER_OTLP_ENDPOINT):
|
||
// трассы (BatchSpanProcessor, ограниченная очередь), метрики (периодический
|
||
// reader, cumulative) и логи (slog → otelslog bridge, BatchProcessor). Параллельно
|
||
// каждый лог пишется JSON в stdout с trace_id/span_id — это локальный резерв на
|
||
// случай недоступного Collector (docker logs).
|
||
//
|
||
// OTEL_SDK_DISABLED=true выключает экспорт (трек 1: «telemetry off»): провайдеры
|
||
// остаются no-op, stdout-логи сохраняются. Sampler задаётся стандартными
|
||
// OTEL_TRACES_SAMPLER / OTEL_TRACES_SAMPLER_ARG (читает сам SDK).
|
||
package telemetry
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"log/slog"
|
||
"os"
|
||
"strings"
|
||
"time"
|
||
|
||
"go.opentelemetry.io/contrib/bridges/otelslog"
|
||
"go.opentelemetry.io/contrib/instrumentation/host"
|
||
"go.opentelemetry.io/contrib/instrumentation/runtime"
|
||
"go.opentelemetry.io/otel"
|
||
"go.opentelemetry.io/otel/attribute"
|
||
"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/log/global"
|
||
"go.opentelemetry.io/otel/metric"
|
||
"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.43.0"
|
||
"go.opentelemetry.io/otel/trace"
|
||
)
|
||
|
||
// ScopeName — имя instrumentation scope для собственных инструментов.
|
||
const ScopeName = "github.com/charawein/mtusi2026lab6"
|
||
|
||
// Version — service.version (задаётся при сборке через -ldflags, иначе dev).
|
||
var Version = "dev"
|
||
|
||
// Enabled — экспортирует ли процесс телеметрию.
|
||
func Enabled() bool { return !strings.EqualFold(os.Getenv("OTEL_SDK_DISABLED"), "true") }
|
||
|
||
// Setup настраивает провайдеры и slog. serviceName — значение по умолчанию,
|
||
// OTEL_SERVICE_NAME имеет приоритет (так API и worker различаются в compose).
|
||
func Setup(ctx context.Context, serviceName, instanceID string, level slog.Leveler) (func(context.Context) error, error) {
|
||
if v := os.Getenv("OTEL_SERVICE_NAME"); v != "" {
|
||
serviceName = v
|
||
}
|
||
otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(propagation.TraceContext{}, propagation.Baggage{}))
|
||
stdout := slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: level})
|
||
|
||
if !Enabled() {
|
||
slog.SetDefault(slog.New(&traceHandler{next: stdout, service: serviceName}))
|
||
return func(context.Context) error { return nil }, nil
|
||
}
|
||
|
||
res, err := resource.Merge(resource.Default(), resource.NewWithAttributes(semconv.SchemaURL,
|
||
semconv.ServiceName(serviceName),
|
||
semconv.ServiceVersion(Version),
|
||
semconv.ServiceInstanceID(instanceID),
|
||
attribute.String("deployment.environment.name", "lab"),
|
||
))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
// OTEL_RESOURCE_ATTRIBUTES (если заданы) дополняют/переопределяют.
|
||
if envRes, err := resource.New(ctx, resource.WithFromEnv()); err == nil {
|
||
if merged, err := resource.Merge(res, envRes); err == nil {
|
||
res = merged
|
||
}
|
||
}
|
||
|
||
traceExp, err := otlptracehttp.New(ctx)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
// Очередь BatchSpanProcessor ограничена: при недоступном Collector новые
|
||
// spans отбрасываются, а не копятся в памяти процесса.
|
||
tp := sdktrace.NewTracerProvider(
|
||
sdktrace.WithResource(res),
|
||
sdktrace.WithBatcher(traceExp,
|
||
sdktrace.WithMaxQueueSize(4096),
|
||
sdktrace.WithMaxExportBatchSize(512),
|
||
sdktrace.WithBatchTimeout(2*time.Second),
|
||
sdktrace.WithExportTimeout(5*time.Second)),
|
||
)
|
||
otel.SetTracerProvider(tp)
|
||
|
||
metricExp, err := otlpmetrichttp.New(ctx)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
mp := sdkmetric.NewMeterProvider(
|
||
sdkmetric.WithResource(res),
|
||
sdkmetric.WithReader(sdkmetric.NewPeriodicReader(metricExp, sdkmetric.WithInterval(5*time.Second), sdkmetric.WithTimeout(4*time.Second))),
|
||
sdkmetric.WithView(histogramViews()...),
|
||
)
|
||
otel.SetMeterProvider(mp)
|
||
|
||
logExp, err := otlploghttp.New(ctx)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
lp := sdklog.NewLoggerProvider(
|
||
sdklog.WithResource(res),
|
||
sdklog.WithProcessor(sdklog.NewBatchProcessor(logExp, sdklog.WithMaxQueueSize(4096), sdklog.WithExportTimeout(5*time.Second))),
|
||
)
|
||
global.SetLoggerProvider(lp)
|
||
|
||
bridge := otelslog.NewHandler(ScopeName, otelslog.WithLoggerProvider(lp), otelslog.WithSource(false))
|
||
slog.SetDefault(slog.New(&traceHandler{next: stdout, otlp: bridge, service: serviceName, level: level}))
|
||
|
||
if err := runtime.Start(runtime.WithMeterProvider(mp), runtime.WithMinimumReadMemStatsInterval(5*time.Second)); err != nil {
|
||
slog.Warn("runtime metrics", "err", err)
|
||
}
|
||
if err := host.Start(host.WithMeterProvider(mp)); err != nil {
|
||
slog.Warn("host metrics", "err", err)
|
||
}
|
||
|
||
return func(ctx context.Context) error {
|
||
return errors.Join(tp.Shutdown(ctx), mp.Shutdown(ctx), lp.Shutdown(ctx))
|
||
}, nil
|
||
}
|
||
|
||
// Границы buckets (секунды) под ожидаемые задержки: HTTP — миллисекунды…секунды,
|
||
// обработка job и время до ready — сотни миллисекунд…минуты.
|
||
var (
|
||
httpBuckets = []float64{0.002, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30}
|
||
jobBuckets = []float64{0.05, 0.1, 0.25, 0.5, 1, 2, 5, 10, 20, 30, 60, 120, 300}
|
||
)
|
||
|
||
func histogramViews() []sdkmetric.View {
|
||
view := func(name string, b []float64) sdkmetric.View {
|
||
return sdkmetric.NewView(sdkmetric.Instrument{Name: name},
|
||
sdkmetric.Stream{Aggregation: sdkmetric.AggregationExplicitBucketHistogram{Boundaries: b}})
|
||
}
|
||
return []sdkmetric.View{
|
||
view("http.server.request.duration", httpBuckets),
|
||
view("messenger.job.duration", jobBuckets),
|
||
view("messenger.attachment.time_to_ready", jobBuckets),
|
||
view("messenger.outbox.publish.duration", httpBuckets),
|
||
}
|
||
}
|
||
|
||
// Meter / Tracer — собственные инструменты (no-op, если экспорт выключен).
|
||
func Meter() metric.Meter { return otel.Meter(ScopeName) }
|
||
func Tracer() trace.Tracer { return otel.Tracer(ScopeName) }
|
||
|
||
// traceHandler пишет JSON в stdout (с trace_id/span_id активного span) и
|
||
// дублирует запись в OTLP-мост (тот берёт trace context из ctx сам).
|
||
type traceHandler struct {
|
||
next slog.Handler
|
||
otlp slog.Handler
|
||
service string
|
||
level slog.Leveler
|
||
}
|
||
|
||
func (h *traceHandler) Enabled(ctx context.Context, l slog.Level) bool { return h.next.Enabled(ctx, l) }
|
||
|
||
func (h *traceHandler) Handle(ctx context.Context, r slog.Record) error {
|
||
if sc := trace.SpanContextFromContext(ctx); sc.IsValid() {
|
||
r.AddAttrs(slog.String("trace_id", sc.TraceID().String()), slog.String("span_id", sc.SpanID().String()))
|
||
}
|
||
if h.otlp != nil && h.otlp.Enabled(ctx, r.Level) {
|
||
_ = h.otlp.Handle(ctx, r.Clone())
|
||
}
|
||
r.AddAttrs(slog.String("service.name", h.service))
|
||
return h.next.Handle(ctx, r)
|
||
}
|
||
|
||
func (h *traceHandler) WithAttrs(as []slog.Attr) slog.Handler {
|
||
c := *h
|
||
c.next = h.next.WithAttrs(as)
|
||
if h.otlp != nil {
|
||
c.otlp = h.otlp.WithAttrs(as)
|
||
}
|
||
return &c
|
||
}
|
||
|
||
func (h *traceHandler) WithGroup(name string) slog.Handler {
|
||
c := *h
|
||
c.next = h.next.WithGroup(name)
|
||
if h.otlp != nil {
|
||
c.otlp = h.otlp.WithGroup(name)
|
||
}
|
||
return &c
|
||
}
|
||
|
||
// --- перенос контекста через outbox и broker ---
|
||
|
||
// InjectMap сериализует активный trace context (W3C traceparent/tracestate).
|
||
func InjectMap(ctx context.Context) map[string]string {
|
||
c := propagation.MapCarrier{}
|
||
otel.GetTextMapPropagator().Inject(ctx, c)
|
||
if len(c) == 0 {
|
||
return nil
|
||
}
|
||
return c
|
||
}
|
||
|
||
// ExtractMap восстанавливает контекст родителя из map.
|
||
func ExtractMap(ctx context.Context, m map[string]string) context.Context {
|
||
if len(m) == 0 {
|
||
return ctx
|
||
}
|
||
return otel.GetTextMapPropagator().Extract(ctx, propagation.MapCarrier(m))
|
||
}
|
||
|
||
// Unsampled возвращает контекст с не-сэмплированным родителем: дочерние spans
|
||
// (pgx, S3) при ParentBased-sampler не создаются. Для фоновых циклов и health
|
||
// checks, чтобы служебные запросы раз в 300 ms не превращались в отдельные трассы.
|
||
func Unsampled(ctx context.Context) context.Context {
|
||
var tid trace.TraceID
|
||
var sid trace.SpanID
|
||
tid[0], sid[0] = 1, 1
|
||
return trace.ContextWithRemoteSpanContext(ctx, trace.NewSpanContext(trace.SpanContextConfig{
|
||
TraceID: tid, SpanID: sid, TraceFlags: 0, Remote: true,
|
||
}))
|
||
}
|