78 lines
2.4 KiB
Go
78 lines
2.4 KiB
Go
// Package observability provides slog-based structured logging for push-gateway.
|
|
//
|
|
// The logger emits JSON in production and a human-readable console format in
|
|
// development (DEV_MODE=true). Trace correlation is handled by attaching a
|
|
// trace_id attribute from the OpenTelemetry span context when present.
|
|
package observability
|
|
|
|
import (
|
|
"context"
|
|
"log/slog"
|
|
"os"
|
|
"time"
|
|
|
|
"go.opentelemetry.io/otel/trace"
|
|
)
|
|
|
|
// ctxKey is an unexported type so context values cannot collide with callers.
|
|
type ctxKey struct{}
|
|
|
|
// logger is the process-wide *slog.Logger initialized by InitLogger.
|
|
var logger *slog.Logger
|
|
|
|
// InitLogger configures the global slog logger. In DevMode a console handler
|
|
// with colored levels is used; otherwise a JSON handler at Info level is used.
|
|
// The logger is tagged with service=push-gateway on every emitted record.
|
|
func InitLogger(devMode bool) *slog.Logger {
|
|
var handler slog.Handler
|
|
opts := &slog.HandlerOptions{
|
|
Level: slog.LevelInfo,
|
|
}
|
|
if devMode {
|
|
opts.Level = slog.LevelDebug
|
|
handler = slog.NewTextHandler(os.Stdout, opts)
|
|
} else {
|
|
handler = slog.NewJSONHandler(os.Stdout, opts)
|
|
}
|
|
logger = slog.New(handler).With("service", "push-gateway")
|
|
slog.SetDefault(logger)
|
|
return logger
|
|
}
|
|
|
|
// Logger returns the process-wide logger initialized by InitLogger. When Init
|
|
// has not been called a fallback JSON logger is returned so callers never
|
|
// receive a nil logger.
|
|
func Logger() *slog.Logger {
|
|
if logger == nil {
|
|
logger = slog.New(slog.NewJSONHandler(os.Stdout, nil)).With("service", "push-gateway")
|
|
}
|
|
return logger
|
|
}
|
|
|
|
// WithContext returns a copy of ctx carrying l so it can later be retrieved
|
|
// via FromContext.
|
|
func WithContext(ctx context.Context, l *slog.Logger) context.Context {
|
|
return context.WithValue(ctx, ctxKey{}, l)
|
|
}
|
|
|
|
// FromContext returns the logger stored in ctx. When an OpenTelemetry span is
|
|
// active the returned logger is decorated with a trace_id field so log lines
|
|
// can be correlated to traces. If no logger was stored in ctx the
|
|
// process-wide logger is returned (never nil).
|
|
func FromContext(ctx context.Context) *slog.Logger {
|
|
l, ok := ctx.Value(ctxKey{}).(*slog.Logger)
|
|
if !ok || l == nil {
|
|
l = Logger()
|
|
}
|
|
if sc := trace.SpanContextFromContext(ctx); sc.HasTraceID() {
|
|
return l.With("trace_id", sc.TraceID().String())
|
|
}
|
|
return l
|
|
}
|
|
|
|
// Now returns the current UTC time in RFC3339 format. Convenience helper for
|
|
// log field construction.
|
|
func Now() string {
|
|
return time.Now().UTC().Format(time.RFC3339)
|
|
}
|