Commit: Bulk unfinished work

fx/logger.go

@@ -0,0 +1,137 @@
+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
+}