update otlp tracing

cmd/revad/runtime/runtime.go

@@ -62,16 +62,9 @@ func RunWithOptions(mainConf map[string]interface{}, pidFile string, opts ...Opt
 
 type coreConf struct {
 	MaxCPUs            string `mapstructure:"max_cpus"`
-	TracingEnabled     bool   `mapstructure:"tracing_enabled"`
-	TracingInsecure    bool   `mapstructure:"tracing_insecure"`
-	TracingExporter    string `mapstructure:"tracing_exporter"`
-	TracingEndpoint    string `mapstructure:"tracing_endpoint"`
-	TracingCollector   string `mapstructure:"tracing_collector"`
+	TracesExporter     string `mapstructure:"traces_exporter"`
 	TracingServiceName string `mapstructure:"tracing_service_name"`
 
-	// TracingService specifies the service. i.e OpenCensus, OpenTelemetry, OpenTracing...
-	TracingService string `mapstructure:"tracing_service"`
-
 	GracefulShutdownTimeout int `mapstructure:"graceful_shutdown_timeout"`
 }
 
@@ -149,20 +142,8 @@ func initServers(mainConf map[string]interface{}, log *zerolog.Logger, tp trace.
 }
 
 func initTracing(conf *coreConf) trace.TracerProvider {
-	if conf.TracingEnabled {
-		opts := []rtrace.Option{
-			rtrace.WithExporter(conf.TracingExporter),
-			rtrace.WithEndpoint(conf.TracingEndpoint),
-			rtrace.WithCollector(conf.TracingCollector),
-			rtrace.WithServiceName(conf.TracingServiceName),
-		}
-		if conf.TracingEnabled {
-			opts = append(opts, rtrace.WithEnabled())
-		}
-		if conf.TracingInsecure {
-			opts = append(opts, rtrace.WithInsecure())
-		}
-		tp := rtrace.NewTracerProvider(opts...)
+	if conf.TracesExporter != "none" && conf.TracesExporter != "" {
+		tp := rtrace.NewTracerProvider(conf.TracingServiceName, conf.TracesExporter)
 		rtrace.SetDefaultTracerProvider(tp)
 		return tp
 	}
@@ -281,11 +262,9 @@ func parseCoreConfOrDie(v interface{}) *coreConf {
 
 	// tracing defaults to enabled if not explicitly configured
 	if v == nil {
-		c.TracingEnabled = true
-		c.TracingEndpoint = "localhost:6831"
-	} else if _, ok := v.(map[string]interface{})["tracing_enabled"]; !ok {
-		c.TracingEnabled = true
-		c.TracingEndpoint = "localhost:6831"
+		c.TracesExporter = "console"
+	} else if _, ok := v.(map[string]interface{})["traces_exporter"]; !ok {
+		c.TracesExporter = "console"
 	}
 
 	return c

pkg/micro/ocdav/option.go

@@ -31,7 +31,6 @@ import (
 	"github.com/rs/zerolog"
 	"go-micro.dev/v4/broker"
 	"go.opentelemetry.io/otel/trace"
-	"google.golang.org/grpc/credentials"
 )
 
 // Option defines a single option function.
@@ -52,10 +51,7 @@ type Options struct {
 	FavoriteManager favorite.Manager
 	GatewaySelector pool.Selectable[gateway.GatewayAPIClient]
 
-	TracingEnabled              bool
-	TracingInsecure             bool
-	TracingEndpoint             string
-	TracingTransportCredentials credentials.TransportCredentials
+	TracesExporter string
 
 	TraceProvider trace.TracerProvider
 
@@ -233,33 +229,10 @@ func LockSystem(val ocdav.LockSystem) Option {
 	}
 }
 
-// Tracing enables tracing
-// Deprecated: use WithTracingEndpoint and WithTracingEnabled, Collector is unused
-func Tracing(endpoint, collector string) Option {
+// WithTracesExporter option
+func WithTracesExporter(exporter string) Option {
 	return func(o *Options) {
-		o.TracingEnabled = true
-		o.TracingEndpoint = endpoint
-	}
-}
-
-// WithTracingEnabled option
-func WithTracingEnabled(enabled bool) Option {
-	return func(o *Options) {
-		o.TracingEnabled = enabled
-	}
-}
-
-// WithTracingEndpoint option
-func WithTracingEndpoint(endpoint string) Option {
-	return func(o *Options) {
-		o.TracingEndpoint = endpoint
-	}
-}
-
-// WithTracingInsecure option
-func WithTracingInsecure() Option {
-	return func(o *Options) {
-		o.TracingInsecure = true
+		o.TracesExporter = exporter
 	}
 }
 
@@ -269,13 +242,6 @@ func WithTracingExporter(exporter string) Option {
 	return func(o *Options) {}
 }
 
-// WithTracingTransportCredentials option
-func WithTracingTransportCredentials(v credentials.TransportCredentials) Option {
-	return func(o *Options) {
-		o.TracingTransportCredentials = v
-	}
-}
-
 // WithTraceProvider option
 func WithTraceProvider(provider trace.TracerProvider) Option {
 	return func(o *Options) {

pkg/micro/ocdav/service.go

@@ -91,20 +91,7 @@ func Service(opts ...Option) (micro.Service, error) {
 	tp := sopts.TraceProvider
 
 	if tp == nil {
-		topts := []rtrace.Option{
-			rtrace.WithEndpoint(sopts.TracingEndpoint),
-			rtrace.WithServiceName(sopts.Name),
-		}
-		if sopts.TracingEnabled {
-			topts = append(topts, rtrace.WithEnabled())
-		}
-		if sopts.TracingInsecure {
-			topts = append(topts, rtrace.WithInsecure())
-		}
-		if sopts.TracingTransportCredentials != nil {
-			topts = append(topts, rtrace.WithTransportCredentials(sopts.TracingTransportCredentials))
-		}
-		tp = rtrace.NewTracerProvider(topts...)
+		tp = rtrace.NewTracerProvider(sopts.Name, sopts.TracesExporter)
 	}
 	if err := useMiddlewares(r, &sopts, revaService, tp); err != nil {
 		return nil, err
@@ -189,10 +176,7 @@ func useMiddlewares(r *chi.Mux, sopts *Options, svc global.Service, tp trace.Tra
 	}
 
 	// tracing
-	tm := func(h http.Handler) http.Handler { return h }
-	if sopts.TracingEnabled {
-		tm = traceHandler(tp, "ocdav")
-	}
+	tm := traceHandler(tp, "ocdav")
 
 	// metrics
 	pm := func(h http.Handler) http.Handler { return h }

pkg/trace/trace.go

@@ -20,21 +20,17 @@ package trace
 
 import (
 	"context"
-	"fmt"
 	"sync"
+	"time"
 
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
 	"go.opentelemetry.io/otel/propagation"
 	"go.opentelemetry.io/otel/sdk/resource"
 	sdktrace "go.opentelemetry.io/otel/sdk/trace"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials"
-	"google.golang.org/grpc/credentials/insecure"
 
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/trace"
-	"go.opentelemetry.io/otel/trace/noop"
 )
 
 var (
@@ -48,28 +44,42 @@ type revaDefaultTracerProvider struct {
 	initialized bool
 }
 
-// NewTracerProvider returns a new TracerProvider, configure for the specified service
-func NewTracerProvider(opts ...Option) trace.TracerProvider {
-	options := Options{}
-
-	for _, o := range opts {
-		o(&options)
-	}
-
-	if options.TransportCredentials == nil {
-		options.TransportCredentials = credentials.NewClientTLSFromCert(nil, "")
+// NewTracerProvider returns a new TracerProvider, configured for the specified service
+func NewTracerProvider(serviceName, exporter string) trace.TracerProvider {
+	var tp *sdktrace.TracerProvider
+	if exporter == "otlp" {
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+		defer cancel()
+
+		exporter, err := otlptracegrpc.New(ctx)
+		if err != nil {
+			return nil
+		}
+		resources, err := resource.New(
+			context.Background(),
+			resource.WithFromEnv(), // Reads OTEL_RESOURCE_ATTRIBUTES and OTEL_SERVICE_NAME
+			resource.WithAttributes(
+				attribute.String("service.name", serviceName),
+				attribute.String("library.language", "go"),
+			),
+		)
+		if err != nil {
+			return nil
+		}
+
+		tp = sdktrace.NewTracerProvider(
+			sdktrace.WithSampler(sdktrace.AlwaysSample()),
+			sdktrace.WithBatcher(exporter),
+			sdktrace.WithResource(resources),
+		)
+	} else {
+		tp = sdktrace.NewTracerProvider(
+			sdktrace.WithSampler(sdktrace.NeverSample()),
+		)
 	}
 
-	if !options.Enabled {
-		return noop.NewTracerProvider()
-	}
-
-	// default to 'reva' as service name if not set
-	if options.ServiceName == "" {
-		options.ServiceName = "reva"
-	}
-
-	return getOtlpTracerProvider(options)
+	SetDefaultTracerProvider(tp)
+	return tp
 }
 
 // SetDefaultTracerProvider sets the default trace provider
@@ -80,64 +90,10 @@ func SetDefaultTracerProvider(tp trace.TracerProvider) {
 	defaultProvider.initialized = true
 }
 
-// InitDefaultTracerProvider initializes a global default jaeger TracerProvider at a package level.
-//
-// Deprecated: Use NewTracerProvider and SetDefaultTracerProvider to properly initialize a tracer provider with options
-func InitDefaultTracerProvider(collector, endpoint string) {
-	defaultProvider.mutex.Lock()
-	defer defaultProvider.mutex.Unlock()
-	if !defaultProvider.initialized {
-		SetDefaultTracerProvider(getOtlpTracerProvider(Options{
-			Endpoint:    endpoint,
-			ServiceName: "reva default otlp provider",
-			Insecure:    true,
-		}))
-	}
-}
-
 // DefaultProvider returns the "global" default TracerProvider
 // Currently used by the pool to get the global tracer
 func DefaultProvider() trace.TracerProvider {
 	defaultProvider.mutex.RLock()
 	defer defaultProvider.mutex.RUnlock()
 	return otel.GetTracerProvider()
 }
-
-// getOtelTracerProvider returns a new TracerProvider, configure for the specified service
-func getOtlpTracerProvider(options Options) trace.TracerProvider {
-	transportCredentials := options.TransportCredentials
-	if options.Insecure {
-		transportCredentials = insecure.NewCredentials()
-	}
-	conn, err := grpc.NewClient(options.Endpoint,
-		grpc.WithTransportCredentials(transportCredentials),
-	)
-	if err != nil {
-		panic(fmt.Errorf("failed to create gRPC connection to endpoint: %w", err))
-	}
-	exporter, err := otlptracegrpc.New(
-		context.Background(),
-		otlptracegrpc.WithGRPCConn(conn),
-	)
-
-	if err != nil {
-		panic(err)
-	}
-
-	resources, err := resource.New(
-		context.Background(),
-		resource.WithAttributes(
-			attribute.String("service.name", options.ServiceName),
-			attribute.String("library.language", "go"),
-		),
-	)
-	if err != nil {
-		panic(err)
-	}
-
-	return sdktrace.NewTracerProvider(
-		sdktrace.WithSampler(sdktrace.AlwaysSample()),
-		sdktrace.WithBatcher(exporter),
-		sdktrace.WithResource(resources),
-	)
-}