move options to dedicated package

Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>

tracer/context.go

@@ -46,13 +46,3 @@ func NewSpanContext(ctx context.Context, span Span) context.Context {
 	}
 	return context.WithValue(ctx, spanKey{}, span)
 }
-
-// SetOption returns a function to setup a context with given value
-func SetOption(k, v interface{}) Option {
-	return func(o *Options) {
-		if o.Context == nil {
-			o.Context = context.Background()
-		}
-		o.Context = context.WithValue(o.Context, k, v)
-	}
-}

tracer/noop.go

@@ -2,6 +2,8 @@ package tracer
 
 import (
 	"context"
+
+	"go.unistack.org/micro/v4/options"
 )
 
 var _ Tracer = (*noopTracer)(nil)
@@ -10,7 +12,7 @@ type noopTracer struct {
 	opts Options
 }
 
-func (t *noopTracer) Start(ctx context.Context, name string, opts ...SpanOption) (context.Context, Span) {
+func (t *noopTracer) Start(ctx context.Context, name string, opts ...options.Option) (context.Context, Span) {
 	span := &noopSpan{
 		name:   name,
 		ctx:    ctx,
@@ -27,7 +29,7 @@ func (t *noopTracer) Flush(ctx context.Context) error {
 	return nil
 }
 
-func (t *noopTracer) Init(opts ...Option) error {
+func (t *noopTracer) Init(opts ...options.Option) error {
 	for _, o := range opts {
 		o(&t.opts)
 	}
@@ -47,7 +49,7 @@ type noopSpan struct {
 	statusMsg string
 }
 
-func (s *noopSpan) Finish(opts ...SpanOption) {
+func (s *noopSpan) Finish(opts ...options.Option) {
 }
 
 func (s *noopSpan) Context() context.Context {
@@ -58,7 +60,7 @@ func (s *noopSpan) Tracer() Tracer {
 	return s.tracer
 }
 
-func (s *noopSpan) AddEvent(name string, opts ...EventOption) {
+func (s *noopSpan) AddEvent(name string, opts ...options.Option) {
 }
 
 func (s *noopSpan) SetName(name string) {
@@ -87,7 +89,7 @@ func (s *noopSpan) SetStatus(st SpanStatus, msg string) {
 }
 
 // NewTracer returns new memory tracer
-func NewTracer(opts ...Option) Tracer {
+func NewTracer(opts ...options.Option) Tracer {
 	return &noopTracer{
 		opts: NewOptions(opts...),
 	}

tracer/options.go

@@ -2,8 +2,11 @@ package tracer
 
 import (
 	"context"
+	"reflect"
 
 	"go.unistack.org/micro/v4/logger"
+	"go.unistack.org/micro/v4/options"
+	rutil "go.unistack.org/micro/v4/util/reflect"
 )
 
 type SpanStatus int
@@ -87,24 +90,29 @@ type SpanOptions struct {
 	Kind   SpanKind
 }
 
-// SpanOption func signature
-type SpanOption func(o *SpanOptions)
-
 // EventOptions contains event options
 type EventOptions struct{}
 
-// EventOption func signature
-type EventOption func(o *EventOptions)
-
-func WithSpanLabels(labels ...interface{}) SpanOption {
-	return func(o *SpanOptions) {
-		o.Labels = labels
+func WithSpanLabels(ls ...interface{}) options.Option {
+	return func(src interface{}) error {
+		v, err := options.Get(src, ".Labels")
+		if err != nil {
+			return err
+		} else if rutil.IsZero(v) {
+			v = reflect.MakeSlice(reflect.TypeOf(v), 0, len(ls)).Interface()
+		}
+		cv := reflect.ValueOf(v)
+		for _, l := range ls {
+			reflect.Append(cv, reflect.ValueOf(l))
+		}
+		err = options.Set(src, cv, ".Labels")
+		return err
 	}
 }
 
-func WithSpanKind(k SpanKind) SpanOption {
-	return func(o *SpanOptions) {
-		o.Kind = k
+func WithSpanKind(k SpanKind) options.Option {
+	return func(src interface{}) error {
+		return options.Set(src, k, ".Kind")
 	}
 }
 
@@ -118,18 +126,8 @@ type Options struct {
 	Name string
 }
 
-// Option func signature
-type Option func(o *Options)
-
-// Logger sets the logger
-func Logger(l logger.Logger) Option {
-	return func(o *Options) {
-		o.Logger = l
-	}
-}
-
 // NewSpanOptions returns default SpanOptions
-func NewSpanOptions(opts ...SpanOption) SpanOptions {
+func NewSpanOptions(opts ...options.Option) SpanOptions {
 	options := SpanOptions{
 		Kind: SpanKindInternal,
 	}
@@ -140,7 +138,7 @@ func NewSpanOptions(opts ...SpanOption) SpanOptions {
 }
 
 // NewOptions returns default options
-func NewOptions(opts ...Option) Options {
+func NewOptions(opts ...options.Option) Options {
 	options := Options{
 		Logger: logger.DefaultLogger,
 	}
@@ -149,10 +147,3 @@ func NewOptions(opts ...Option) Options {
 	}
 	return options
 }
-
-// Name sets the name
-func Name(n string) Option {
-	return func(o *Options) {
-		o.Name = n
-	}
-}

tracer/tracer.go

@@ -3,6 +3,8 @@ package tracer // import "go.unistack.org/micro/v4/tracer"
 
 import (
 	"context"
+
+	"go.unistack.org/micro/v4/options"
 )
 
 // DefaultTracer is the global default tracer
@@ -13,9 +15,9 @@ type Tracer interface {
 	// Name return tracer name
 	Name() string
 	// Init tracer with options
-	Init(...Option) error
+	Init(...options.Option) error
 	// Start a trace
-	Start(ctx context.Context, name string, opts ...SpanOption) (context.Context, Span)
+	Start(ctx context.Context, name string, opts ...options.Option) (context.Context, Span)
 	// Flush flushes spans
 	Flush(ctx context.Context) error
 }
@@ -24,9 +26,9 @@ type Span interface {
 	// Tracer return underlining tracer
 	Tracer() Tracer
 	// Finish complete and send span
-	Finish(opts ...SpanOption)
+	Finish(opts ...options.Option)
 	// AddEvent add event to span
-	AddEvent(name string, opts ...EventOption)
+	AddEvent(name string, opts ...options.Option)
 	// Context return context with span
 	Context() context.Context
 	// SetName set the span name

tracer/wrapper/wrapper.go

@@ -46,23 +46,6 @@ var (
 		sp.SetLabels(labels...)
 	}
 
-	DefaultClientPublishObserver = func(ctx context.Context, msg client.Message, opts []client.PublishOption, sp tracer.Span, err error) {
-		sp.SetName(fmt.Sprintf("Publish %s", msg.Topic()))
-		var labels []interface{}
-		if md, ok := metadata.FromOutgoingContext(ctx); ok {
-			labels = make([]interface{}, 0, len(md))
-			for k, v := range md {
-				labels = append(labels, k, v)
-			}
-		}
-		if err != nil {
-			labels = append(labels, "error", err.Error())
-			sp.SetStatus(tracer.SpanStatusError, err.Error())
-		}
-		labels = append(labels, "kind", sp.Kind())
-		sp.SetLabels(labels...)
-	}
-
 	DefaultServerHandlerObserver = func(ctx context.Context, req server.Request, rsp interface{}, sp tracer.Span, err error) {
 		sp.SetName(fmt.Sprintf("Handler %s.%s", req.Service(), req.Method()))
 		var labels []interface{}
@@ -80,23 +63,6 @@ var (
 		sp.SetLabels(labels...)
 	}
 
-	DefaultServerSubscriberObserver = func(ctx context.Context, msg server.Message, sp tracer.Span, err error) {
-		sp.SetName(fmt.Sprintf("Subscriber %s", msg.Topic()))
-		var labels []interface{}
-		if md, ok := metadata.FromIncomingContext(ctx); ok {
-			labels = make([]interface{}, 0, len(md))
-			for k, v := range md {
-				labels = append(labels, k, v)
-			}
-		}
-		if err != nil {
-			labels = append(labels, "error", err.Error())
-			sp.SetStatus(tracer.SpanStatusError, err.Error())
-		}
-		labels = append(labels, "kind", sp.Kind())
-		sp.SetLabels(labels...)
-	}
-
 	DefaultClientCallFuncObserver = func(ctx context.Context, addr string, req client.Request, rsp interface{}, opts client.CallOptions, sp tracer.Span, err error) {
 		sp.SetName(fmt.Sprintf("Call %s.%s", req.Service(), req.Method()))
 		var labels []interface{}
@@ -119,19 +85,16 @@ var (
 
 type tWrapper struct {
 	client.Client
-	serverHandler    server.HandlerFunc
-	serverSubscriber server.SubscriberFunc
-	clientCallFunc   client.CallFunc
-	opts             Options
+	serverHandler  server.HandlerFunc
+	clientCallFunc client.CallFunc
+	opts           Options
 }
 
 type (
-	ClientCallObserver       func(context.Context, client.Request, interface{}, []client.CallOption, tracer.Span, error)
-	ClientStreamObserver     func(context.Context, client.Request, []client.CallOption, client.Stream, tracer.Span, error)
-	ClientPublishObserver    func(context.Context, client.Message, []client.PublishOption, tracer.Span, error)
-	ClientCallFuncObserver   func(context.Context, string, client.Request, interface{}, client.CallOptions, tracer.Span, error)
-	ServerHandlerObserver    func(context.Context, server.Request, interface{}, tracer.Span, error)
-	ServerSubscriberObserver func(context.Context, server.Message, tracer.Span, error)
+	ClientCallObserver     func(context.Context, client.Request, interface{}, []client.CallOption, tracer.Span, error)
+	ClientStreamObserver   func(context.Context, client.Request, []client.CallOption, client.Stream, tracer.Span, error)
+	ClientCallFuncObserver func(context.Context, string, client.Request, interface{}, client.CallOptions, tracer.Span, error)
+	ServerHandlerObserver  func(context.Context, server.Request, interface{}, tracer.Span, error)
 )
 
 // Options struct
@@ -142,14 +105,10 @@ type Options struct {
 	ClientCallObservers []ClientCallObserver
 	// ClientStreamObservers funcs
 	ClientStreamObservers []ClientStreamObserver
-	// ClientPublishObservers funcs
-	ClientPublishObservers []ClientPublishObserver
 	// ClientCallFuncObservers funcs
 	ClientCallFuncObservers []ClientCallFuncObserver
 	// ServerHandlerObservers funcs
 	ServerHandlerObservers []ServerHandlerObserver
-	// ServerSubscriberObservers funcs
-	ServerSubscriberObservers []ServerSubscriberObserver
 	// SkipEndpoints
 	SkipEndpoints []string
 }
@@ -160,14 +119,12 @@ type Option func(*Options)
 // NewOptions create Options from Option slice
 func NewOptions(opts ...Option) Options {
 	options := Options{
-		Tracer:                    tracer.DefaultTracer,
-		ClientCallObservers:       []ClientCallObserver{DefaultClientCallObserver},
-		ClientStreamObservers:     []ClientStreamObserver{DefaultClientStreamObserver},
-		ClientPublishObservers:    []ClientPublishObserver{DefaultClientPublishObserver},
-		ClientCallFuncObservers:   []ClientCallFuncObserver{DefaultClientCallFuncObserver},
-		ServerHandlerObservers:    []ServerHandlerObserver{DefaultServerHandlerObserver},
-		ServerSubscriberObservers: []ServerSubscriberObserver{DefaultServerSubscriberObserver},
-		SkipEndpoints:             DefaultSkipEndpoints,
+		Tracer:                  tracer.DefaultTracer,
+		ClientCallObservers:     []ClientCallObserver{DefaultClientCallObserver},
+		ClientStreamObservers:   []ClientStreamObserver{DefaultClientStreamObserver},
+		ClientCallFuncObservers: []ClientCallFuncObserver{DefaultClientCallFuncObserver},
+		ServerHandlerObservers:  []ServerHandlerObserver{DefaultServerHandlerObserver},
+		SkipEndpoints:           DefaultSkipEndpoints,
 	}
 
 	for _, o := range opts {
@@ -205,13 +162,6 @@ func WithClientStreamObservers(ob ...ClientStreamObserver) Option {
 	}
 }
 
-// WithClientPublishObservers funcs
-func WithClientPublishObservers(ob ...ClientPublishObserver) Option {
-	return func(o *Options) {
-		o.ClientPublishObservers = ob
-	}
-}
-
 // WithClientCallFuncObservers funcs
 func WithClientCallFuncObservers(ob ...ClientCallFuncObserver) Option {
 	return func(o *Options) {
@@ -226,13 +176,6 @@ func WithServerHandlerObservers(ob ...ServerHandlerObserver) Option {
 	}
 }
 
-// WithServerSubscriberObservers funcs
-func WithServerSubscriberObservers(ob ...ServerSubscriberObserver) Option {
-	return func(o *Options) {
-		o.ServerSubscriberObservers = ob
-	}
-}
-
 func (ot *tWrapper) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
 	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
 	for _, ep := range ot.opts.SkipEndpoints {
@@ -279,22 +222,6 @@ func (ot *tWrapper) Stream(ctx context.Context, req client.Request, opts ...clie
 	return stream, err
 }
 
-func (ot *tWrapper) Publish(ctx context.Context, msg client.Message, opts ...client.PublishOption) error {
-	sp, ok := tracer.SpanFromContext(ctx)
-	if !ok {
-		ctx, sp = ot.opts.Tracer.Start(ctx, "", tracer.WithSpanKind(tracer.SpanKindProducer))
-	}
-	defer sp.Finish()
-
-	err := ot.Client.Publish(ctx, msg, opts...)
-
-	for _, o := range ot.opts.ClientPublishObservers {
-		o(ctx, msg, opts, sp, err)
-	}
-
-	return err
-}
-
 func (ot *tWrapper) ServerHandler(ctx context.Context, req server.Request, rsp interface{}) error {
 	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Method())
 	for _, ep := range ot.opts.SkipEndpoints {
@@ -318,22 +245,6 @@ func (ot *tWrapper) ServerHandler(ctx context.Context, req server.Request, rsp i
 	return err
 }
 
-func (ot *tWrapper) ServerSubscriber(ctx context.Context, msg server.Message) error {
-	sp, ok := tracer.SpanFromContext(ctx)
-	if !ok {
-		ctx, sp = ot.opts.Tracer.Start(ctx, "", tracer.WithSpanKind(tracer.SpanKindConsumer))
-	}
-	defer sp.Finish()
-
-	err := ot.serverSubscriber(ctx, msg)
-
-	for _, o := range ot.opts.ServerSubscriberObservers {
-		o(ctx, msg, sp, err)
-	}
-
-	return err
-}
-
 // NewClientWrapper accepts an open tracing Trace and returns a Client Wrapper
 func NewClientWrapper(opts ...Option) client.Wrapper {
 	return func(c client.Client) client.Client {
@@ -393,16 +304,3 @@ func NewServerHandlerWrapper(opts ...Option) server.HandlerWrapper {
 		return ot.ServerHandler
 	}
 }
-
-// NewServerSubscriberWrapper accepts an opentracing Tracer and returns a Subscriber Wrapper
-func NewServerSubscriberWrapper(opts ...Option) server.SubscriberWrapper {
-	return func(h server.SubscriberFunc) server.SubscriberFunc {
-		options := NewOptions()
-		for _, o := range opts {
-			o(&options)
-		}
-
-		ot := &tWrapper{opts: options, serverSubscriber: h}
-		return ot.ServerSubscriber
-	}
-}