138 lines
3.3 KiB
Go
138 lines
3.3 KiB
Go
package fx
|
|
|
|
import (
|
|
"context"
|
|
"log/slog"
|
|
"time"
|
|
|
|
"go.uber.org/fx"
|
|
|
|
"go.opentelemetry.io/contrib/bridges/otelslog"
|
|
"go.opentelemetry.io/otel"
|
|
"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/propagation"
|
|
olog "go.opentelemetry.io/otel/sdk/log"
|
|
"go.opentelemetry.io/otel/sdk/metric"
|
|
"go.opentelemetry.io/otel/sdk/trace"
|
|
)
|
|
|
|
func NewOtelTracerProvider(lc fx.Lifecycle) *trace.TracerProvider {
|
|
tp, err := newTracerProvider()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
lc.Append(fx.Hook{
|
|
OnStop: func(ctx context.Context) error {
|
|
return tp.Shutdown(ctx)
|
|
},
|
|
})
|
|
|
|
return tp
|
|
}
|
|
|
|
func NewOtelMeterProvider(lc fx.Lifecycle) *metric.MeterProvider {
|
|
mp, err := newMeterProvider()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
lc.Append(fx.Hook{
|
|
OnStop: func(ctx context.Context) error {
|
|
return mp.Shutdown(ctx)
|
|
},
|
|
})
|
|
|
|
return mp
|
|
}
|
|
|
|
func NewOtelLoggerProvider(lc fx.Lifecycle) *olog.LoggerProvider {
|
|
lp, err := newLoggerProvider()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
lc.Append(fx.Hook{
|
|
OnStop: func(ctx context.Context) error {
|
|
return lp.Shutdown(ctx)
|
|
},
|
|
})
|
|
|
|
return lp
|
|
}
|
|
|
|
func NewLogger(loggerProvider *olog.LoggerProvider) *slog.Logger {
|
|
logger := otelslog.NewLogger("Application", otelslog.WithLoggerProvider(loggerProvider))
|
|
return logger
|
|
}
|
|
|
|
// setupOTelSDK bootstraps the OpenTelemetry pipeline.
|
|
// If it does not return an error, make sure to call shutdown for proper cleanup.
|
|
func SetupOTelSDK(tracerProvider *trace.TracerProvider, meterProvider *metric.MeterProvider, loggerProvider *olog.LoggerProvider) {
|
|
// Set up propagator.
|
|
prop := newPropagator()
|
|
otel.SetTextMapPropagator(prop)
|
|
|
|
// Set up trace provider.
|
|
otel.SetTracerProvider(tracerProvider)
|
|
otel.SetMeterProvider(meterProvider)
|
|
|
|
// Set up logger provider.
|
|
global.SetLoggerProvider(loggerProvider)
|
|
}
|
|
|
|
func newPropagator() propagation.TextMapPropagator {
|
|
return propagation.NewCompositeTextMapPropagator(
|
|
propagation.TraceContext{},
|
|
propagation.Baggage{},
|
|
)
|
|
}
|
|
|
|
func newTracerProvider() (*trace.TracerProvider, error) {
|
|
|
|
traceExporter, err := otlptracehttp.New(context.Background())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
tracerProvider := trace.NewTracerProvider(
|
|
trace.WithBatcher(traceExporter,
|
|
// Default is 5s. Set to 1s for demonstrative purposes.
|
|
trace.WithBatchTimeout(time.Second)),
|
|
)
|
|
return tracerProvider, nil
|
|
}
|
|
|
|
func newMeterProvider() (*metric.MeterProvider, error) {
|
|
metricExporter, err := otlpmetrichttp.New(context.Background())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
meterProvider := metric.NewMeterProvider(
|
|
metric.WithReader(metric.NewPeriodicReader(metricExporter,
|
|
// Default is 1m. Set to 3s for demonstrative purposes.
|
|
metric.WithInterval(3*time.Second))),
|
|
)
|
|
return meterProvider, nil
|
|
}
|
|
|
|
func newLoggerProvider() (*olog.LoggerProvider, error) {
|
|
logExporter, err := otlploghttp.New(context.Background())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
loggerProvider := olog.NewLoggerProvider(
|
|
olog.WithProcessor(olog.NewBatchProcessor(logExporter)),
|
|
)
|
|
|
|
logger := otelslog.NewLogger("sloger", otelslog.WithLoggerProvider(loggerProvider))
|
|
logger.Info("Hello")
|
|
|
|
return loggerProvider, nil
|
|
}
|