forked from mtusi2026/mtusi2026lab6
158 lines
4.7 KiB
Go
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),
|
|
)
|
|
}
|