chore: import upstream snapshot with attribution

wrapper/trace/opentelemetry/README.md

@@ -0,0 +1,14 @@
+# OpenTelemetry wrappers
+
+OpenTelemetry wrappers propagate traces (spans) accross services.
+
+## Usage
+
+```go
+service := micro.NewService(
+    micro.Name("go.micro.srv.greeter"),
+    micro.WrapClient(opentelemetry.NewClientWrapper()),
+    micro.WrapHandler(opentelemetry.NewHandlerWrapper()),
+    micro.WrapSubscriber(opentelemetry.NewSubscriberWrapper()),
+)
+```

wrapper/trace/opentelemetry/opentelemetry.go

@@ -0,0 +1,55 @@
+package opentelemetry
+
+import (
+	"context"
+	"strings"
+
+	"go-micro.dev/v6/metadata"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/baggage"
+	"go.opentelemetry.io/otel/propagation"
+	"go.opentelemetry.io/otel/trace"
+)
+
+const (
+	instrumentationName = "github.com/micro/plugins/v5/wrapper/trace/opentelemetry"
+)
+
+// StartSpanFromContext returns a new span with the given operation name and options. If a span
+// is found in the context, it will be used as the parent of the resulting span.
+func StartSpanFromContext(ctx context.Context, tp trace.TracerProvider, name string, opts ...trace.SpanStartOption) (context.Context, trace.Span) {
+	md, ok := metadata.FromContext(ctx)
+	if !ok {
+		md = make(metadata.Metadata)
+	}
+	propagator, carrier := otel.GetTextMapPropagator(), make(propagation.MapCarrier)
+	for k, v := range md {
+		for _, f := range propagator.Fields() {
+			if strings.EqualFold(k, f) {
+				carrier[f] = v
+			}
+		}
+	}
+	ctx = propagator.Extract(ctx, carrier)
+	spanCtx := trace.SpanContextFromContext(ctx)
+	ctx = baggage.ContextWithBaggage(ctx, baggage.FromContext(ctx))
+
+	var tracer trace.Tracer
+	var span trace.Span
+	if tp != nil {
+		tracer = tp.Tracer(instrumentationName)
+	} else {
+		tracer = otel.Tracer(instrumentationName)
+	}
+	ctx, span = tracer.Start(trace.ContextWithRemoteSpanContext(ctx, spanCtx), name, opts...)
+
+	carrier = make(propagation.MapCarrier)
+	propagator.Inject(ctx, carrier)
+	for k, v := range carrier {
+		//lint:ignore SA1019 no unicode punctution handle needed
+		md.Set(strings.Title(k), v)
+	}
+	ctx = metadata.NewContext(ctx, md)
+
+	return ctx, span
+}

wrapper/trace/opentelemetry/options.go

@@ -0,0 +1,72 @@
+package opentelemetry
+
+import (
+	"context"
+
+	"go-micro.dev/v6/client"
+	"go-micro.dev/v6/server"
+	"go.opentelemetry.io/otel/trace"
+)
+
+type Options struct {
+	TraceProvider trace.TracerProvider
+
+	CallFilter       CallFilter
+	StreamFilter     StreamFilter
+	PublishFilter    PublishFilter
+	SubscriberFilter SubscriberFilter
+	HandlerFilter    HandlerFilter
+}
+
+// CallFilter used to filter client.Call, return true to skip call trace.
+type CallFilter func(context.Context, client.Request) bool
+
+// StreamFilter used to filter client.Stream, return true to skip stream trace.
+type StreamFilter func(context.Context, client.Request) bool
+
+// PublishFilter used to filter client.Publish, return true to skip publish trace.
+type PublishFilter func(context.Context, client.Message) bool
+
+// SubscriberFilter used to filter server.Subscribe, return true to skip subcribe trace.
+type SubscriberFilter func(context.Context, server.Message) bool
+
+// HandlerFilter used to filter server.Handle, return true to skip handle trace.
+type HandlerFilter func(context.Context, server.Request) bool
+
+type Option func(*Options)
+
+func WithTraceProvider(tp trace.TracerProvider) Option {
+	return func(o *Options) {
+		o.TraceProvider = tp
+	}
+}
+
+func WithCallFilter(filter CallFilter) Option {
+	return func(o *Options) {
+		o.CallFilter = filter
+	}
+}
+
+func WithStreamFilter(filter StreamFilter) Option {
+	return func(o *Options) {
+		o.StreamFilter = filter
+	}
+}
+
+func WithPublishFilter(filter PublishFilter) Option {
+	return func(o *Options) {
+		o.PublishFilter = filter
+	}
+}
+
+func WithSubscribeFilter(filter SubscriberFilter) Option {
+	return func(o *Options) {
+		o.SubscriberFilter = filter
+	}
+}
+
+func WithHandleFilter(filter HandlerFilter) Option {
+	return func(o *Options) {
+		o.HandlerFilter = filter
+	}
+}

wrapper/trace/opentelemetry/wrapper.go

