util/reflect: add ability to merge maps

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

broker/broker.go

@@ -1,5 +1,5 @@
 // Package broker is an interface used for asynchronous messaging
-package broker // import "go.unistack.org/micro/v3/broker"
+package broker
 
 import (
 	"context"

broker/memory/memory.go

@@ -373,6 +373,10 @@ func (m *memoryEvent) SetError(err error) {
 	m.err = err
 }
 
+func (m *memoryEvent) Context() context.Context {
+	return m.opts.Context
+}
+
 func (m *memorySubscriber) Options() broker.SubscribeOptions {
 	return m.opts
 }

client/client.go

@@ -1,5 +1,5 @@
 // Package client is an interface for an RPC client
-package client // import "go.unistack.org/micro/v3/client"
+package client
 
 import (
 	"context"

codec/codec.go

@@ -1,19 +1,8 @@
 // Package codec is an interface for encoding messages
-package codec // import "go.unistack.org/micro/v3/codec"
+package codec
 
 import (
 	"errors"
-	"io"
-
-	"go.unistack.org/micro/v3/metadata"
-)
-
-// Message types
-const (
-	Error MessageType = iota
-	Request
-	Response
-	Event
 )
 
 var (
@@ -24,65 +13,23 @@ var (
 )
 
 var (
-	// DefaultMaxMsgSize specifies how much data codec can handle
-	DefaultMaxMsgSize = 1024 * 1024 * 4 // 4Mb
 	// DefaultCodec is the global default codec
 	DefaultCodec = NewCodec()
 	// DefaultTagName specifies struct tag name to control codec Marshal/Unmarshal
 	DefaultTagName = "codec"
 )
 
-// MessageType specifies message type for codec
+// Codec encodes/decodes various types of messages.
-type MessageType int
-
-// Codec encodes/decodes various types of messages used within micro.
-// ReadHeader and ReadBody are called in pairs to read requests/responses
-// from the connection. Close is called when finished with the
-// connection. ReadBody may be called with a nil argument to force the
-// body to be read and discarded.
 type Codec interface {
-	ReadHeader(r io.Reader, m *Message, mt MessageType) error
-	ReadBody(r io.Reader, v interface{}) error
-	Write(w io.Writer, m *Message, v interface{}) error
 	Marshal(v interface{}, opts ...Option) ([]byte, error)
 	Unmarshal(b []byte, v interface{}, opts ...Option) error
 	String() string
 }
 
-// Message represents detailed information about
+type CodecV2 interface {
-// the communication, likely followed by the body.
+	Marshal(buf []byte, v interface{}, opts ...Option) ([]byte, error)
-// In the case of an error, body may be nil.
+	Unmarshal(buf []byte, v interface{}, opts ...Option) error
-type Message struct {
+	String() string
-	Header   metadata.Metadata
-	Target   string
-	Method   string
-	Endpoint string
-	Error    string
-	ID       string
-	Body     []byte
-	Type     MessageType
-}
-
-// NewMessage creates new codec message
-func NewMessage(t MessageType) *Message {
-	return &Message{Type: t, Header: metadata.New(0)}
-}
-
-// MarshalAppend calls codec.Marshal(v) and returns the data appended to buf.
-// If codec implements MarshalAppend, that is called instead.
-func MarshalAppend(buf []byte, c Codec, v interface{}, opts ...Option) ([]byte, error) {
-	if nc, ok := c.(interface {
-		MarshalAppend([]byte, interface{}, ...Option) ([]byte, error)
-	}); ok {
-		return nc.MarshalAppend(buf, v, opts...)
-	}
-
-	mbuf, err := c.Marshal(v, opts...)
-	if err != nil {
-		return nil, err
-	}
-
-	return append(buf, mbuf...), nil
 }
 
 // RawMessage is a raw encoded JSON value.
@@ -93,6 +40,8 @@ type RawMessage []byte
 func (m *RawMessage) MarshalJSON() ([]byte, error) {
 	if m == nil {
 		return []byte("null"), nil
+	} else if len(*m) == 0 {
+		return []byte("null"), nil
 	}
 	return *m, nil
 }

codec/noop.go

@@ -2,70 +2,14 @@ package codec
 
 import (
 	"encoding/json"
-	"io"
+
+	codecpb "go.unistack.org/micro-proto/v3/codec"
 )
 
 type noopCodec struct {
 	opts Options
 }
 
-func (c *noopCodec) ReadHeader(conn io.Reader, m *Message, t MessageType) error {
-	return nil
-}
-
-func (c *noopCodec) ReadBody(conn io.Reader, b interface{}) error {
-	// read bytes
-	buf, err := io.ReadAll(conn)
-	if err != nil {
-		return err
-	}
-
-	if b == nil {
-		return nil
-	}
-
-	switch v := b.(type) {
-	case *string:
-		*v = string(buf)
-	case *[]byte:
-		*v = buf
-	case *Frame:
-		v.Data = buf
-	default:
-		return json.Unmarshal(buf, v)
-	}
-
-	return nil
-}
-
-func (c *noopCodec) Write(conn io.Writer, m *Message, b interface{}) error {
-	if b == nil {
-		return nil
-	}
-
-	var v []byte
-	switch vb := b.(type) {
-	case *Frame:
-		v = vb.Data
-	case string:
-		v = []byte(vb)
-	case *string:
-		v = []byte(*vb)
-	case *[]byte:
-		v = *vb
-	case []byte:
-		v = vb
-	default:
-		var err error
-		v, err = json.Marshal(vb)
-		if err != nil {
-			return err
-		}
-	}
-	_, err := conn.Write(v)
-	return err
-}
-
 func (c *noopCodec) String() string {
 	return "noop"
 }
@@ -91,8 +35,8 @@ func (c *noopCodec) Marshal(v interface{}, opts ...Option) ([]byte, error) {
 		return ve, nil
 	case *Frame:
 		return ve.Data, nil
-	case *Message:
+	case *codecpb.Frame:
-		return ve.Body, nil
+		return ve.Data, nil
 	}
 
 	return json.Marshal(v)
@@ -115,8 +59,8 @@ func (c *noopCodec) Unmarshal(d []byte, v interface{}, opts ...Option) error {
 	case *Frame:
 		ve.Data = d
 		return nil
-	case *Message:
+	case *codecpb.Frame:
-		ve.Body = d
+		ve.Data = d
 		return nil
 	}
 

codec/options.go

@@ -23,15 +23,8 @@ type Options struct {
 	Context context.Context
 	// TagName specifies tag name in struct to control codec
 	TagName string
-	// MaxMsgSize specifies max messages size that reads by codec
+	// Flatten specifies that struct must be analyzed for flatten tag
-	MaxMsgSize int
+	Flatten bool
-}
-
-// MaxMsgSize sets the max message size
-func MaxMsgSize(n int) Option {
-	return func(o *Options) {
-		o.MaxMsgSize = n
-	}
 }
 
 // TagName sets the codec tag name in struct
@@ -41,6 +34,13 @@ func TagName(n string) Option {
 	}
 }
 
+// Flatten enables checking for flatten tag name
+func Flatten(b bool) Option {
+	return func(o *Options) {
+		o.Flatten = b
+	}
+}
+
 // Logger sets the logger
 func Logger(l logger.Logger) Option {
 	return func(o *Options) {
@@ -65,12 +65,12 @@ func Meter(m meter.Meter) Option {
 // NewOptions returns new options
 func NewOptions(opts ...Option) Options {
 	options := Options{
-		Context:    context.Background(),
+		Context: context.Background(),
-		Logger:     logger.DefaultLogger,
+		Logger:  logger.DefaultLogger,
-		Meter:      meter.DefaultMeter,
+		Meter:   meter.DefaultMeter,
-		Tracer:     tracer.DefaultTracer,
+		Tracer:  tracer.DefaultTracer,
-		MaxMsgSize: DefaultMaxMsgSize,
+		TagName: DefaultTagName,
-		TagName:    DefaultTagName,
+		Flatten: false,
 	}
 
 	for _, o := range opts {

config/config.go

@@ -1,5 +1,5 @@
 // Package config is an interface for dynamic configuration.
-package config // import "go.unistack.org/micro/v3/config"
+package config
 
 import (
 	"context"

errors/errors.go

@@ -1,6 +1,6 @@
 // Package errors provides a way to return detailed information
 // for an RPC request error. The error is normally JSON encoded.
-package errors // import "go.unistack.org/micro/v3/errors"
+package errors
 
 import (
 	"bytes"
@@ -44,6 +44,20 @@ var (
 	ErrGatewayTimeout = &Error{Code: 504}
 )
 
+const ProblemContentType = "application/problem+json"
+
+type Problem struct {
+	Type     string `json:"type,omitempty"`
+	Title    string `json:"title,omitempty"`
+	Detail   string `json:"detail,omitempty"`
+	Instance string `json:"instance,omitempty"`
+	Errors   []struct {
+		Title  string `json:"title,omitempty"`
+		Detail string `json:"detail,omitempty"`
+	} `json:"errors,omitempty"`
+	Status int `json:"status,omitempty"`
+}
+
 // Error type
 type Error struct {
 	// ID holds error id or service, usually someting like my_service or id

flow/flow.go

@@ -1,5 +1,5 @@
 // Package flow is an interface used for saga pattern microservice workflow
-package flow // import "go.unistack.org/micro/v3/flow"
+package flow
 
 import (
 	"context"

fsm/fsm.go

@@ -1,4 +1,4 @@
-package fsm // import "go.unistack.org/micro/v3/fsm"
+package fsm
 
 import (
 	"context"

logger/logger.go

@@ -1,5 +1,5 @@
 // Package logger provides a log interface
-package logger // import "go.unistack.org/micro/v3/logger"
+package logger
 
 import (
 	"context"

logger/options.go

@@ -74,7 +74,7 @@ func NewOptions(opts ...Option) Options {
 	return options
 }
 
-// WithContextAttrFuncs appends default funcs for the context arrts filler
+// WithContextAttrFuncs appends default funcs for the context attrs filler
 func WithContextAttrFuncs(fncs ...ContextAttrFunc) Option {
 	return func(o *Options) {
 		o.ContextAttrFuncs = append(o.ContextAttrFuncs, fncs...)
@@ -137,6 +137,13 @@ func WithName(n string) Option {
 	}
 }
 
+// WithMeter sets the meter
+func WithMeter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
 // WithTimeFunc sets the func to obtain current time
 func WithTimeFunc(fn func() time.Time) Option {
 	return func(o *Options) {

metadata/metadata.go

@@ -1,5 +1,5 @@
 // Package metadata is a way of defining message headers
-package metadata // import "go.unistack.org/micro/v3/metadata"
+package metadata
 
 import (
 	"net/textproto"

meter/meter.go

@@ -16,10 +16,6 @@ var (
 	DefaultAddress = ":9090"
 	// DefaultPath the meter endpoint where the Meter data will be made available
 	DefaultPath = "/metrics"
-	// DefaultMetricPrefix holds the string that prepends to all metrics
-	DefaultMetricPrefix = "micro_"
-	// DefaultLabelPrefix holds the string that prepends to all labels
-	DefaultLabelPrefix = "micro_"
 	// DefaultSummaryQuantiles is the default spread of stats for summary
 	DefaultSummaryQuantiles = []float64{0.5, 0.9, 0.97, 0.99, 1}
 	// DefaultSummaryWindow is the default window for summary

meter/options.go

@@ -17,10 +17,6 @@ type Options struct {
 	Address string
 	// Path holds the path for metrics
 	Path string
-	// MetricPrefix holds the prefix for all metrics
-	MetricPrefix string
-	// LabelPrefix holds the prefix for all labels
-	LabelPrefix string
 	// Labels holds the default labels
 	Labels []string
 	// WriteProcessMetrics flag to write process metrics
@@ -32,11 +28,9 @@ type Options struct {
 // NewOptions prepares a set of options:
 func NewOptions(opt ...Option) Options {
 	opts := Options{
-		Address:      DefaultAddress,
+		Address: DefaultAddress,
-		Path:         DefaultPath,
+		Path:    DefaultPath,
-		Context:      context.Background(),
+		Context: context.Background(),
-		MetricPrefix: DefaultMetricPrefix,
-		LabelPrefix:  DefaultLabelPrefix,
 	}
 
 	for _, o := range opt {
@@ -46,20 +40,6 @@ func NewOptions(opt ...Option) Options {
 	return opts
 }
 
-// LabelPrefix sets the labels prefix
-func LabelPrefix(pref string) Option {
-	return func(o *Options) {
-		o.LabelPrefix = pref
-	}
-}
-
-// MetricPrefix sets the metric prefix
-func MetricPrefix(pref string) Option {
-	return func(o *Options) {
-		o.MetricPrefix = pref
-	}
-}
-
 // Context sets the metrics context
 func Context(ctx context.Context) Option {
 	return func(o *Options) {
@@ -90,7 +70,7 @@ func TimingObjectives(value map[float64]float64) Option {
 }
 */
 
-// Labels sets the meter labels
+// Labels add the meter labels
 func Labels(ls ...string) Option {
 	return func(o *Options) {
 		o.Labels = append(o.Labels, ls...)

meter/wrapper/wrapper.go

@@ -1,347 +0,0 @@
-package wrapper // import "go.unistack.org/micro/v3/meter/wrapper"
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"go.unistack.org/micro/v3/client"
-	"go.unistack.org/micro/v3/meter"
-	"go.unistack.org/micro/v3/server"
-)
-
-var (
-	// ClientRequestDurationSeconds specifies meter metric name
-	ClientRequestDurationSeconds = "client_request_duration_seconds"
-	// ClientRequestLatencyMicroseconds specifies meter metric name
-	ClientRequestLatencyMicroseconds = "client_request_latency_microseconds"
-	// ClientRequestTotal specifies meter metric name
-	ClientRequestTotal = "client_request_total"
-	// ClientRequestInflight specifies meter metric name
-	ClientRequestInflight = "client_request_inflight"
-	// ServerRequestDurationSeconds specifies meter metric name
-	ServerRequestDurationSeconds = "server_request_duration_seconds"
-	// ServerRequestLatencyMicroseconds specifies meter metric name
-	ServerRequestLatencyMicroseconds = "server_request_latency_microseconds"
-	// ServerRequestTotal specifies meter metric name
-	ServerRequestTotal = "server_request_total"
-	// ServerRequestInflight specifies meter metric name
-	ServerRequestInflight = "server_request_inflight"
-	// PublishMessageDurationSeconds specifies meter metric name
-	PublishMessageDurationSeconds = "publish_message_duration_seconds"
-	// PublishMessageLatencyMicroseconds specifies meter metric name
-	PublishMessageLatencyMicroseconds = "publish_message_latency_microseconds"
-	// PublishMessageTotal specifies meter metric name
-	PublishMessageTotal = "publish_message_total"
-	// PublishMessageInflight specifies meter metric name
-	PublishMessageInflight = "publish_message_inflight"
-	// SubscribeMessageDurationSeconds specifies meter metric name
-	SubscribeMessageDurationSeconds = "subscribe_message_duration_seconds"
-	// SubscribeMessageLatencyMicroseconds specifies meter metric name
-	SubscribeMessageLatencyMicroseconds = "subscribe_message_latency_microseconds"
-	// SubscribeMessageTotal specifies meter metric name
-	SubscribeMessageTotal = "subscribe_message_total"
-	// SubscribeMessageInflight specifies meter metric name
-	SubscribeMessageInflight = "subscribe_message_inflight"
-
-	labelSuccess  = "success"
-	labelFailure  = "failure"
-	labelStatus   = "status"
-	labelEndpoint = "endpoint"
-
-	// DefaultSkipEndpoints contains list of endpoints that not evaluted by wrapper
-	DefaultSkipEndpoints = []string{"Meter.Metrics", "Health.Live", "Health.Ready", "Health.Version"}
-)
-
-// Options struct
-type Options struct {
-	Meter         meter.Meter
-	lopts         []meter.Option
-	SkipEndpoints []string
-}
-
-// Option func signature
-type Option func(*Options)
-
-// NewOptions creates new Options struct
-func NewOptions(opts ...Option) Options {
-	options := Options{
-		Meter:         meter.DefaultMeter,
-		lopts:         make([]meter.Option, 0, 5),
-		SkipEndpoints: DefaultSkipEndpoints,
-	}
-	for _, o := range opts {
-		o(&options)
-	}
-	return options
-}
-
-// ServiceName passes service name to meter label
-func ServiceName(name string) Option {
-	return func(o *Options) {
-		o.lopts = append(o.lopts, meter.Labels("name", name))
-	}
-}
-
-// ServiceVersion passes service version to meter label
-func ServiceVersion(version string) Option {
-	return func(o *Options) {
-		o.lopts = append(o.lopts, meter.Labels("version", version))
-	}
-}
-
-// ServiceID passes service id to meter label
-func ServiceID(id string) Option {
-	return func(o *Options) {
-		o.lopts = append(o.lopts, meter.Labels("id", id))
-	}
-}
-
-// Meter passes meter
-func Meter(m meter.Meter) Option {
-	return func(o *Options) {
-		o.Meter = m
-	}
-}
-
-// SkipEndoints add endpoint to skip
-func SkipEndoints(eps ...string) Option {
-	return func(o *Options) {
-		o.SkipEndpoints = append(o.SkipEndpoints, eps...)
-	}
-}
-
-type wrapper struct {
-	client.Client
-	callFunc client.CallFunc
-	opts     Options
-}
-
-// NewClientWrapper create new client wrapper
-func NewClientWrapper(opts ...Option) client.Wrapper {
-	return func(c client.Client) client.Client {
-		handler := &wrapper{
-			opts:   NewOptions(opts...),
-			Client: c,
-		}
-		return handler
-	}
-}
-
-// NewCallWrapper create new call wrapper
-func NewCallWrapper(opts ...Option) client.CallWrapper {
-	return func(fn client.CallFunc) client.CallFunc {
-		handler := &wrapper{
-			opts:     NewOptions(opts...),
-			callFunc: fn,
-		}
-		return handler.CallFunc
-	}
-}
-
-func (w *wrapper) CallFunc(ctx context.Context, addr string, req client.Request, rsp interface{}, opts client.CallOptions) error {
-	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
-	for _, ep := range w.opts.SkipEndpoints {
-		if ep == endpoint {
-			return w.callFunc(ctx, addr, req, rsp, opts)
-		}
-	}
-
-	labels := make([]string, 0, 4)
-	labels = append(labels, labelEndpoint, endpoint)
-
-	w.opts.Meter.Counter(ClientRequestInflight, labels...).Inc()
-	ts := time.Now()
-	err := w.callFunc(ctx, addr, req, rsp, opts)
-	te := time.Since(ts)
-	w.opts.Meter.Counter(ClientRequestInflight, labels...).Dec()
-
-	w.opts.Meter.Summary(ClientRequestLatencyMicroseconds, labels...).Update(te.Seconds())
-	w.opts.Meter.Histogram(ClientRequestDurationSeconds, labels...).Update(te.Seconds())
-
-	if err == nil {
-		labels = append(labels, labelStatus, labelSuccess)
-	} else {
-		labels = append(labels, labelStatus, labelFailure)
-	}
-	w.opts.Meter.Counter(ClientRequestTotal, labels...).Inc()
-
-	return err
-}
-
-func (w *wrapper) 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 w.opts.SkipEndpoints {
-		if ep == endpoint {
-			return w.Client.Call(ctx, req, rsp, opts...)
-		}
-	}
-
-	labels := make([]string, 0, 4)
-	labels = append(labels, labelEndpoint, endpoint)
-
-	w.opts.Meter.Counter(ClientRequestInflight, labels...).Inc()
-	ts := time.Now()
-	err := w.Client.Call(ctx, req, rsp, opts...)
-	te := time.Since(ts)
-	w.opts.Meter.Counter(ClientRequestInflight, labels...).Dec()
-
-	w.opts.Meter.Summary(ClientRequestLatencyMicroseconds, labels...).Update(te.Seconds())
-	w.opts.Meter.Histogram(ClientRequestDurationSeconds, labels...).Update(te.Seconds())
-
-	if err == nil {
-		labels = append(labels, labelStatus, labelSuccess)
-	} else {
-		labels = append(labels, labelStatus, labelFailure)
-	}
-	w.opts.Meter.Counter(ClientRequestTotal, labels...).Inc()
-
-	return err
-}
-
-func (w *wrapper) Stream(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
-	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
-	for _, ep := range w.opts.SkipEndpoints {
-		if ep == endpoint {
-			return w.Client.Stream(ctx, req, opts...)
-		}
-	}
-
-	labels := make([]string, 0, 4)
-	labels = append(labels, labelEndpoint, endpoint)
-
-	w.opts.Meter.Counter(ClientRequestInflight, labels...).Inc()
-	ts := time.Now()
-	stream, err := w.Client.Stream(ctx, req, opts...)
-	te := time.Since(ts)
-	w.opts.Meter.Counter(ClientRequestInflight, labels...).Dec()
-
-	w.opts.Meter.Summary(ClientRequestLatencyMicroseconds, labels...).Update(te.Seconds())
-	w.opts.Meter.Histogram(ClientRequestDurationSeconds, labels...).Update(te.Seconds())
-
-	if err == nil {
-		labels = append(labels, labelStatus, labelSuccess)
-	} else {
-		labels = append(labels, labelStatus, labelFailure)
-	}
-	w.opts.Meter.Counter(ClientRequestTotal, labels...).Inc()
-
-	return stream, err
-}
-
-func (w *wrapper) Publish(ctx context.Context, p client.Message, opts ...client.PublishOption) error {
-	endpoint := p.Topic()
-
-	labels := make([]string, 0, 4)
-	labels = append(labels, labelEndpoint, endpoint)
-
-	w.opts.Meter.Counter(PublishMessageInflight, labels...).Inc()
-	ts := time.Now()
-	err := w.Client.Publish(ctx, p, opts...)
-	te := time.Since(ts)
-	w.opts.Meter.Counter(PublishMessageInflight, labels...).Dec()
-
-	w.opts.Meter.Summary(PublishMessageLatencyMicroseconds, labels...).Update(te.Seconds())
-	w.opts.Meter.Histogram(PublishMessageDurationSeconds, labels...).Update(te.Seconds())
-
-	if err == nil {
-		labels = append(labels, labelStatus, labelSuccess)
-	} else {
-		labels = append(labels, labelStatus, labelFailure)
-	}
-	w.opts.Meter.Counter(PublishMessageTotal, labels...).Inc()
-
-	return err
-}
-
-// NewHandlerWrapper create new server handler wrapper
-// deprecated
-func NewHandlerWrapper(opts ...Option) server.HandlerWrapper {
-	handler := &wrapper{
-		opts: NewOptions(opts...),
-	}
-	return handler.HandlerFunc
-}
-
-// NewServerHandlerWrapper create new server handler wrapper
-func NewServerHandlerWrapper(opts ...Option) server.HandlerWrapper {
-	handler := &wrapper{
-		opts: NewOptions(opts...),
-	}
-	return handler.HandlerFunc
-}
-
-func (w *wrapper) HandlerFunc(fn server.HandlerFunc) server.HandlerFunc {
-	return func(ctx context.Context, req server.Request, rsp interface{}) error {
-		endpoint := req.Service() + "." + req.Endpoint()
-		for _, ep := range w.opts.SkipEndpoints {
-			if ep == endpoint {
-				return fn(ctx, req, rsp)
-			}
-		}
-
-		labels := make([]string, 0, 4)
-		labels = append(labels, labelEndpoint, endpoint)
-
-		w.opts.Meter.Counter(ServerRequestInflight, labels...).Inc()
-		ts := time.Now()
-		err := fn(ctx, req, rsp)
-		te := time.Since(ts)
-		w.opts.Meter.Counter(ServerRequestInflight, labels...).Dec()
-
-		w.opts.Meter.Summary(ServerRequestLatencyMicroseconds, labels...).Update(te.Seconds())
-		w.opts.Meter.Histogram(ServerRequestDurationSeconds, labels...).Update(te.Seconds())
-
-		if err == nil {
-			labels = append(labels, labelStatus, labelSuccess)
-		} else {
-			labels = append(labels, labelStatus, labelFailure)
-		}
-		w.opts.Meter.Counter(ServerRequestTotal, labels...).Inc()
-
-		return err
-	}
-}
-
-// NewSubscriberWrapper create server subscribe wrapper
-// deprecated
-func NewSubscriberWrapper(opts ...Option) server.SubscriberWrapper {
-	handler := &wrapper{
-		opts: NewOptions(opts...),
-	}
-	return handler.SubscriberFunc
-}
-
-func NewServerSubscriberWrapper(opts ...Option) server.SubscriberWrapper {
-	handler := &wrapper{
-		opts: NewOptions(opts...),
-	}
-	return handler.SubscriberFunc
-}
-
-func (w *wrapper) SubscriberFunc(fn server.SubscriberFunc) server.SubscriberFunc {
-	return func(ctx context.Context, msg server.Message) error {
-		endpoint := msg.Topic()
-
-		labels := make([]string, 0, 4)
-		labels = append(labels, labelEndpoint, endpoint)
-
-		w.opts.Meter.Counter(SubscribeMessageInflight, labels...).Inc()
-		ts := time.Now()
-		err := fn(ctx, msg)
-		te := time.Since(ts)
-		w.opts.Meter.Counter(SubscribeMessageInflight, labels...).Dec()
-
-		w.opts.Meter.Summary(SubscribeMessageLatencyMicroseconds, labels...).Update(te.Seconds())
-		w.opts.Meter.Histogram(SubscribeMessageDurationSeconds, labels...).Update(te.Seconds())
-
-		if err == nil {
-			labels = append(labels, labelStatus, labelSuccess)
-		} else {
-			labels = append(labels, labelStatus, labelFailure)
-		}
-		w.opts.Meter.Counter(SubscribeMessageTotal, labels...).Inc()
-
-		return err
-	}
-}

mtls/mtls.go

@@ -1,4 +1,4 @@
-package mtls // import "go.unistack.org/micro/v3/mtls"
+package mtls
 
 import (
 	"bytes"

network/network.go

@@ -1,5 +1,5 @@
 // Package network is for creating internetworks
-package network // import "go.unistack.org/micro/v3/network"
+package network
 
 import (
 	"go.unistack.org/micro/v3/client"

network/transport/transport.go

@@ -1,5 +1,5 @@
 // Package transport is an interface for synchronous connection based communication
-package transport // import "go.unistack.org/micro/v3/network/transport"
+package transport
 
 import (
 	"context"

network/tunnel/broker/broker.go

@@ -1,5 +1,5 @@
 // Package broker is a tunnel broker
-package broker // import "go.unistack.org/micro/v3/network/tunnel/broker"
+package broker
 
 import (
 	"context"
@@ -305,6 +305,10 @@ func (t *tunEvent) SetError(err error) {
 	t.err = err
 }
 
+func (t *tunEvent) Context() context.Context {
+	return context.TODO()
+}
+
 // NewBroker returns new tunnel broker
 func NewBroker(opts ...broker.Option) (broker.Broker, error) {
 	options := broker.NewOptions(opts...)

network/tunnel/transport/transport.go

@@ -1,5 +1,5 @@
 // Package transport provides a tunnel transport
-package transport // import "go.unistack.org/micro/v3/network/tunnel/transport"
+package transport
 
 import (
 	"context"

network/tunnel/tunnel.go

@@ -1,5 +1,5 @@
 // Package tunnel provides gre network tunnelling
-package tunnel // import "go.unistack.org/micro/v3/network/transport/tunnel"
+package tunnel
 
 import (
 	"context"

profiler/http/http.go

@@ -1,5 +1,5 @@
 // Package http enables the http profiler
-package http // import "go.unistack.org/micro/v3/profiler/http"
+package http
 
 import (
 	"context"

profiler/pprof/pprof.go

@@ -1,5 +1,5 @@
 // Package pprof provides a pprof profiler which writes output to /tmp/[name].{cpu,mem}.pprof
-package pprof // import "go.unistack.org/micro/v3/profiler/pprof"
+package pprof
 
 import (
 	"os"

profiler/profile.go

@@ -1,5 +1,5 @@
 // Package profiler is for profilers
-package profiler // import "go.unistack.org/micro/v3/profiler"
+package profiler
 
 // Profiler interface
 type Profiler interface {

proxy/proxy.go

@@ -1,5 +1,5 @@
 // Package proxy is a transparent proxy built on the micro/server
-package proxy // import "go.unistack.org/micro/v3/proxy"
+package proxy
 
 import (
 	"context"

register/register.go

@@ -1,5 +1,5 @@
 // Package register is an interface for service discovery
-package register // import "go.unistack.org/micro/v3/register"
+package register
 
 import (
 	"context"

resolver/dns/dns.go

@@ -1,5 +1,5 @@
 // Package dns resolves names to dns records
-package dns // import "go.unistack.org/micro/v3/resolver/dns"
+package dns
 
 import (
 	"context"

resolver/dnssrv/dnssrv.go

@@ -1,5 +1,5 @@
 // Package dnssrv resolves names to dns srv records
-package dnssrv // import "go.unistack.org/micro/v3/resolver/dnssrv"
+package dnssrv
 
 import (
 	"fmt"

resolver/http/http.go

@@ -1,5 +1,5 @@
 // Package http resolves names to network addresses using a http request
-package http // import "go.unistack.org/micro/v3/resolver/http"
+package http
 
 import (
 	"encoding/json"

resolver/noop/noop.go

@@ -1,5 +1,5 @@
 // Package noop is a noop resolver
-package noop // import "go.unistack.org/micro/v3/resolver/noop"
+package noop
 
 import (
 	"go.unistack.org/micro/v3/resolver"

resolver/registry/registry.go

@@ -1,5 +1,5 @@
 // Package register resolves names using the micro register
-package register // import "go.unistack.org/micro/v3/resolver/registry"
+package register
 
 import (
 	"context"

resolver/static/static.go

@@ -1,5 +1,5 @@
 // Package static is a static resolver
-package static // import "go.unistack.org/micro/v3/resolver/static"
+package static
 
 import (
 	"go.unistack.org/micro/v3/resolver"

router/router.go

@@ -1,5 +1,5 @@
 // Package router provides a network routing control plane
-package router // import "go.unistack.org/micro/v3/router"
+package router
 
 import (
 	"errors"

selector/random/random.go

@@ -1,4 +1,4 @@
-package random // import "go.unistack.org/micro/v3/selector/random"
+package random
 
 import (
 	"go.unistack.org/micro/v3/selector"

selector/roundrobin/roundrobin.go

@@ -1,4 +1,4 @@
-package roundrobin // import "go.unistack.org/micro/v3/selector/roundrobin"
+package roundrobin
 
 import (
 	"go.unistack.org/micro/v3/selector"

selector/selector.go

@@ -1,5 +1,5 @@
 // Package selector is for node selection and load balancing
-package selector // import "go.unistack.org/micro/v3/selector"
+package selector
 
 import (
 	"errors"

semconv/broker.go

@@ -2,21 +2,21 @@ package semconv
 
 var (
 	// PublishMessageDurationSeconds specifies meter metric name
-	PublishMessageDurationSeconds = "publish_message_duration_seconds"
+	PublishMessageDurationSeconds = "micro_publish_message_duration_seconds"
 	// PublishMessageLatencyMicroseconds specifies meter metric name
-	PublishMessageLatencyMicroseconds = "publish_message_latency_microseconds"
+	PublishMessageLatencyMicroseconds = "micro_publish_message_latency_microseconds"
 	// PublishMessageTotal specifies meter metric name
-	PublishMessageTotal = "publish_message_total"
+	PublishMessageTotal = "micro_publish_message_total"
 	// PublishMessageInflight specifies meter metric name
-	PublishMessageInflight = "publish_message_inflight"
+	PublishMessageInflight = "micro_publish_message_inflight"
 	// SubscribeMessageDurationSeconds specifies meter metric name
-	SubscribeMessageDurationSeconds = "subscribe_message_duration_seconds"
+	SubscribeMessageDurationSeconds = "micro_subscribe_message_duration_seconds"
 	// SubscribeMessageLatencyMicroseconds specifies meter metric name
-	SubscribeMessageLatencyMicroseconds = "subscribe_message_latency_microseconds"
+	SubscribeMessageLatencyMicroseconds = "micro_subscribe_message_latency_microseconds"
 	// SubscribeMessageTotal specifies meter metric name
-	SubscribeMessageTotal = "subscribe_message_total"
+	SubscribeMessageTotal = "micro_subscribe_message_total"
 	// SubscribeMessageInflight specifies meter metric name
-	SubscribeMessageInflight = "subscribe_message_inflight"
+	SubscribeMessageInflight = "micro_subscribe_message_inflight"
 	// BrokerGroupLag specifies broker lag
-	BrokerGroupLag = "broker_group_lag"
+	BrokerGroupLag = "micro_broker_group_lag"
 )

semconv/cache.go

@@ -1,12 +0,0 @@
-package semconv
-
-var (
-	// CacheRequestDurationSeconds specifies meter metric name
-	CacheRequestDurationSeconds = "cache_request_duration_seconds"
-	// ClientRequestLatencyMicroseconds specifies meter metric name
-	CacheRequestLatencyMicroseconds = "cache_request_latency_microseconds"
-	// CacheRequestTotal specifies meter metric name
-	CacheRequestTotal = "cache_request_total"
-	// CacheRequestInflight specifies meter metric name
-	CacheRequestInflight = "cache_request_inflight"
-)

semconv/client.go

@@ -2,11 +2,11 @@ package semconv
 
 var (
 	// ClientRequestDurationSeconds specifies meter metric name
-	ClientRequestDurationSeconds = "client_request_duration_seconds"
+	ClientRequestDurationSeconds = "micro_client_request_duration_seconds"
 	// ClientRequestLatencyMicroseconds specifies meter metric name
-	ClientRequestLatencyMicroseconds = "client_request_latency_microseconds"
+	ClientRequestLatencyMicroseconds = "micro_client_request_latency_microseconds"
 	// ClientRequestTotal specifies meter metric name
-	ClientRequestTotal = "client_request_total"
+	ClientRequestTotal = "micro_client_request_total"
 	// ClientRequestInflight specifies meter metric name
-	ClientRequestInflight = "client_request_inflight"
+	ClientRequestInflight = "micro_client_request_inflight"
 )

semconv/logger.go

@@ -1,4 +1,4 @@
 package semconv
 
 // LoggerMessageTotal specifies meter metric name for logger messages
-var LoggerMessageTotal = "logger_message_total"
+var LoggerMessageTotal = "micro_logger_message_total"

semconv/server.go

@@ -2,11 +2,11 @@ package semconv
 
 var (
 	// ServerRequestDurationSeconds specifies meter metric name
-	ServerRequestDurationSeconds = "server_request_duration_seconds"
+	ServerRequestDurationSeconds = "micro_server_request_duration_seconds"
 	// ServerRequestLatencyMicroseconds specifies meter metric name
-	ServerRequestLatencyMicroseconds = "server_request_latency_microseconds"
+	ServerRequestLatencyMicroseconds = "micro_server_request_latency_microseconds"
 	// ServerRequestTotal specifies meter metric name
-	ServerRequestTotal = "server_request_total"
+	ServerRequestTotal = "micro_server_request_total"
 	// ServerRequestInflight specifies meter metric name
-	ServerRequestInflight = "server_request_inflight"
+	ServerRequestInflight = "micro_server_request_inflight"
 )

semconv/store.go

@@ -0,0 +1,12 @@
+package semconv
+
+var (
+	// StoreRequestDurationSeconds specifies meter metric name
+	StoreRequestDurationSeconds = "micro_store_request_duration_seconds"
+	// ClientRequestLatencyMicroseconds specifies meter metric name
+	StoreRequestLatencyMicroseconds = "micro_store_request_latency_microseconds"
+	// StoreRequestTotal specifies meter metric name
+	StoreRequestTotal = "micro_store_request_total"
+	// StoreRequestInflight specifies meter metric name
+	StoreRequestInflight = "micro_store_request_inflight"
+)

server/noop.go

@@ -1,7 +1,6 @@
 package server
 
 import (
-	"bytes"
 	"context"
 	"fmt"
 	"reflect"
@@ -691,7 +690,7 @@ func (n *noopServer) createSubHandler(sb *subscriber, opts Options) broker.Handl
 				req = req.Elem()
 			}
 
-			if err = cf.ReadBody(bytes.NewBuffer(msg.Body), req.Interface()); err != nil {
+			if err = cf.Unmarshal(msg.Body, req.Interface()); err != nil {
 				return err
 			}
 

server/server.go

@@ -1,5 +1,5 @@
 // Package server is an interface for a micro server
-package server // import "go.unistack.org/micro/v3/server"
+package server
 
 import (
 	"context"
@@ -11,7 +11,9 @@ import (
 )
 
 // DefaultServer default server
-var DefaultServer Server = NewServer()
+var (
+	DefaultServer Server = NewServer()
+)
 
 var (
 	// DefaultAddress will be used if no address passed, use secure localhost

store/store.go

@@ -1,5 +1,5 @@
 // Package store is an interface for distributed data storage.
-package store // import "go.unistack.org/micro/v3/store"
+package store
 
 import (
 	"context"

sync/sync.go

@@ -1,5 +1,5 @@
 // Package sync is an interface for distributed synchronization
-package sync // import "go.unistack.org/micro/v3/sync"
+package sync
 
 import (
 	"errors"

tracer/options.go

@@ -140,6 +140,8 @@ type Options struct {
 	Logger logger.Logger
 	// Name of the tracer
 	Name string
+	// ContextAttrFuncs contains funcs that provides tracing
+	ContextAttrFuncs []ContextAttrFunc
 }
 
 // Option func signature
@@ -176,8 +178,9 @@ func NewSpanOptions(opts ...SpanOption) SpanOptions {
 // NewOptions returns default options
 func NewOptions(opts ...Option) Options {
 	options := Options{
-		Logger:  logger.DefaultLogger,
+		Logger:           logger.DefaultLogger,
-		Context: context.Background(),
+		Context:          context.Background(),
+		ContextAttrFuncs: DefaultContextAttrFuncs,
 	}
 	for _, o := range opts {
 		o(&options)

tracer/tracer.go

@@ -1,5 +1,5 @@
 // Package tracer provides an interface for distributed tracing
-package tracer // import "go.unistack.org/micro/v3/tracer"
+package tracer
 
 import (
 	"context"
@@ -21,8 +21,11 @@ var (
 		"HealthService.Ready",
 		"HealthService.Version",
 	}
+	DefaultContextAttrFuncs []ContextAttrFunc
 )
 
+type ContextAttrFunc func(ctx context.Context) []interface{}
+
 func init() {
 	logger.DefaultContextAttrFuncs = append(logger.DefaultContextAttrFuncs,
 		func(ctx context.Context) []interface{} {

tracer/wrapper/wrapper.go

@@ -1,415 +0,0 @@
-// Package wrapper provides wrapper for Tracer
-package wrapper // import "go.unistack.org/micro/v3/tracer/wrapper"
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"go.unistack.org/micro/v3/client"
-	"go.unistack.org/micro/v3/metadata"
-	"go.unistack.org/micro/v3/server"
-	"go.unistack.org/micro/v3/tracer"
-)
-
-var DefaultHeadersExctract = []string{metadata.HeaderXRequestID}
-
-func ExtractDefaultLabels(md metadata.Metadata) []interface{} {
-	labels := make([]interface{}, 0, len(DefaultHeadersExctract))
-	for _, k := range DefaultHeadersExctract {
-		if v, ok := md.Get(k); ok {
-			labels = append(labels, strings.ToLower(k), v)
-		}
-	}
-	return labels
-}
-
-var (
-	DefaultClientCallObserver = func(ctx context.Context, req client.Request, rsp interface{}, opts []client.CallOption, sp tracer.Span, err error) {
-		var labels []interface{}
-		if md, ok := metadata.FromOutgoingContext(ctx); ok {
-			labels = append(labels, ExtractDefaultLabels(md)...)
-		}
-		if err != nil {
-			sp.SetStatus(tracer.SpanStatusError, err.Error())
-		}
-		sp.AddLabels(labels...)
-	}
-
-	DefaultClientStreamObserver = func(ctx context.Context, req client.Request, opts []client.CallOption, stream client.Stream, sp tracer.Span, err error) {
-		var labels []interface{}
-		if md, ok := metadata.FromOutgoingContext(ctx); ok {
-			labels = append(labels, ExtractDefaultLabels(md)...)
-		}
-		if err != nil {
-			sp.SetStatus(tracer.SpanStatusError, err.Error())
-		}
-		sp.AddLabels(labels...)
-	}
-
-	DefaultClientPublishObserver = func(ctx context.Context, msg client.Message, opts []client.PublishOption, sp tracer.Span, err error) {
-		var labels []interface{}
-		if md, ok := metadata.FromOutgoingContext(ctx); ok {
-			labels = append(labels, ExtractDefaultLabels(md)...)
-		}
-		labels = append(labels, ExtractDefaultLabels(msg.Metadata())...)
-		if err != nil {
-			sp.SetStatus(tracer.SpanStatusError, err.Error())
-		}
-		sp.AddLabels(labels...)
-	}
-
-	DefaultServerHandlerObserver = func(ctx context.Context, req server.Request, rsp interface{}, sp tracer.Span, err error) {
-		var labels []interface{}
-		if md, ok := metadata.FromIncomingContext(ctx); ok {
-			labels = append(labels, ExtractDefaultLabels(md)...)
-		}
-		if err != nil {
-			sp.SetStatus(tracer.SpanStatusError, err.Error())
-		}
-		sp.AddLabels(labels...)
-	}
-
-	DefaultServerSubscriberObserver = func(ctx context.Context, msg server.Message, sp tracer.Span, err error) {
-		var labels []interface{}
-		if md, ok := metadata.FromIncomingContext(ctx); ok {
-			labels = append(labels, ExtractDefaultLabels(md)...)
-		}
-		labels = append(labels, ExtractDefaultLabels(msg.Header())...)
-
-		if err != nil {
-			sp.SetStatus(tracer.SpanStatusError, err.Error())
-		}
-		sp.AddLabels(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("%s.%s call", req.Service(), req.Method()))
-		var labels []interface{}
-		if md, ok := metadata.FromOutgoingContext(ctx); ok {
-			labels = append(labels, ExtractDefaultLabels(md)...)
-		}
-		if err != nil {
-			sp.SetStatus(tracer.SpanStatusError, err.Error())
-		}
-		sp.AddLabels(labels...)
-	}
-
-	DefaultSkipEndpoints = []string{"Meter.Metrics", "Health.Live", "Health.Ready", "Health.Version"}
-)
-
-type tWrapper struct {
-	client.Client
-	serverHandler    server.HandlerFunc
-	serverSubscriber server.SubscriberFunc
-	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)
-)
-
-// Options struct
-type Options struct {
-	// Tracer that used for tracing
-	Tracer tracer.Tracer
-	// ClientCallObservers funcs
-	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
-}
-
-// Option func signature
-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,
-	}
-
-	for _, o := range opts {
-		o(&options)
-	}
-
-	return options
-}
-
-// WithTracer pass tracer
-func WithTracer(t tracer.Tracer) Option {
-	return func(o *Options) {
-		o.Tracer = t
-	}
-}
-
-// SkipEndponts
-func SkipEndpoins(eps ...string) Option {
-	return func(o *Options) {
-		o.SkipEndpoints = append(o.SkipEndpoints, eps...)
-	}
-}
-
-// WithClientCallObservers funcs
-func WithClientCallObservers(ob ...ClientCallObserver) Option {
-	return func(o *Options) {
-		o.ClientCallObservers = ob
-	}
-}
-
-// WithClientStreamObservers funcs
-func WithClientStreamObservers(ob ...ClientStreamObserver) Option {
-	return func(o *Options) {
-		o.ClientStreamObservers = ob
-	}
-}
-
-// 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) {
-		o.ClientCallFuncObservers = ob
-	}
-}
-
-// WithServerHandlerObservers funcs
-func WithServerHandlerObservers(ob ...ServerHandlerObserver) Option {
-	return func(o *Options) {
-		o.ServerHandlerObservers = ob
-	}
-}
-
-// 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 {
-		if ep == endpoint {
-			return ot.Client.Call(ctx, req, rsp, opts...)
-		}
-	}
-
-	nctx, sp := ot.opts.Tracer.Start(ctx, fmt.Sprintf("%s.%s rpc-client", req.Service(), req.Method()),
-		tracer.WithSpanKind(tracer.SpanKindClient),
-		tracer.WithSpanLabels(
-			"rpc.service", req.Service(),
-			"rpc.method", req.Method(),
-			"rpc.flavor", "rpc",
-			"rpc.call", "/"+req.Service()+"/"+req.Endpoint(),
-			"rpc.call_type", "unary",
-		),
-	)
-	defer sp.Finish()
-
-	err := ot.Client.Call(nctx, req, rsp, opts...)
-
-	for _, o := range ot.opts.ClientCallObservers {
-		o(nctx, req, rsp, opts, sp, err)
-	}
-
-	return err
-}
-
-func (ot *tWrapper) Stream(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
-	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
-	for _, ep := range ot.opts.SkipEndpoints {
-		if ep == endpoint {
-			return ot.Client.Stream(ctx, req, opts...)
-		}
-	}
-
-	nctx, sp := ot.opts.Tracer.Start(ctx, fmt.Sprintf("%s.%s rpc-client", req.Service(), req.Method()),
-		tracer.WithSpanKind(tracer.SpanKindClient),
-		tracer.WithSpanLabels(
-			"rpc.service", req.Service(),
-			"rpc.method", req.Method(),
-			"rpc.flavor", "rpc",
-			"rpc.call", "/"+req.Service()+"/"+req.Endpoint(),
-			"rpc.call_type", "stream",
-		),
-	)
-	defer sp.Finish()
-
-	stream, err := ot.Client.Stream(nctx, req, opts...)
-
-	for _, o := range ot.opts.ClientStreamObservers {
-		o(nctx, req, opts, stream, sp, err)
-	}
-
-	return stream, err
-}
-
-func (ot *tWrapper) Publish(ctx context.Context, msg client.Message, opts ...client.PublishOption) error {
-	nctx, sp := ot.opts.Tracer.Start(ctx, msg.Topic()+" publish", tracer.WithSpanKind(tracer.SpanKindProducer))
-	defer sp.Finish()
-	sp.AddLabels("messaging.destination.name", msg.Topic())
-	sp.AddLabels("messaging.operation", "publish")
-	err := ot.Client.Publish(nctx, msg, opts...)
-
-	for _, o := range ot.opts.ClientPublishObservers {
-		o(nctx, 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 {
-		if ep == endpoint {
-			return ot.serverHandler(ctx, req, rsp)
-		}
-	}
-
-	callType := "unary"
-	if req.Stream() {
-		callType = "stream"
-	}
-
-	nctx, sp := ot.opts.Tracer.Start(ctx, fmt.Sprintf("%s.%s rpc-server", req.Service(), req.Method()),
-		tracer.WithSpanKind(tracer.SpanKindServer),
-		tracer.WithSpanLabels(
-			"rpc.service", req.Service(),
-			"rpc.method", req.Method(),
-			"rpc.flavor", "rpc",
-			"rpc.call", "/"+req.Service()+"/"+req.Endpoint(),
-			"rpc.call_type", callType,
-		),
-	)
-	defer sp.Finish()
-
-	err := ot.serverHandler(nctx, req, rsp)
-
-	for _, o := range ot.opts.ServerHandlerObservers {
-		o(nctx, req, rsp, sp, err)
-	}
-
-	return err
-}
-
-func (ot *tWrapper) ServerSubscriber(ctx context.Context, msg server.Message) error {
-	nctx, sp := ot.opts.Tracer.Start(ctx, msg.Topic()+" process", tracer.WithSpanKind(tracer.SpanKindConsumer))
-	defer sp.Finish()
-	sp.AddLabels("messaging.operation", "process")
-	sp.AddLabels("messaging.source.name", msg.Topic())
-	err := ot.serverSubscriber(nctx, msg)
-
-	for _, o := range ot.opts.ServerSubscriberObservers {
-		o(nctx, 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 {
-		options := NewOptions()
-		for _, o := range opts {
-			o(&options)
-		}
-		return &tWrapper{opts: options, Client: c}
-	}
-}
-
-// NewClientCallWrapper accepts an opentracing Tracer and returns a Call Wrapper
-func NewClientCallWrapper(opts ...Option) client.CallWrapper {
-	return func(h client.CallFunc) client.CallFunc {
-		options := NewOptions()
-		for _, o := range opts {
-			o(&options)
-		}
-
-		ot := &tWrapper{opts: options, clientCallFunc: h}
-		return ot.ClientCallFunc
-	}
-}
-
-func (ot *tWrapper) ClientCallFunc(ctx context.Context, addr string, req client.Request, rsp interface{}, opts client.CallOptions) error {
-	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Method())
-	for _, ep := range ot.opts.SkipEndpoints {
-		if ep == endpoint {
-			return ot.ClientCallFunc(ctx, addr, req, rsp, opts)
-		}
-	}
-
-	nctx, sp := ot.opts.Tracer.Start(ctx, fmt.Sprintf("%s.%s rpc-client", req.Service(), req.Method()),
-		tracer.WithSpanKind(tracer.SpanKindClient),
-		tracer.WithSpanLabels(
-			"rpc.service", req.Service(),
-			"rpc.method", req.Method(),
-			"rpc.flavor", "rpc",
-			"rpc.call", "/"+req.Service()+"/"+req.Endpoint(),
-			"rpc.call_type", "unary",
-		),
-	)
-
-	defer sp.Finish()
-
-	err := ot.clientCallFunc(nctx, addr, req, rsp, opts)
-
-	for _, o := range ot.opts.ClientCallFuncObservers {
-		o(nctx, addr, req, rsp, opts, sp, err)
-	}
-
-	return err
-}
-
-// NewServerHandlerWrapper accepts an options and returns a Handler Wrapper
-func NewServerHandlerWrapper(opts ...Option) server.HandlerWrapper {
-	return func(h server.HandlerFunc) server.HandlerFunc {
-		options := NewOptions()
-		for _, o := range opts {
-			o(&options)
-		}
-
-		ot := &tWrapper{opts: options, serverHandler: h}
-		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
-	}
-}

util/addr/addr.go

@@ -1,4 +1,4 @@
-package addr // import "go.unistack.org/micro/v3/util/addr"
+package addr
 
 import (
 	"fmt"
@@ -58,6 +58,7 @@ func IsLocal(addr string) bool {
 }
 
 // Extract returns a real ip
+//
 //nolint:gocyclo
 func Extract(addr string) (string, error) {
 	// if addr specified then its returned

util/backoff/backoff.go

@@ -1,5 +1,5 @@
 // Package backoff provides backoff functionality
-package backoff // import "go.unistack.org/micro/v3/util/backoff"
+package backoff
 
 import (
 	"math"

util/buf/buf.go

@@ -1,4 +1,4 @@
-package buf // import "go.unistack.org/micro/v3/util/buf"
+package buf
 
 import (
 	"bytes"

util/http/http.go

@@ -1,4 +1,4 @@
-package http // import "go.unistack.org/micro/v3/util/http"
+package http
 
 import (
 	"context"

util/id/id.go

@@ -1,4 +1,4 @@
-package id // import "go.unistack.org/micro/v3/util/id"
+package id
 
 import (
 	"context"

util/io/io.go

@@ -1,5 +1,5 @@
 // Package io is for io management
-package io // import "go.unistack.org/micro/v3/util/io"
+package io
 
 import (
 	"io"

util/jitter/random.go

@@ -1,5 +1,5 @@
 // Package jitter provides a random jitter
-package jitter // import "go.unistack.org/micro/v3/util/jitter"
+package jitter
 
 import (
 	"time"

util/jitter/ticker.go

@@ -1,4 +1,4 @@
-package jitter // import "go.unistack.org/micro/v3/util/jitter"
+package jitter
 
 import (
 	"context"

util/net/net.go

@@ -1,4 +1,4 @@
-package net // import "go.unistack.org/micro/v3/util/net"
+package net
 
 import (
 	"errors"

util/pki/pki.go

@@ -1,6 +1,6 @@
 // Package pki provides PKI all the PKI functions necessary to run micro over an untrusted network
 // including a CA
-package pki // import "go.unistack.org/micro/v3/util/pki"
+package pki
 
 import (
 	"bytes"

util/pool/pool.go

@@ -1,5 +1,5 @@
 // Package pool is a connection pool
-package pool // import "go.unistack.org/micro/v3/util/pool"
+package pool
 
 import (
 	"context"

util/rand/rand.go

@@ -1,4 +1,4 @@
-package rand // import "go.unistack.org/micro/v3/util/rand"
+package rand
 
 import (
 	crand "crypto/rand"

util/reflect/reflect.go

@@ -44,6 +44,37 @@ func SliceAppend(b bool) Option {
 	}
 }
 
+var maxDepth = 32
+
+func mergeMap(dst, src map[string]interface{}, depth int) map[string]interface{} {
+	if depth > maxDepth {
+		return dst
+	}
+	for key, srcVal := range src {
+		if dstVal, ok := dst[key]; ok {
+			srcMap, srcMapOk := mapify(srcVal)
+			dstMap, dstMapOk := mapify(dstVal)
+			if srcMapOk && dstMapOk {
+				srcVal = mergeMap(dstMap, srcMap, depth+1)
+			}
+		}
+		dst[key] = srcVal
+	}
+	return dst
+}
+
+func mapify(i interface{}) (map[string]interface{}, bool) {
+	value := reflect.ValueOf(i)
+	if value.Kind() == reflect.Map {
+		m := map[string]interface{}{}
+		for _, k := range value.MapKeys() {
+			m[k.String()] = value.MapIndex(k).Interface()
+		}
+		return m, true
+	}
+	return map[string]interface{}{}, false
+}
+
 // Merge merges map[string]interface{} to destination struct
 func Merge(dst interface{}, mp map[string]interface{}, opts ...Option) error {
 	options := Options{}
@@ -59,6 +90,11 @@ func Merge(dst interface{}, mp map[string]interface{}, opts ...Option) error {
 		return err
 	}
 
+	if mapper, ok := dst.(map[string]interface{}); ok {
+		dst = mergeMap(mapper, mp, 0)
+		return nil
+	}
+
 	var err error
 	var sval reflect.Value
 	var fname string

util/reflect/reflect_test.go

@@ -4,6 +4,27 @@ import (
 	"testing"
 )
 
+func TestMergeMap(t *testing.T) {
+	src := map[string]interface{}{
+		"skey1": "sval1",
+		"skey2": map[string]interface{}{
+			"skey3": "sval3",
+		},
+	}
+	dst := map[string]interface{}{
+		"skey1": "dval1",
+		"skey2": map[string]interface{}{
+			"skey3": "dval3",
+		},
+	}
+
+	if err := Merge(src, dst); err != nil {
+		t.Fatal(err)
+	}
+
+	t.Logf("%#+v", src)
+}
+
 func TestFieldName(t *testing.T) {
 	src := "SomeVar"
 	chk := "some_var"

util/register/util.go

@@ -1,4 +1,4 @@
-package register // import "go.unistack.org/micro/v3/util/register"
+package register
 
 import (
 	"context"

util/ring/buffer.go

@@ -1,5 +1,5 @@
 // Package ring provides a simple ring buffer for storing local data
-package ring // import "go.unistack.org/micro/v3/util/ring"
+package ring
 
 import (
 	"sync"

util/socket/socket.go

@@ -1,5 +1,5 @@
 // Package socket provides a pseudo socket
-package socket // import "go.unistack.org/micro/v3/util/socket"
+package socket
 
 import (
 	"io"

util/sort/sort_test.go

@@ -0,0 +1,60 @@
+package sort
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestUniq(t *testing.T) {
+	type args struct {
+		labels []interface{}
+	}
+
+	tests := []struct {
+		name string
+		args args
+		want []interface{}
+	}{
+		{
+			name: "test#1",
+			args: args{
+				labels: append(make([]interface{}, 0), "test-1", 1, "test-2", 2),
+			},
+			want: append(make([]interface{}, 0), "test-1", 1, "test-2", 2),
+		},
+		{
+			name: "test#2",
+			args: args{
+				labels: append(make([]interface{}, 0), "test-1", 1, "test-2", 2, "test-2", 2),
+			},
+			want: append(make([]interface{}, 0), "test-1", 1, "test-2", 2),
+		},
+		{
+			name: "test#3",
+			args: args{
+				labels: append(make([]interface{}, 0), "test-1", 1, "test-2", 2, "test-2", 3),
+			},
+			want: append(make([]interface{}, 0), "test-1", 1, "test-2", 3),
+		},
+		{
+			name: "test#4",
+			args: args{
+				labels: append(make([]interface{}, 0),
+					"test-1", 1, "test-1", 2,
+					"test-2", 3, "test-2", 2,
+					"test-3", 5, "test-3", 3,
+					"test-1", 4, "test-1", 1),
+			},
+			want: append(make([]interface{}, 0), "test-1", 1, "test-2", 2, "test-3", 3),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var got []interface{}
+			if got = Uniq(tt.args.labels); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("Uniq() = %v, want %v", got, tt.want)
+			}
+			t.Logf("got-%#v", got)
+		})
+	}
+}

util/stream/stream.go

@@ -1,5 +1,5 @@
 // Package stream encapsulates streams within streams
-package stream // import "go.unistack.org/micro/v3/util/stream"
+package stream
 
 import (
 	"context"

util/xpool/pool.go

@@ -1,6 +1,9 @@
 package pool
 
-import "sync"
+import (
+	"bytes"
+	"sync"
+)
 
 type Pool[T any] struct {
 	p *sync.Pool
@@ -23,3 +26,11 @@ func (p Pool[T]) Get() T {
 func (p Pool[T]) Put(t T) {
 	p.p.Put(t)
 }
+
+func NewBytePool(size int) Pool[[]byte] {
+	return NewPool(func() []byte { return make([]byte, size) })
+}
+
+func NewBytesPool() Pool[*bytes.Buffer] {
+	return NewPool(func() *bytes.Buffer { return bytes.NewBuffer(nil) })
+}