// Package telemetry owns bounded OpenTelemetry providers and safe instrumentation. package telemetry import ( "context" "errors" "fmt" "math" "net/url" "strings" "time" "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" otellog "go.opentelemetry.io/otel/log" "go.opentelemetry.io/otel/metric" 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" "go.opentelemetry.io/otel/trace" "gitea.privcloud.tech/vlad_marlo/mtusi2026lab6/internal/config" ) // Runtime owns providers; Shutdown is called once by the application lifecycle. type Runtime struct { traces *sdktrace.TracerProvider metrics *sdkmetric.MeterProvider logs *sdklog.LoggerProvider tracer trace.Tracer logger otellog.Logger meter metric.Meter instruments instruments enabled bool } // New builds nonblocking bounded exporters; backend availability is never a startup dependency. func New(ctx context.Context, cfg *config.Telemetry) (*Runtime, error) { if cfg == nil { return nil, fmt.Errorf("telemetry configuration is required") } if math.IsNaN(cfg.SampleRatio) || cfg.SampleRatio < 0 || cfg.SampleRatio > 1 { return nil, fmt.Errorf("telemetry sampling ratio must be in [0,1]") } if cfg.Endpoint != "" { endpoint, err := url.Parse(cfg.Endpoint) if err != nil || endpoint.Host == "" || (endpoint.Scheme != "http" && endpoint.Scheme != "https") || endpoint.User != nil { return nil, fmt.Errorf("invalid telemetry endpoint") } } res := resource.NewSchemaless(attribute.String("service.name", cfg.Service), attribute.String("service.version", cfg.Version), attribute.String("service.instance.id", cfg.Instance), attribute.String("deployment.environment.name", "lab")) traceOptions := []sdktrace.TracerProviderOption{sdktrace.WithResource(res), sdktrace.WithSampler(sdktrace.ParentBased(sdktrace.TraceIDRatioBased(cfg.SampleRatio)))} metricOptions := []sdkmetric.Option{sdkmetric.WithResource(res), sdkmetric.WithView(sdkmetric.NewView(sdkmetric.Instrument{Kind: sdkmetric.InstrumentKindHistogram}, sdkmetric.Stream{Aggregation: sdkmetric.AggregationExplicitBucketHistogram{Boundaries: []float64{.005, .01, .025, .05, .1, .25, .5, 1, 2, 5, 10, 30, 60, 120}}}))} logOptions := []sdklog.LoggerProviderOption{sdklog.WithResource(res)} if cfg.Endpoint != "" { traces, err := otlptracehttp.New(ctx, otlptracehttp.WithEndpointURL(strings.TrimRight(cfg.Endpoint, "/")+"/v1/traces"), otlptracehttp.WithTimeout(time.Second), otlptracehttp.WithRetry(otlptracehttp.RetryConfig{Enabled: false})) if err != nil { return nil, err } metrics, err := otlpmetrichttp.New(ctx, otlpmetrichttp.WithEndpointURL(strings.TrimRight(cfg.Endpoint, "/")+"/v1/metrics"), otlpmetrichttp.WithTimeout(time.Second), otlpmetrichttp.WithRetry(otlpmetrichttp.RetryConfig{Enabled: false})) if err != nil { return nil, errors.Join(err, traces.Shutdown(ctx)) } logs, err := otlploghttp.New(ctx, otlploghttp.WithEndpointURL(strings.TrimRight(cfg.Endpoint, "/")+"/v1/logs"), otlploghttp.WithTimeout(time.Second), otlploghttp.WithRetry(otlploghttp.RetryConfig{Enabled: false})) if err != nil { return nil, errors.Join(err, traces.Shutdown(ctx), metrics.Shutdown(ctx)) } traceOptions = append(traceOptions, sdktrace.WithBatcher(traces, sdktrace.WithMaxQueueSize(256), sdktrace.WithMaxExportBatchSize(64), sdktrace.WithBatchTimeout(time.Second), sdktrace.WithExportTimeout(time.Second))) metricOptions = append(metricOptions, sdkmetric.WithReader(sdkmetric.NewPeriodicReader(metrics, sdkmetric.WithInterval(5*time.Second), sdkmetric.WithTimeout(time.Second)))) logOptions = append(logOptions, sdklog.WithProcessor(sdklog.NewBatchProcessor(logs, sdklog.WithMaxQueueSize(256), sdklog.WithExportMaxBatchSize(64), sdklog.WithExportInterval(time.Second), sdklog.WithExportTimeout(time.Second), sdklog.WithExportBufferSize(1)))) } r := &Runtime{traces: sdktrace.NewTracerProvider(traceOptions...), metrics: sdkmetric.NewMeterProvider(metricOptions...), logs: sdklog.NewLoggerProvider(logOptions...), enabled: cfg.Endpoint != ""} r.tracer = r.traces.Tracer("messenger") r.meter = r.metrics.Meter("messenger") r.logger = r.logs.Logger("messenger") r.instruments = newInstruments(r.meter) return r, nil } // Shutdown flushes all providers under the lifecycle's bounded deadline. func (r *Runtime) Shutdown(ctx context.Context) error { return errors.Join(r.traces.Shutdown(ctx), r.metrics.Shutdown(ctx), r.logs.Shutdown(ctx)) }