@@ -0,0 +1,175 @@
+package opentelemetry
+
+import (
+	"context"
+	"fmt"
+
+	"go-micro.dev/v6/client"
+	"go-micro.dev/v6/registry"
+	"go-micro.dev/v6/server"
+	"go.opentelemetry.io/otel/codes"
+	"go.opentelemetry.io/otel/trace"
+)
+
+// NewCallWrapper accepts an opentracing Tracer and returns a Call Wrapper.
+func NewCallWrapper(opts ...Option) client.CallWrapper {
+	options := Options{}
+	for _, o := range opts {
+		o(&options)
+	}
+	return func(cf client.CallFunc) client.CallFunc {
+		return func(ctx context.Context, node *registry.Node, req client.Request, rsp interface{}, opts client.CallOptions) error {
+			if options.CallFilter != nil && options.CallFilter(ctx, req) {
+				return cf(ctx, node, req, rsp, opts)
+			}
+			name := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+			spanOpts := []trace.SpanStartOption{
+				trace.WithSpanKind(trace.SpanKindClient),
+			}
+			ctx, span := StartSpanFromContext(ctx, options.TraceProvider, name, spanOpts...)
+			defer span.End()
+			if err := cf(ctx, node, req, rsp, opts); err != nil {
+				span.SetStatus(codes.Error, err.Error())
+				span.RecordError(err)
+				return err
+			}
+			return nil
+		}
+	}
+}
+
+// NewHandlerWrapper accepts an opentracing Tracer and returns a Handler Wrapper.
+func NewHandlerWrapper(opts ...Option) server.HandlerWrapper {
+	options := Options{}
+	for _, o := range opts {
+		o(&options)
+	}
+	return func(h server.HandlerFunc) server.HandlerFunc {
+		return func(ctx context.Context, req server.Request, rsp interface{}) error {
+			if options.HandlerFilter != nil && options.HandlerFilter(ctx, req) {
+				return h(ctx, req, rsp)
+			}
+			name := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+			spanOpts := []trace.SpanStartOption{
+				trace.WithSpanKind(trace.SpanKindServer),
+			}
+			ctx, span := StartSpanFromContext(ctx, options.TraceProvider, name, spanOpts...)
+			defer span.End()
+			if err := h(ctx, req, rsp); err != nil {
+				span.SetStatus(codes.Error, err.Error())
+				span.RecordError(err)
+				return err
+			}
+			return nil
+		}
+	}
+}
+
+// NewSubscriberWrapper accepts an opentracing Tracer and returns a Subscriber Wrapper.
+func NewSubscriberWrapper(opts ...Option) server.SubscriberWrapper {
+	options := Options{}
+	for _, o := range opts {
+		o(&options)
+	}
+	return func(next server.SubscriberFunc) server.SubscriberFunc {
+		return func(ctx context.Context, msg server.Message) error {
+			if options.SubscriberFilter != nil && options.SubscriberFilter(ctx, msg) {
+				return next(ctx, msg)
+			}
+			name := "Sub from " + msg.Topic()
+			spanOpts := []trace.SpanStartOption{
+				trace.WithSpanKind(trace.SpanKindServer),
+			}
+			ctx, span := StartSpanFromContext(ctx, options.TraceProvider, name, spanOpts...)
+			defer span.End()
+			if err := next(ctx, msg); err != nil {
+				span.SetStatus(codes.Error, err.Error())
+				span.RecordError(err)
+				return err
+			}
+			return nil
+		}
+	}
+}
+
+// NewClientWrapper returns a client.Wrapper
+// that adds monitoring to outgoing requests.
+func NewClientWrapper(opts ...Option) client.Wrapper {
+	options := Options{}
+	for _, o := range opts {
+		o(&options)
+	}
+	return func(c client.Client) client.Client {
+		w := &clientWrapper{
+			Client:        c,
+			tp:            options.TraceProvider,
+			callFilter:    options.CallFilter,
+			streamFilter:  options.StreamFilter,
+			publishFilter: options.PublishFilter,
+		}
+		return w
+	}
+}
+
+type clientWrapper struct {
+	client.Client
+
+	tp            trace.TracerProvider
+	callFilter    CallFilter
+	streamFilter  StreamFilter
+	publishFilter PublishFilter
+}
+
+func (w *clientWrapper) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
+	if w.callFilter != nil && w.callFilter(ctx, req) {
+		return w.Client.Call(ctx, req, rsp, opts...)
+	}
+	name := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+	spanOpts := []trace.SpanStartOption{
+		trace.WithSpanKind(trace.SpanKindClient),
+	}
+	ctx, span := StartSpanFromContext(ctx, w.tp, name, spanOpts...)
+	defer span.End()
+	if err := w.Client.Call(ctx, req, rsp, opts...); err != nil {
+		span.SetStatus(codes.Error, err.Error())
+		span.RecordError(err)
+		return err
+	}
+	return nil
+}
+
+func (w *clientWrapper) Stream(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
+	if w.streamFilter != nil && w.streamFilter(ctx, req) {
+		return w.Client.Stream(ctx, req, opts...)
+	}
+	name := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+	spanOpts := []trace.SpanStartOption{
+		trace.WithSpanKind(trace.SpanKindClient),
+	}
+	ctx, span := StartSpanFromContext(ctx, w.tp, name, spanOpts...)
+	defer span.End()
+	stream, err := w.Client.Stream(ctx, req, opts...)
+	if err != nil {
+		span.SetStatus(codes.Error, err.Error())
+		span.RecordError(err)
+	}
+	return stream, err
+}
+
+func (w *clientWrapper) Publish(ctx context.Context, p client.Message, opts ...client.PublishOption) error {
+	if w.publishFilter != nil && w.publishFilter(ctx, p) {
+		return w.Client.Publish(ctx, p, opts...)
+	}
+	name := fmt.Sprintf("Pub to %s", p.Topic())
+	spanOpts := []trace.SpanStartOption{
+		trace.WithSpanKind(trace.SpanKindClient),
+	}
+	ctx, span := StartSpanFromContext(ctx, w.tp, name, spanOpts...)
+	defer span.End()
+	if err := w.Client.Publish(ctx, p, opts...); err != nil {
+		span.SetStatus(codes.Error, err.Error())
+		span.RecordError(err)
+		return err
+	}
+	return nil
+}