From ab94adb925d58c0983f06bb65381f840dc0231be Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ask=20Bj=C3=B8rn=20Hansen?= <ask@develooper.com>
Date: Sat, 9 Nov 2024 10:19:16 +0000
Subject: [PATCH] tracing: setup log provider

---
 tracing/tracing.go | 63 +++++++++++++++++++++++++++++++++-------------
 1 file changed, 46 insertions(+), 17 deletions(-)

diff --git a/tracing/tracing.go b/tracing/tracing.go
index 0f7129b..7961432 100644
--- a/tracing/tracing.go
+++ b/tracing/tracing.go
@@ -9,6 +9,7 @@ import (
 	"crypto/x509"
 	"errors"
 	"os"
+	"slices"
 	"time"
 
 	"go.ntppool.org/common/logger"
@@ -21,9 +22,11 @@ import (
 	"go.opentelemetry.io/otel/exporters/otlp/otlptrace"
 	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
 	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
+	logglobal "go.opentelemetry.io/otel/log/global"
 	"go.opentelemetry.io/otel/propagation"
+	sdklog "go.opentelemetry.io/otel/sdk/log"
 	"go.opentelemetry.io/otel/sdk/resource"
-	otelsdktrace "go.opentelemetry.io/otel/sdk/trace"
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
 	semconv "go.opentelemetry.io/otel/semconv/v1.26.0"
 	"go.opentelemetry.io/otel/trace"
 )
@@ -64,15 +67,17 @@ type TracerConfig struct {
 }
 
 func InitTracer(ctx context.Context, cfg *TracerConfig) (TpShutdownFunc, error) {
+	// todo: setup environment from cfg
 	return SetupSDK(ctx, cfg)
 }
 
 func SetupSDK(ctx context.Context, cfg *TracerConfig) (shutdown TpShutdownFunc, err error) {
+	if cfg == nil {
+		cfg = &TracerConfig{}
+	}
 
 	log := logger.Setup()
 
-	log.Warn("SetupSDK")
-
 	if serviceName := os.Getenv(svcNameKey); len(serviceName) == 0 {
 		if len(cfg.ServiceName) > 0 {
 			os.Setenv(svcNameKey, cfg.ServiceName)
@@ -113,10 +118,18 @@ func SetupSDK(ctx context.Context, cfg *TracerConfig) (shutdown TpShutdownFunc,
 	var shutdownFuncs []func(context.Context) error
 	shutdown = func(ctx context.Context) error {
 		var err error
+		// need to shutdown the providers first,
+		// exporters after which is the opposite
+		// order they are setup.
+		slices.Reverse(shutdownFuncs)
 		for _, fn := range shutdownFuncs {
+			// log.Warn("shutting down", "fn", fn)
 			err = errors.Join(err, fn(ctx))
 		}
 		shutdownFuncs = nil
+		if err != nil {
+			log.Warn("shutdown returned errors", "err", err)
+		}
 		return err
 	}
 
@@ -128,29 +141,32 @@ func SetupSDK(ctx context.Context, cfg *TracerConfig) (shutdown TpShutdownFunc,
 	prop := newPropagator()
 	otel.SetTextMapPropagator(prop)
 
-	var exporter otelsdktrace.SpanExporter
+	var spanExporter sdktrace.SpanExporter
 
 	switch os.Getenv("OTEL_TRACES_EXPORTER") {
 	case "":
-		exporter, err = newOLTPExporter(ctx, cfg)
+		spanExporter, err = newOLTPExporter(ctx, cfg)
 	case "otlp":
-		exporter, err = newOLTPExporter(ctx, cfg)
+		spanExporter, err = newOLTPExporter(ctx, cfg)
 	default:
-		exporter, err = autoexport.NewSpanExporter(ctx)
+		// log.Debug("OTEL_TRACES_EXPORTER", "fallback", os.Getenv("OTEL_TRACES_EXPORTER"))
+		spanExporter, err = autoexport.NewSpanExporter(ctx)
 	}
 	if err != nil {
 		handleErr(err)
 		return
 	}
-	shutdownFuncs = append(shutdownFuncs, exporter.Shutdown)
+	shutdownFuncs = append(shutdownFuncs, spanExporter.Shutdown)
 
-	if exporter == nil {
-		log.Warn("tracing not configured")
+	logExporter, err := autoexport.NewLogExporter(ctx)
+	if err != nil {
+		handleErr(err)
 		return
 	}
+	shutdownFuncs = append(shutdownFuncs, logExporter.Shutdown)
 
 	// Set up trace provider.
-	tracerProvider, err := newTraceProvider(exporter, res)
+	tracerProvider, err := newTraceProvider(spanExporter, res)
 	if err != nil {
 		handleErr(err)
 		return
@@ -158,6 +174,19 @@ func SetupSDK(ctx context.Context, cfg *TracerConfig) (shutdown TpShutdownFunc,
 	shutdownFuncs = append(shutdownFuncs, tracerProvider.Shutdown)
 	otel.SetTracerProvider(tracerProvider)
 
+	logProvider := sdklog.NewLoggerProvider(sdklog.WithResource(res),
+		sdklog.WithProcessor(
+			sdklog.NewBatchProcessor(logExporter, sdklog.WithExportBufferSize(10)),
+		),
+	)
+
+	logglobal.SetLoggerProvider(logProvider)
+	shutdownFuncs = append(shutdownFuncs, func(ctx context.Context) error {
+		logProvider.ForceFlush(ctx)
+		return logProvider.Shutdown(ctx)
+	},
+	)
+
 	if err != nil {
 		handleErr(err)
 		return
@@ -166,7 +195,7 @@ func SetupSDK(ctx context.Context, cfg *TracerConfig) (shutdown TpShutdownFunc,
 	return
 }
 
-func newOLTPExporter(ctx context.Context, cfg *TracerConfig) (otelsdktrace.SpanExporter, error) {
+func newOLTPExporter(ctx context.Context, cfg *TracerConfig) (sdktrace.SpanExporter, error) {
 
 	log := logger.Setup()
 
@@ -235,11 +264,11 @@ func newOLTPExporter(ctx context.Context, cfg *TracerConfig) (otelsdktrace.SpanE
 	return exporter, err
 }
 
-func newTraceProvider(traceExporter otelsdktrace.SpanExporter, res *resource.Resource) (*otelsdktrace.TracerProvider, error) {
-	traceProvider := otelsdktrace.NewTracerProvider(
-		otelsdktrace.WithResource(res),
-		otelsdktrace.WithBatcher(traceExporter,
-			otelsdktrace.WithBatchTimeout(time.Second*3),
+func newTraceProvider(traceExporter sdktrace.SpanExporter, res *resource.Resource) (*sdktrace.TracerProvider, error) {
+	traceProvider := sdktrace.NewTracerProvider(
+		sdktrace.WithResource(res),
+		sdktrace.WithBatcher(traceExporter,
+			sdktrace.WithBatchTimeout(time.Second*3),
 		),
 	)
 	return traceProvider, nil