Merge pull request #778 from Alvise88/move-to-opentelemetry

Move to OpenTelemetry (#735)

cmd/dagger/cmd/root.go

@@ -5,14 +5,16 @@ import (
 	"strings"
 
 	"github.com/moby/buildkit/util/appcontext"
-	"github.com/opentracing/opentracing-go"
-	otlog "github.com/opentracing/opentracing-go/log"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"go.dagger.io/dagger/cmd/dagger/cmd/input"
 	"go.dagger.io/dagger/cmd/dagger/cmd/output"
 	"go.dagger.io/dagger/cmd/dagger/logger"
 	"go.dagger.io/dagger/keychain"
+
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/trace"
 )
 
 var rootCmd = &cobra.Command{
@@ -74,17 +76,21 @@ func Execute() {
 		// default logger. Therefore, we can't store the logger into the context.
 		lg     = logger.New()
 		closer = logger.InitTracing()
-		span   opentracing.Span
+		span   trace.Span
 	)
 
 	if len(os.Args) > 1 {
-		span, ctx = opentracing.StartSpanFromContext(ctx, os.Args[1])
-		span.LogFields(otlog.String("command", strings.Join(os.Args, " ")))
+		tr := otel.Tracer("cmd")
+		ctx, span = tr.Start(ctx, os.Args[1])
+		// Record the action
+		span.AddEvent("command", trace.WithAttributes(
+			attribute.String("args", strings.Join(os.Args, " ")),
+		))
 	}
 
 	defer func() {
 		if span != nil {
-			span.Finish()
+			span.End()
 		}
 		closer.Close()
 	}()

cmd/dagger/logger/tracer.go

@@ -1,31 +1,70 @@
 package logger
 
 import (
+	"context"
 	"io"
 	"os"
+	"time"
 
-	opentracing "github.com/opentracing/opentracing-go"
-	jaeger "github.com/uber/jaeger-client-go"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/exporters/jaeger"
+	"go.opentelemetry.io/otel/sdk/resource"
+	tracesdk "go.opentelemetry.io/otel/sdk/trace"
+	semconv "go.opentelemetry.io/otel/semconv/v1.4.0"
 )
 
+type tracer struct {
+	provider *tracesdk.TracerProvider
+}
+
 func InitTracing() io.Closer {
-	traceAddr := os.Getenv("JAEGER_TRACE")
-	if traceAddr == "" {
+	traceEndpoint := os.Getenv("OTEL_EXPORTER_JAEGER_ENDPOINT")
+	if traceEndpoint == "" {
 		return &nopCloser{}
 	}
 
-	tr, err := jaeger.NewUDPTransport(traceAddr, 0)
+	tp, err := tracerProvider(traceEndpoint)
 	if err != nil {
 		panic(err)
 	}
 
-	tracer, closer := jaeger.NewTracer(
-		"dagger",
-		jaeger.NewConstSampler(true),
-		jaeger.NewRemoteReporter(tr),
+	// Register our TracerProvider as the global so any imported
+	// instrumentation in the future will default to using it.
+	otel.SetTracerProvider(tp)
+
+	tracer := tracer{
+		provider: tp,
+	}
+
+	return tracer
+}
+
+// tracerProvider returns an OpenTelemetry TracerProvider configured to use
+// the Jaeger exporter that will send spans to the provided url. The returned
+// TracerProvider will also use a Resource configured with all the information
+// about the application.
+func tracerProvider(url string) (*tracesdk.TracerProvider, error) {
+	// Create the Jaeger exporter
+	exp, err := jaeger.New(jaeger.WithCollectorEndpoint(jaeger.WithEndpoint(url)))
+	if err != nil {
+		return nil, err
+	}
+	tp := tracesdk.NewTracerProvider(
+		// Always be sure to batch in production.
+		tracesdk.WithBatcher(exp, tracesdk.WithMaxExportBatchSize(1)),
+		// Record information about this application in an Resource.
+		tracesdk.WithResource(resource.NewWithAttributes(
+			semconv.SchemaURL,
+			semconv.ServiceNameKey.String("dagger"),
+		)),
 	)
-	opentracing.SetGlobalTracer(tracer)
-	return closer
+	return tp, nil
+}
+
+func (t tracer) Close() error {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+	defer cancel()
+	return t.provider.Shutdown(ctx)
 }
 
 type nopCloser struct {