diff --git a/cmd/revad/runtime/runtime.go b/cmd/revad/runtime/runtime.go index 2ae269195aa..c0ebada1dab 100644 --- a/cmd/revad/runtime/runtime.go +++ b/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 diff --git a/pkg/micro/ocdav/option.go b/pkg/micro/ocdav/option.go index c294239fb92..37e3a6fa76d 100644 --- a/pkg/micro/ocdav/option.go +++ b/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) { diff --git a/pkg/micro/ocdav/service.go b/pkg/micro/ocdav/service.go index 2eeef548f0d..0553772a3ea 100644 --- a/pkg/micro/ocdav/service.go +++ b/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 } diff --git a/pkg/trace/options.go b/pkg/trace/options.go deleted file mode 100644 index fbd8b8237ff..00000000000 --- a/pkg/trace/options.go +++ /dev/null @@ -1,68 +0,0 @@ -package trace - -import "google.golang.org/grpc/credentials" - -// Options for trace -type Options struct { - Enabled bool - Insecure bool - Exporter string - Collector string - Endpoint string - ServiceName string - TransportCredentials credentials.TransportCredentials -} - -// Option for trace -type Option func(o *Options) - -// WithEnabled option -func WithEnabled() Option { - return func(o *Options) { - o.Enabled = true - } -} - -// WithExporter option -// Deprecated: unused -func WithExporter(v string) Option { - return func(o *Options) { - o.Exporter = v - } -} - -// WithInsecure option -func WithInsecure() Option { - return func(o *Options) { - o.Insecure = true - } -} - -// WithCollector option -// Deprecated: unused -func WithCollector(v string) Option { - return func(o *Options) { - o.Collector = v - } -} - -// WithEndpoint option -func WithEndpoint(v string) Option { - return func(o *Options) { - o.Endpoint = v - } -} - -// WithServiceName option -func WithServiceName(v string) Option { - return func(o *Options) { - o.ServiceName = v - } -} - -// WithTransportCredentials option -func WithTransportCredentials(v credentials.TransportCredentials) Option { - return func(o *Options) { - o.TransportCredentials = v - } -} diff --git a/pkg/trace/trace.go b/pkg/trace/trace.go index f4bfcb9d9b8..bd7bdb76d12 100644 --- a/pkg/trace/trace.go +++ b/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,21 +90,6 @@ 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 { @@ -102,42 +97,3 @@ func DefaultProvider() trace.TracerProvider { 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), - ) -}