Files
mtusi2026lab6/internal/telemetry/runtime.go
T

158 lines
4.7 KiB
Go

package telemetry
import (
"context"
"errors"
"fmt"
"time"
"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"
otellogglobal "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"
"go.opentelemetry.io/otel/trace"
)
const (
ServiceVersion = "6.0.0"
instrumentationScope = "mtusi2026lab6"
)
type Runtime struct {
Tracer trace.Tracer
Meter metric.Meter
Logger *Logger
tracerProvider *sdktrace.TracerProvider
meterProvider *sdkmetric.MeterProvider
loggerProvider *sdklog.LoggerProvider
}
func Start(
ctx context.Context,
serviceName string,
instanceID string,
deploymentEnvironment string,
) (*Runtime, error) {
res, err := resource.New(ctx, resource.WithAttributes(
attribute.String("service.name", serviceName),
attribute.String("service.version", ServiceVersion),
attribute.String("service.instance.id", instanceID),
attribute.String("deployment.environment.name", deploymentEnvironment),
))
if err != nil {
return nil, fmt.Errorf("create OpenTelemetry resource: %w", err)
}
traceExporter, err := otlptracehttp.New(ctx, otlptracehttp.WithTimeout(3*time.Second))
if err != nil {
return nil, fmt.Errorf("create OTLP trace exporter: %w", err)
}
tracerProvider := sdktrace.NewTracerProvider(
sdktrace.WithResource(res),
sdktrace.WithBatcher(
traceExporter,
sdktrace.WithBatchTimeout(time.Second),
sdktrace.WithExportTimeout(3*time.Second),
sdktrace.WithMaxQueueSize(2048),
sdktrace.WithMaxExportBatchSize(256),
),
)
metricExporter, err := otlpmetrichttp.New(ctx, otlpmetrichttp.WithTimeout(3*time.Second))
if err != nil {
_ = tracerProvider.Shutdown(context.Background())
return nil, fmt.Errorf("create OTLP metric exporter: %w", err)
}
metricReader := sdkmetric.NewPeriodicReader(
metricExporter,
sdkmetric.WithInterval(5*time.Second),
sdkmetric.WithTimeout(3*time.Second),
)
meterProvider := sdkmetric.NewMeterProvider(
sdkmetric.WithResource(res),
sdkmetric.WithReader(metricReader),
sdkmetric.WithView(durationHistogramView(
"messenger.http.server.duration",
[]float64{0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10},
)),
sdkmetric.WithView(durationHistogramView(
"messenger.worker.job.duration",
[]float64{0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60},
)),
sdkmetric.WithView(durationHistogramView(
"messenger.attachment.ready.duration",
[]float64{0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60, 120},
)),
)
logExporter, err := otlploghttp.New(ctx, otlploghttp.WithTimeout(3*time.Second))
if err != nil {
_ = meterProvider.Shutdown(context.Background())
_ = tracerProvider.Shutdown(context.Background())
return nil, fmt.Errorf("create OTLP log exporter: %w", err)
}
loggerProvider := sdklog.NewLoggerProvider(
sdklog.WithResource(res),
sdklog.WithAttributeCountLimit(32),
sdklog.WithAttributeValueLengthLimit(1024),
sdklog.WithProcessor(sdklog.NewBatchProcessor(
logExporter,
sdklog.WithMaxQueueSize(2048),
sdklog.WithExportMaxBatchSize(256),
sdklog.WithExportInterval(time.Second),
sdklog.WithExportTimeout(3*time.Second),
)),
)
otel.SetTracerProvider(tracerProvider)
otel.SetMeterProvider(meterProvider)
otellogglobal.SetLoggerProvider(loggerProvider)
otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(
propagation.TraceContext{},
propagation.Baggage{},
))
runtime := &Runtime{
Tracer: tracerProvider.Tracer(instrumentationScope),
Meter: meterProvider.Meter(instrumentationScope),
Logger: NewLogger(otellogglobal.Logger(instrumentationScope), serviceName, instanceID),
tracerProvider: tracerProvider,
meterProvider: meterProvider,
loggerProvider: loggerProvider,
}
if err = registerProcessMetrics(runtime.Meter); err != nil {
_ = runtime.Shutdown(context.Background())
return nil, err
}
return runtime, nil
}
func durationHistogramView(name string, boundaries []float64) sdkmetric.View {
return sdkmetric.NewView(
sdkmetric.Instrument{Name: name, Kind: sdkmetric.InstrumentKindHistogram},
sdkmetric.Stream{Aggregation: sdkmetric.AggregationExplicitBucketHistogram{
Boundaries: boundaries,
}},
)
}
func (runtime *Runtime) Shutdown(ctx context.Context) error {
if runtime == nil {
return nil
}
return errors.Join(
runtime.loggerProvider.Shutdown(ctx),
runtime.meterProvider.Shutdown(ctx),
runtime.tracerProvider.Shutdown(ctx),
)
}