fixup interfaces

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

.gitea/workflows/lint.yml

@@ -10,15 +10,15 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: setup-go
-      uses: https://gitea.com/actions/setup-go@v3
+      uses: actions/setup-go@v3
       with:
-        go-version: 1.18
+        go-version: 1.21
     - name: checkout
-      uses: https://gitea.com/actions/checkout@v3
+      uses: actions/checkout@v3
     - name: deps
       run: go get -v -d ./...
     - name: lint
       uses: https://github.com/golangci/golangci-lint-action@v3.4.0
       continue-on-error: true
       with:
-        version: v1.52
+        version: v1.52

.gitea/workflows/pr.yml

@@ -10,14 +10,14 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: checkout
-      uses: https://gitea.com/actions/checkout@v3
+      uses: actions/checkout@v3
     - name: setup-go
-      uses: https://gitea.com/actions/setup-go@v3
+      uses: actions/setup-go@v3
       with:
-        go-version: 1.18
+        go-version: 1.21
     - name: deps
       run: go get -v -t -d ./...
     - name: test
       env:
         INTEGRATION_TESTS: yes
-      run: go test -mod readonly -v ./...
+      run: go test -mod readonly -v ./...

broker/broker.go

@@ -10,7 +10,7 @@ import (
 )
 
 // DefaultBroker default memory broker
-var DefaultBroker = NewBroker()
+var DefaultBroker Broker = NewBroker()
 
 var (
 	// ErrNotConnected returns when broker used but not connected yet

broker/memory/memory.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"sync"
 
+	"go.unistack.org/micro/v3/broker"
 	"go.unistack.org/micro/v3/logger"
 	"go.unistack.org/micro/v3/metadata"
 	maddr "go.unistack.org/micro/v3/util/addr"
@@ -15,7 +16,7 @@ import (
 type memoryBroker struct {
 	subscribers map[string][]*memorySubscriber
 	addr        string
-	opts        Options
+	opts        broker.Options
 	sync.RWMutex
 	connected bool
 }
@@ -24,20 +25,20 @@ type memoryEvent struct {
 	err     error
 	message interface{}
 	topic   string
-	opts    Options
+	opts    broker.Options
 }
 
 type memorySubscriber struct {
 	ctx          context.Context
 	exit         chan bool
-	handler      Handler
-	batchhandler BatchHandler
+	handler      broker.Handler
+	batchhandler broker.BatchHandler
 	id           string
 	topic        string
-	opts         SubscribeOptions
+	opts         broker.SubscribeOptions
 }
 
-func (m *memoryBroker) Options() Options {
+func (m *memoryBroker) Options() broker.Options {
 	return m.opts
 }
 
@@ -46,6 +47,12 @@ func (m *memoryBroker) Address() string {
 }
 
 func (m *memoryBroker) Connect(ctx context.Context) error {
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	default:
+	}
+
 	m.Lock()
 	defer m.Unlock()
 
@@ -70,6 +77,12 @@ func (m *memoryBroker) Connect(ctx context.Context) error {
 }
 
 func (m *memoryBroker) Disconnect(ctx context.Context) error {
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	default:
+	}
+
 	m.Lock()
 	defer m.Unlock()
 
@@ -81,27 +94,27 @@ func (m *memoryBroker) Disconnect(ctx context.Context) error {
 	return nil
 }
 
-func (m *memoryBroker) Init(opts ...Option) error {
+func (m *memoryBroker) Init(opts ...broker.Option) error {
 	for _, o := range opts {
 		o(&m.opts)
 	}
 	return nil
 }
 
-func (m *memoryBroker) Publish(ctx context.Context, topic string, msg *Message, opts ...PublishOption) error {
+func (m *memoryBroker) Publish(ctx context.Context, topic string, msg *broker.Message, opts ...broker.PublishOption) error {
 	msg.Header.Set(metadata.HeaderTopic, topic)
-	return m.publish(ctx, []*Message{msg}, opts...)
+	return m.publish(ctx, []*broker.Message{msg}, opts...)
 }
 
-func (m *memoryBroker) BatchPublish(ctx context.Context, msgs []*Message, opts ...PublishOption) error {
+func (m *memoryBroker) BatchPublish(ctx context.Context, msgs []*broker.Message, opts ...broker.PublishOption) error {
 	return m.publish(ctx, msgs, opts...)
 }
 
-func (m *memoryBroker) publish(ctx context.Context, msgs []*Message, opts ...PublishOption) error {
+func (m *memoryBroker) publish(ctx context.Context, msgs []*broker.Message, opts ...broker.PublishOption) error {
 	m.RLock()
 	if !m.connected {
 		m.RUnlock()
-		return ErrNotConnected
+		return broker.ErrNotConnected
 	}
 	m.RUnlock()
 
@@ -111,9 +124,9 @@ func (m *memoryBroker) publish(ctx context.Context, msgs []*Message, opts ...Pub
 	case <-ctx.Done():
 		return ctx.Err()
 	default:
-		options := NewPublishOptions(opts...)
+		options := broker.NewPublishOptions(opts...)
 
-		msgTopicMap := make(map[string]Events)
+		msgTopicMap := make(map[string]broker.Events)
 		for _, v := range msgs {
 			p := &memoryEvent{opts: m.opts}
 
@@ -188,11 +201,11 @@ func (m *memoryBroker) publish(ctx context.Context, msgs []*Message, opts ...Pub
 	return nil
 }
 
-func (m *memoryBroker) BatchSubscribe(ctx context.Context, topic string, handler BatchHandler, opts ...SubscribeOption) (Subscriber, error) {
+func (m *memoryBroker) BatchSubscribe(ctx context.Context, topic string, handler broker.BatchHandler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
 	m.RLock()
 	if !m.connected {
 		m.RUnlock()
-		return nil, ErrNotConnected
+		return nil, broker.ErrNotConnected
 	}
 	m.RUnlock()
 
@@ -201,7 +214,7 @@ func (m *memoryBroker) BatchSubscribe(ctx context.Context, topic string, handler
 		return nil, err
 	}
 
-	options := NewSubscribeOptions(opts...)
+	options := broker.NewSubscribeOptions(opts...)
 
 	sub := &memorySubscriber{
 		exit:         make(chan bool, 1),
@@ -233,11 +246,11 @@ func (m *memoryBroker) BatchSubscribe(ctx context.Context, topic string, handler
 	return sub, nil
 }
 
-func (m *memoryBroker) Subscribe(ctx context.Context, topic string, handler Handler, opts ...SubscribeOption) (Subscriber, error) {
+func (m *memoryBroker) Subscribe(ctx context.Context, topic string, handler broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
 	m.RLock()
 	if !m.connected {
 		m.RUnlock()
-		return nil, ErrNotConnected
+		return nil, broker.ErrNotConnected
 	}
 	m.RUnlock()
 
@@ -246,7 +259,7 @@ func (m *memoryBroker) Subscribe(ctx context.Context, topic string, handler Hand
 		return nil, err
 	}
 
-	options := NewSubscribeOptions(opts...)
+	options := broker.NewSubscribeOptions(opts...)
 
 	sub := &memorySubscriber{
 		exit:    make(chan bool, 1),
@@ -290,12 +303,12 @@ func (m *memoryEvent) Topic() string {
 	return m.topic
 }
 
-func (m *memoryEvent) Message() *Message {
+func (m *memoryEvent) Message() *broker.Message {
 	switch v := m.message.(type) {
-	case *Message:
+	case *broker.Message:
 		return v
 	case []byte:
-		msg := &Message{}
+		msg := &broker.Message{}
 		if err := m.opts.Codec.Unmarshal(v, msg); err != nil {
 			if m.opts.Logger.V(logger.ErrorLevel) {
 				m.opts.Logger.Error(m.opts.Context, "[memory]: failed to unmarshal: %v", err)
@@ -320,7 +333,7 @@ func (m *memoryEvent) SetError(err error) {
 	m.err = err
 }
 
-func (m *memorySubscriber) Options() SubscribeOptions {
+func (m *memorySubscriber) Options() broker.SubscribeOptions {
 	return m.opts
 }
 
@@ -334,9 +347,9 @@ func (m *memorySubscriber) Unsubscribe(ctx context.Context) error {
 }
 
 // NewBroker return new memory broker
-func NewBroker(opts ...Option) Broker {
+func NewBroker(opts ...broker.Option) broker.Broker {
 	return &memoryBroker{
-		opts:        NewOptions(opts...),
+		opts:        broker.NewOptions(opts...),
 		subscribers: make(map[string][]*memorySubscriber),
 	}
 }

broker/memory/memory_test.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"testing"
 
+	"go.unistack.org/micro/v3/broker"
 	"go.unistack.org/micro/v3/metadata"
 )
 
@@ -19,7 +20,7 @@ func TestMemoryBatchBroker(t *testing.T) {
 	topic := "test"
 	count := 10
 
-	fn := func(evts Events) error {
+	fn := func(evts broker.Events) error {
 		return evts.Ack()
 	}
 
@@ -28,9 +29,9 @@ func TestMemoryBatchBroker(t *testing.T) {
 		t.Fatalf("Unexpected error subscribing %v", err)
 	}
 
-	msgs := make([]*Message, 0, count)
+	msgs := make([]*broker.Message, 0, count)
 	for i := 0; i < count; i++ {
-		message := &Message{
+		message := &broker.Message{
 			Header: map[string]string{
 				metadata.HeaderTopic: topic,
 				"foo":                "bar",
@@ -65,7 +66,7 @@ func TestMemoryBroker(t *testing.T) {
 	topic := "test"
 	count := 10
 
-	fn := func(p Event) error {
+	fn := func(p broker.Event) error {
 		return nil
 	}
 
@@ -74,9 +75,9 @@ func TestMemoryBroker(t *testing.T) {
 		t.Fatalf("Unexpected error subscribing %v", err)
 	}
 
-	msgs := make([]*Message, 0, count)
+	msgs := make([]*broker.Message, 0, count)
 	for i := 0; i < count; i++ {
-		message := &Message{
+		message := &broker.Message{
 			Header: map[string]string{
 				metadata.HeaderTopic: topic,
 				"foo":                "bar",

broker/noop.go

@@ -0,0 +1,82 @@
+package broker
+
+import (
+	"context"
+	"strings"
+)
+
+type NoopBroker struct {
+	opts Options
+}
+
+func NewBroker(opts ...Option) *NoopBroker {
+	b := &NoopBroker{opts: NewOptions(opts...)}
+	return b
+}
+
+func (b *NoopBroker) Name() string {
+	return b.opts.Name
+}
+
+func (b *NoopBroker) String() string {
+	return "noop"
+}
+
+func (b *NoopBroker) Options() Options {
+	return b.opts
+}
+
+func (b *NoopBroker) Init(opts ...Option) error {
+	for _, opt := range opts {
+		opt(&b.opts)
+	}
+	return nil
+}
+
+func (b *NoopBroker) Connect(_ context.Context) error {
+	return nil
+}
+
+func (b *NoopBroker) Disconnect(_ context.Context) error {
+	return nil
+}
+
+func (b *NoopBroker) Address() string {
+	return strings.Join(b.opts.Addrs, ",")
+}
+
+func (b *NoopBroker) BatchPublish(_ context.Context, _ []*Message, _ ...PublishOption) error {
+	return nil
+}
+
+func (b *NoopBroker) Publish(_ context.Context, _ string, _ *Message, _ ...PublishOption) error {
+	return nil
+}
+
+type NoopSubscriber struct {
+	ctx          context.Context
+	topic        string
+	handler      Handler
+	batchHandler BatchHandler
+	opts         SubscribeOptions
+}
+
+func (b *NoopBroker) BatchSubscribe(ctx context.Context, topic string, handler BatchHandler, opts ...SubscribeOption) (Subscriber, error) {
+	return &NoopSubscriber{ctx: ctx, topic: topic, opts: NewSubscribeOptions(opts...), batchHandler: handler}, nil
+}
+
+func (b *NoopBroker) Subscribe(ctx context.Context, topic string, handler Handler, opts ...SubscribeOption) (Subscriber, error) {
+	return &NoopSubscriber{ctx: ctx, topic: topic, opts: NewSubscribeOptions(opts...), handler: handler}, nil
+}
+
+func (s *NoopSubscriber) Options() SubscribeOptions {
+	return s.opts
+}
+
+func (s *NoopSubscriber) Topic() string {
+	return s.topic
+}
+
+func (s *NoopSubscriber) Unsubscribe(ctx context.Context) error {
+	return nil
+}

client/noop.go

@@ -3,6 +3,7 @@ package client
 import (
 	"context"
 	"fmt"
+	"os"
 	"time"
 
 	"go.unistack.org/micro/v3/broker"
@@ -485,21 +486,34 @@ func (n *noopClient) publish(ctx context.Context, ps []Message, opts ...PublishO
 
 	msgs := make([]*broker.Message, 0, len(ps))
 
+	// get proxy
+	exchange := ""
+	if v, ok := os.LookupEnv("MICRO_PROXY"); ok {
+		exchange = v
+	}
+	// get the exchange
+	if len(options.Exchange) > 0 {
+		exchange = options.Exchange
+	}
+
+	omd, ok := metadata.FromOutgoingContext(ctx)
+	if !ok {
+		omd = metadata.New(0)
+	}
+
 	for _, p := range ps {
-		md, ok := metadata.FromOutgoingContext(ctx)
-		if !ok {
-			md = metadata.New(0)
-		}
+		md := metadata.Copy(omd)
 		md[metadata.HeaderContentType] = p.ContentType()
-
 		topic := p.Topic()
-
-		// get the exchange
-		if len(options.Exchange) > 0 {
-			topic = options.Exchange
+		if len(exchange) > 0 {
+			topic = exchange
 		}
-
 		md[metadata.HeaderTopic] = topic
+		iter := p.Metadata().Iterator()
+		var k, v string
+		for iter.Next(&k, &v) {
+			md.Set(k, v)
+		}
 
 		var body []byte
 

config/config.go

@@ -13,7 +13,7 @@ type Validator interface {
 }
 
 // DefaultConfig default config
-var DefaultConfig = NewConfig()
+var DefaultConfig Config = NewConfig()
 
 // DefaultWatcherMinInterval default min interval for poll changes
 var DefaultWatcherMinInterval = 5 * time.Second

config/default.go

@@ -7,7 +7,9 @@ import (
 	"strings"
 	"time"
 
-	"github.com/imdario/mergo"
+	"dario.cat/mergo"
+	"github.com/google/uuid"
+	mid "go.unistack.org/micro/v3/util/id"
 	rutil "go.unistack.org/micro/v3/util/reflect"
 	mtime "go.unistack.org/micro/v3/util/time"
 )
@@ -37,6 +39,10 @@ func (c *defaultConfig) Init(opts ...Option) error {
 }
 
 func (c *defaultConfig) Load(ctx context.Context, opts ...LoadOption) error {
+	if c.opts.SkipLoad != nil && c.opts.SkipLoad(ctx, c) {
+		return nil
+	}
+
 	if err := DefaultBeforeLoad(ctx, c); err != nil && !c.opts.AllowFail {
 		return err
 	}
@@ -124,6 +130,20 @@ func fillValue(value reflect.Value, val string) error {
 		}
 		value.Set(reflect.ValueOf(v))
 	case reflect.String:
+		switch val {
+		case "micro:generate uuid":
+			uid, err := uuid.NewRandom()
+			if err != nil {
+				return err
+			}
+			val = uid.String()
+		case "micro:generate id":
+			uid, err := mid.New()
+			if err != nil {
+				return err
+			}
+			val = uid
+		}
 		value.Set(reflect.ValueOf(val))
 	case reflect.Float32:
 		v, err := strconv.ParseFloat(val, 32)
@@ -275,7 +295,11 @@ func fillValues(valueOf reflect.Value, tname string) error {
 	return nil
 }
 
-func (c *defaultConfig) Save(ctx context.Context, opts ...SaveOption) error {
+func (c *defaultConfig) Save(ctx context.Context, _ ...SaveOption) error {
+	if c.opts.SkipSave != nil && c.opts.SkipSave(ctx, c) {
+		return nil
+	}
+
 	if err := DefaultBeforeSave(ctx, c); err != nil {
 		return err
 	}

config/default_test.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"go.unistack.org/micro/v3/config"
+	mid "go.unistack.org/micro/v3/util/id"
 	mtime "go.unistack.org/micro/v3/util/time"
 )
 
@@ -14,9 +15,12 @@ type cfg struct {
 	StringValue    string `default:"string_value"`
 	IgnoreValue    string `json:"-"`
 	StructValue    *cfgStructValue
-	IntValue       int            `default:"99"`
-	DurationValue  time.Duration  `default:"10s"`
-	MDurationValue mtime.Duration `default:"10s"`
+	IntValue       int             `default:"99"`
+	DurationValue  time.Duration   `default:"10s"`
+	MDurationValue mtime.Duration  `default:"10s"`
+	MapValue       map[string]bool `default:"key1=true,key2=false"`
+	UUIDValue      string          `default:"micro:generate uuid"`
+	IDValue        string          `default:"micro:generate id"`
 }
 
 type cfgStructValue struct {
@@ -67,6 +71,21 @@ func TestDefault(t *testing.T) {
 	if conf.StringValue != "after_load" {
 		t.Fatal("AfterLoad option not working")
 	}
+	if len(conf.MapValue) != 2 {
+		t.Fatalf("map value invalid: %#+v\n", conf.MapValue)
+	}
+
+	if conf.UUIDValue == "" {
+		t.Fatalf("uuid value empty")
+	} else if len(conf.UUIDValue) != 36 {
+		t.Fatalf("uuid value invalid: %s", conf.UUIDValue)
+	}
+
+	if conf.IDValue == "" {
+		t.Fatalf("id value empty")
+	} else if len(conf.IDValue) != mid.DefaultSize {
+		t.Fatalf("id value invalid: %s", conf.IDValue)
+	}
 	_ = conf
 	// t.Logf("%#+v\n", conf)
 }

config/options.go

@@ -42,6 +42,10 @@ type Options struct {
 	AfterInit []func(context.Context, Config) error
 	// AllowFail flag to allow fail in config source
 	AllowFail bool
+	// SkipLoad runs only if condition returns true
+	SkipLoad func(context.Context, Config) bool
+	// SkipSave runs only if condition returns true
+	SkipSave func(context.Context, Config) bool
 }
 
 // Option function signature
@@ -68,9 +72,9 @@ type LoadOption func(o *LoadOptions)
 // LoadOptions struct
 type LoadOptions struct {
 	Struct   interface{}
+	Context  context.Context
 	Override bool
 	Append   bool
-	Context  context.Context
 }
 
 // NewLoadOptions create LoadOptions struct with provided opts

database/dsn.go

@@ -0,0 +1,157 @@
+package database
+
+import (
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"net/url"
+	"strings"
+)
+
+var (
+	ErrInvalidDSNAddr      = errors.New("invalid dsn addr")
+	ErrInvalidDSNUnescaped = errors.New("dsn must be escaped")
+	ErrInvalidDSNNoSlash   = errors.New("dsn must contains slash")
+)
+
+type Config struct {
+	TLSConfig *tls.Config
+	Username  string
+	Password  string
+	Scheme    string
+	Host      string
+	Port      string
+	Database  string
+	Params    []string
+}
+
+func (cfg *Config) FormatDSN() string {
+	var s strings.Builder
+
+	if len(cfg.Scheme) > 0 {
+		s.WriteString(cfg.Scheme + "://")
+	}
+	// [username[:password]@]
+	if len(cfg.Username) > 0 {
+		s.WriteString(cfg.Username)
+		if len(cfg.Password) > 0 {
+			s.WriteByte(':')
+			s.WriteString(url.PathEscape(cfg.Password))
+		}
+		s.WriteByte('@')
+	}
+
+	// [host:port]
+	if len(cfg.Host) > 0 {
+		s.WriteString(cfg.Host)
+		if len(cfg.Port) > 0 {
+			s.WriteByte(':')
+			s.WriteString(cfg.Port)
+		}
+	}
+
+	// /dbname
+	s.WriteByte('/')
+	s.WriteString(url.PathEscape(cfg.Database))
+
+	for i := 0; i < len(cfg.Params); i += 2 {
+		if i == 0 {
+			s.WriteString("?")
+		} else {
+			s.WriteString("&")
+		}
+		s.WriteString(cfg.Params[i])
+		s.WriteString("=")
+		s.WriteString(cfg.Params[i+1])
+	}
+
+	return s.String()
+}
+
+func ParseDSN(dsn string) (*Config, error) {
+	cfg := &Config{}
+
+	// [user[:password]@][net[(addr)]]/dbname[?param1=value1&paramN=valueN]
+	// Find last '/' that goes before dbname
+	foundSlash := false
+	for i := len(dsn) - 1; i >= 0; i-- {
+		if dsn[i] == '/' {
+			foundSlash = true
+			var j, k int
+
+			// left part is empty if i <= 0
+			if i > 0 {
+				// Find the first ':' in dsn
+				for j = i; j >= 0; j-- {
+					if dsn[j] == ':' {
+						cfg.Scheme = dsn[0:j]
+					}
+				}
+
+				// [username[:password]@][host]
+				// Find the last '@' in dsn[:i]
+				for j = i; j >= 0; j-- {
+					if dsn[j] == '@' {
+						// username[:password]
+						// Find the second ':' in dsn[:j]
+						for k = 0; k < j; k++ {
+							if dsn[k] == ':' {
+								if cfg.Scheme == dsn[:k] {
+									continue
+								}
+								var err error
+								cfg.Password, err = url.PathUnescape(dsn[k+1 : j])
+								if err != nil {
+									return nil, err
+								}
+								break
+							}
+						}
+						cfg.Username = dsn[len(cfg.Scheme)+3 : k]
+						break
+					}
+				}
+
+				for k = j + 1; k < i; k++ {
+					if dsn[k] == ':' {
+						cfg.Host = dsn[j+1 : k]
+						cfg.Port = dsn[k+1 : i]
+						break
+					}
+				}
+
+			}
+
+			// dbname[?param1=value1&...&paramN=valueN]
+			// Find the first '?' in dsn[i+1:]
+			for j = i + 1; j < len(dsn); j++ {
+				if dsn[j] == '?' {
+					parts := strings.Split(dsn[j+1:], "&")
+					cfg.Params = make([]string, 0, len(parts)*2)
+					for _, p := range parts {
+						k, v, found := strings.Cut(p, "=")
+						if !found {
+							continue
+						}
+						cfg.Params = append(cfg.Params, k, v)
+					}
+
+					break
+				}
+			}
+			var err error
+			dbname := dsn[i+1 : j]
+			if cfg.Database, err = url.PathUnescape(dbname); err != nil {
+				return nil, fmt.Errorf("invalid dbname %q: %w", dbname, err)
+			}
+
+			break
+		}
+	}
+
+	if !foundSlash && len(dsn) > 0 {
+		return nil, ErrInvalidDSNNoSlash
+	}
+
+	return cfg, nil
+}

database/dsn_test.go

@@ -0,0 +1,31 @@
+package database
+
+import (
+	"net/url"
+	"testing"
+)
+
+func TestParseDSN(t *testing.T) {
+	cfg, err := ParseDSN("postgres://username:p@ssword#@host:12345/dbname?key1=val2&key2=val2")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if cfg.Password != "p@ssword#" {
+		t.Fatalf("parsing error")
+	}
+}
+
+func TestFormatDSN(t *testing.T) {
+	src := "postgres://username:p@ssword#@host:12345/dbname?key1=val2&key2=val2"
+	cfg, err := ParseDSN(src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	dst, err := url.PathUnescape(cfg.FormatDSN())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if src != dst {
+		t.Fatalf("\n%s\n%s", src, dst)
+	}
+}

errors/errors.go

@@ -4,11 +4,17 @@ package errors // import "go.unistack.org/micro/v3/errors"
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
+	"io"
 	"net/http"
 	"strconv"
 	"strings"
+
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 )
 
 var (
@@ -340,3 +346,135 @@ func addslashes(str string) string {
 	}
 	return buf.String()
 }
+
+type retryableError struct {
+	err error
+}
+
+// Retryable returns error that can be retried later
+func Retryable(err error) error {
+	return &retryableError{err: err}
+}
+
+type IsRetryableFunc func(error) bool
+
+var (
+	RetrayableOracleErrors = []IsRetryableFunc{
+		func(err error) bool {
+			errmsg := err.Error()
+			switch {
+			case strings.Contains(errmsg, `ORA-`):
+				return true
+			case strings.Contains(errmsg, `can not assign`):
+				return true
+			case strings.Contains(errmsg, `can't assign`):
+				return true
+			}
+			return false
+		},
+	}
+	RetrayablePostgresErrors = []IsRetryableFunc{
+		func(err error) bool {
+			errmsg := err.Error()
+			switch {
+			case strings.Contains(errmsg, `number of field descriptions must equal number of`):
+				return true
+			case strings.Contains(errmsg, `not a pointer`):
+				return true
+			case strings.Contains(errmsg, `values, but dst struct has only`):
+				return true
+			case strings.Contains(errmsg, `struct doesn't have corresponding row field`):
+				return true
+			case strings.Contains(errmsg, `cannot find field`):
+				return true
+			case strings.Contains(errmsg, `cannot scan`) || strings.Contains(errmsg, `cannot convert`):
+				return true
+			case strings.Contains(errmsg, `failed to connect to`):
+				return true
+			}
+			return false
+		},
+	}
+	RetryableMicroErrors = []IsRetryableFunc{
+		func(err error) bool {
+			switch verr := err.(type) {
+			case *Error:
+				switch verr.Code {
+				case 401, 403, 408, 500, 501, 502, 503, 504:
+					return true
+				default:
+					return false
+				}
+			case *retryableError:
+				return true
+			}
+			return false
+		},
+	}
+	RetryableGoErrors = []IsRetryableFunc{
+		func(err error) bool {
+			switch verr := err.(type) {
+			case interface{ SafeToRetry() bool }:
+				return verr.SafeToRetry()
+			case interface{ Timeout() bool }:
+				return verr.Timeout()
+			}
+			switch {
+			case errors.Is(err, io.EOF), errors.Is(err, io.ErrUnexpectedEOF):
+				return true
+			case errors.Is(err, context.DeadlineExceeded):
+				return true
+			case errors.Is(err, io.ErrClosedPipe), errors.Is(err, io.ErrShortBuffer), errors.Is(err, io.ErrShortWrite):
+				return true
+			}
+			return false
+		},
+	}
+	RetryableGrpcErrors = []IsRetryableFunc{
+		func(err error) bool {
+			st, ok := status.FromError(err)
+			if !ok {
+				return false
+			}
+			switch st.Code() {
+			case codes.Unavailable, codes.ResourceExhausted:
+				return true
+			case codes.DeadlineExceeded:
+				return true
+			case codes.Internal:
+				switch {
+				case strings.Contains(st.Message(), `transport: received the unexpected content-type "text/html; charset=UTF-8"`):
+					return true
+				case strings.Contains(st.Message(), io.ErrUnexpectedEOF.Error()):
+					return true
+				case strings.Contains(st.Message(), `stream terminated by RST_STREAM with error code: INTERNAL_ERROR`):
+					return true
+				}
+			}
+			return false
+		},
+	}
+)
+
+// Unwrap provides error wrapping
+func (e *retryableError) Unwrap() error {
+	return e.err
+}
+
+// Error returns the error string
+func (e *retryableError) Error() string {
+	if e.err == nil {
+		return ""
+	}
+	return e.err.Error()
+}
+
+// IsRetryable checks error for ability to retry later
+func IsRetryable(err error, fns ...IsRetryableFunc) bool {
+	for _, fn := range fns {
+		if ok := fn(err); ok {
+			return true
+		}
+	}
+	return false
+}

errors/errors_test.go

@@ -8,6 +8,13 @@ import (
 	"testing"
 )
 
+func TestIsRetrayable(t *testing.T) {
+	err := fmt.Errorf("ORA-")
+	if !IsRetryable(err, RetrayableOracleErrors...) {
+		t.Fatalf("IsRetrayable not works")
+	}
+}
+
 func TestMarshalJSON(t *testing.T) {
 	e := InternalServerError("id", "err: %v", fmt.Errorf("err: %v", `xxx: "UNIX_TIMESTAMP": invalid identifier`))
 	_, err := json.Marshal(e)

go.mod

@@ -1,9 +1,20 @@
 module go.unistack.org/micro/v3
 
-go 1.19
+go 1.20
 
 require (
-	github.com/imdario/mergo v0.3.14
+	dario.cat/mergo v1.0.0
+	github.com/DATA-DOG/go-sqlmock v1.5.0
+	github.com/google/uuid v1.3.0
 	github.com/patrickmn/go-cache v2.1.0+incompatible
-	github.com/silas/dag v0.0.0-20211117232152-9d50aa809f35
+	github.com/silas/dag v0.0.0-20220518035006-a7e85ada93c5
+	golang.org/x/sync v0.3.0
+	google.golang.org/grpc v1.57.0
+	google.golang.org/protobuf v1.31.0
+)
+
+require (
+	github.com/golang/protobuf v1.5.3 // indirect
+	golang.org/x/net v0.14.0 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20230526203410-71b5a4ffd15e // indirect
 )

go.sum

@@ -1,9 +1,33 @@
-github.com/imdario/mergo v0.3.14 h1:fOqeC1+nCuuk6PKQdg9YmosXX7Y7mHX6R/0ZldI9iHo=
-github.com/imdario/mergo v0.3.14/go.mod h1:WBLT9ZmE3lPoWsEzCh9LPo3TiwVN+ZKEjmz+hD27ysY=
+dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk=
+dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
+github.com/DATA-DOG/go-sqlmock v1.5.0 h1:Shsta01QNfFxHCfpW6YH2STWB0MudeXXEWMr20OEh60=
+github.com/DATA-DOG/go-sqlmock v1.5.0/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
+github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
+github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaRUnok+kx1WdO15EQc=
 github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ=
-github.com/silas/dag v0.0.0-20211117232152-9d50aa809f35 h1:4mohWoM/UGg1BvFFiqSPRl5uwJY3rVV0HQX0ETqauqQ=
-github.com/silas/dag v0.0.0-20211117232152-9d50aa809f35/go.mod h1:7RTUFBdIRC9nZ7/3RyRNH1bdqIShrDejd1YbLwgPS+I=
+github.com/silas/dag v0.0.0-20220518035006-a7e85ada93c5 h1:G/FZtUu7a6NTWl3KUHMV9jkLAh/Rvtf03NWMHaEDl+E=
+github.com/silas/dag v0.0.0-20220518035006-a7e85ada93c5/go.mod h1:7RTUFBdIRC9nZ7/3RyRNH1bdqIShrDejd1YbLwgPS+I=
+golang.org/x/net v0.14.0 h1:BONx9s002vGdD9umnlX1Po8vOZmrgH34qlHcD1MfK14=
+golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI=
+golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
+golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
+golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=
+golang.org/x/text v0.12.0 h1:k+n5B8goJNdU7hSvEtMUz3d1Q6D/XW4COJSJR6fN0mc=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20230526203410-71b5a4ffd15e h1:NumxXLPfHSndr3wBBdeKiVHjGVFzi9RX2HwwQke94iY=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20230526203410-71b5a4ffd15e/go.mod h1:66JfowdXAEgad5O9NnYcsNPLCPZJD++2L9X0PCMODrA=
+google.golang.org/grpc v1.57.0 h1:kfzNeI/klCGD2YPMUlaGNT3pxvYfga7smW3Vth8Zsiw=
+google.golang.org/grpc v1.57.0/go.mod h1:Sd+9RMTACXwmub0zcNY2c4arhtrbBYD1AUHI/dt16Mo=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
+google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

logger/default.go

@@ -1,230 +0,0 @@
-package logger
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"os"
-	"runtime"
-	"strings"
-	"sync"
-	"time"
-)
-
-type defaultLogger struct {
-	enc  *json.Encoder
-	opts Options
-	sync.RWMutex
-}
-
-// Init(opts...) should only overwrite provided options
-func (l *defaultLogger) Init(opts ...Option) error {
-	l.Lock()
-	for _, o := range opts {
-		o(&l.opts)
-	}
-	l.enc = json.NewEncoder(l.opts.Out)
-	// wrap the Log func
-	l.Unlock()
-	return nil
-}
-
-func (l *defaultLogger) String() string {
-	return "micro"
-}
-
-func (l *defaultLogger) Clone(opts ...Option) Logger {
-	newopts := NewOptions(opts...)
-	oldopts := l.opts
-	for _, o := range opts {
-		o(&newopts)
-		o(&oldopts)
-	}
-
-	l.Lock()
-	cl := &defaultLogger{opts: oldopts, enc: json.NewEncoder(l.opts.Out)}
-	l.Unlock()
-
-	return cl
-}
-
-func (l *defaultLogger) V(level Level) bool {
-	l.RLock()
-	ok := l.opts.Level.Enabled(level)
-	l.RUnlock()
-	return ok
-}
-
-func (l *defaultLogger) Level(level Level) {
-	l.Lock()
-	l.opts.Level = level
-	l.Unlock()
-}
-
-func (l *defaultLogger) Fields(fields ...interface{}) Logger {
-	l.RLock()
-	nl := &defaultLogger{opts: l.opts, enc: l.enc}
-	if len(fields) == 0 {
-		l.RUnlock()
-		return nl
-	} else if len(fields)%2 != 0 {
-		fields = fields[:len(fields)-1]
-	}
-	nl.opts.Fields = copyFields(l.opts.Fields)
-	nl.opts.Fields = append(nl.opts.Fields, fields...)
-	l.RUnlock()
-	return nl
-}
-
-func copyFields(src []interface{}) []interface{} {
-	dst := make([]interface{}, len(src))
-	copy(dst, src)
-	return dst
-}
-
-// logCallerfilePath returns a package/file:line description of the caller,
-// preserving only the leaf directory name and file name.
-func logCallerfilePath(loggingFilePath string) string {
-	// To make sure we trim the path correctly on Windows too, we
-	// counter-intuitively need to use '/' and *not* os.PathSeparator here,
-	// because the path given originates from Go stdlib, specifically
-	// runtime.Caller() which (as of Mar/17) returns forward slashes even on
-	// Windows.
-	//
-	// See https://github.com/golang/go/issues/3335
-	// and https://github.com/golang/go/issues/18151
-	//
-	// for discussion on the issue on Go side.
-	idx := strings.LastIndexByte(loggingFilePath, '/')
-	if idx == -1 {
-		return loggingFilePath
-	}
-	idx = strings.LastIndexByte(loggingFilePath[:idx], '/')
-	if idx == -1 {
-		return loggingFilePath
-	}
-	return loggingFilePath[idx+1:]
-}
-
-func (l *defaultLogger) Info(ctx context.Context, args ...interface{}) {
-	l.Log(ctx, InfoLevel, args...)
-}
-
-func (l *defaultLogger) Error(ctx context.Context, args ...interface{}) {
-	l.Log(ctx, ErrorLevel, args...)
-}
-
-func (l *defaultLogger) Debug(ctx context.Context, args ...interface{}) {
-	l.Log(ctx, DebugLevel, args...)
-}
-
-func (l *defaultLogger) Warn(ctx context.Context, args ...interface{}) {
-	l.Log(ctx, WarnLevel, args...)
-}
-
-func (l *defaultLogger) Trace(ctx context.Context, args ...interface{}) {
-	l.Log(ctx, TraceLevel, args...)
-}
-
-func (l *defaultLogger) Fatal(ctx context.Context, args ...interface{}) {
-	l.Log(ctx, FatalLevel, args...)
-	os.Exit(1)
-}
-
-func (l *defaultLogger) Infof(ctx context.Context, msg string, args ...interface{}) {
-	l.Logf(ctx, InfoLevel, msg, args...)
-}
-
-func (l *defaultLogger) Errorf(ctx context.Context, msg string, args ...interface{}) {
-	l.Logf(ctx, ErrorLevel, msg, args...)
-}
-
-func (l *defaultLogger) Debugf(ctx context.Context, msg string, args ...interface{}) {
-	l.Logf(ctx, DebugLevel, msg, args...)
-}
-
-func (l *defaultLogger) Warnf(ctx context.Context, msg string, args ...interface{}) {
-	l.Logf(ctx, WarnLevel, msg, args...)
-}
-
-func (l *defaultLogger) Tracef(ctx context.Context, msg string, args ...interface{}) {
-	l.Logf(ctx, TraceLevel, msg, args...)
-}
-
-func (l *defaultLogger) Fatalf(ctx context.Context, msg string, args ...interface{}) {
-	l.Logf(ctx, FatalLevel, msg, args...)
-	os.Exit(1)
-}
-
-func (l *defaultLogger) Log(ctx context.Context, level Level, args ...interface{}) {
-	if !l.V(level) {
-		return
-	}
-
-	l.RLock()
-	fields := copyFields(l.opts.Fields)
-	l.RUnlock()
-
-	fields = append(fields, "level", level.String())
-
-	if _, file, line, ok := runtime.Caller(l.opts.CallerSkipCount); ok {
-		fields = append(fields, "caller", fmt.Sprintf("%s:%d", logCallerfilePath(file), line))
-	}
-	fields = append(fields, "timestamp", time.Now().Format("2006-01-02 15:04:05"))
-
-	if len(args) > 0 {
-		fields = append(fields, "msg", fmt.Sprint(args...))
-	}
-
-	out := make(map[string]interface{}, len(fields)/2)
-	for i := 0; i < len(fields); i += 2 {
-		out[fields[i].(string)] = fields[i+1]
-	}
-	l.RLock()
-	_ = l.enc.Encode(out)
-	l.RUnlock()
-}
-
-func (l *defaultLogger) Logf(ctx context.Context, level Level, msg string, args ...interface{}) {
-	if !l.V(level) {
-		return
-	}
-
-	l.RLock()
-	fields := copyFields(l.opts.Fields)
-	l.RUnlock()
-
-	fields = append(fields, "level", level.String())
-
-	if _, file, line, ok := runtime.Caller(l.opts.CallerSkipCount); ok {
-		fields = append(fields, "caller", fmt.Sprintf("%s:%d", logCallerfilePath(file), line))
-	}
-
-	fields = append(fields, "timestamp", time.Now().Format("2006-01-02 15:04:05"))
-	if len(args) > 0 {
-		fields = append(fields, "msg", fmt.Sprintf(msg, args...))
-	} else if msg != "" {
-		fields = append(fields, "msg", msg)
-	}
-
-	out := make(map[string]interface{}, len(fields)/2)
-	for i := 0; i < len(fields); i += 2 {
-		out[fields[i].(string)] = fields[i+1]
-	}
-	l.RLock()
-	_ = l.enc.Encode(out)
-	l.RUnlock()
-}
-
-func (l *defaultLogger) Options() Options {
-	return l.opts
-}
-
-// NewLogger builds a new logger based on options
-func NewLogger(opts ...Option) Logger {
-	l := &defaultLogger{
-		opts: NewOptions(opts...),
-	}
-	l.enc = json.NewEncoder(l.opts.Out)
-	return l
-}

logger/logger.go

@@ -3,12 +3,15 @@ package logger // import "go.unistack.org/micro/v3/logger"
 
 import (
 	"context"
-	"os"
 )
 
+type ContextAttrFunc func(ctx context.Context) []interface{}
+
+var DefaultContextAttrFuncs []ContextAttrFunc
+
 var (
 	// DefaultLogger variable
-	DefaultLogger = NewLogger(WithLevel(ParseLevel(os.Getenv("MICRO_LOG_LEVEL"))))
+	DefaultLogger Logger = NewLogger()
 	// DefaultLevel used by logger
 	DefaultLevel = InfoLevel
 	// DefaultCallerSkipCount used by logger
@@ -57,7 +60,9 @@ type Logger interface {
 	Log(ctx context.Context, level Level, args ...interface{})
 	// Logf logs message with needed level
 	Logf(ctx context.Context, level Level, msg string, args ...interface{})
-	// String returns the name of logger
+	// Name returns broker instance name
+	Name() string
+	// String returns the type of logger
 	String() string
 }
 
@@ -65,76 +70,106 @@ type Logger interface {
 type Field interface{}
 
 // Info writes msg to default logger on info level
+//
+// Deprecated: Dont use logger methods directly, use instance of logger to avoid additional allocations
 func Info(ctx context.Context, args ...interface{}) {
-	DefaultLogger.Info(ctx, args...)
+	DefaultLogger.Clone(WithCallerSkipCount(DefaultCallerSkipCount+1)).Info(ctx, args...)
 }
 
 // Error writes msg to default logger on error level
+//
+// Deprecated: Dont use logger methods directly, use instance of logger to avoid additional allocations
 func Error(ctx context.Context, args ...interface{}) {
-	DefaultLogger.Error(ctx, args...)
+	DefaultLogger.Clone(WithCallerSkipCount(DefaultCallerSkipCount+1)).Error(ctx, args...)
 }
 
 // Debug writes msg to default logger on debug level
+//
+// Deprecated: Dont use logger methods directly, use instance of logger to avoid additional allocations
 func Debug(ctx context.Context, args ...interface{}) {
-	DefaultLogger.Debug(ctx, args...)
+	DefaultLogger.Clone(WithCallerSkipCount(DefaultCallerSkipCount+1)).Debug(ctx, args...)
 }
 
 // Warn writes msg to default logger on warn level
+//
+// Deprecated: Dont use logger methods directly, use instance of logger to avoid additional allocations
 func Warn(ctx context.Context, args ...interface{}) {
-	DefaultLogger.Warn(ctx, args...)
+	DefaultLogger.Clone(WithCallerSkipCount(DefaultCallerSkipCount+1)).Warn(ctx, args...)
 }
 
 // Trace writes msg to default logger on trace level
+//
+// Deprecated: Dont use logger methods directly, use instance of logger to avoid additional allocations
 func Trace(ctx context.Context, args ...interface{}) {
-	DefaultLogger.Trace(ctx, args...)
+	DefaultLogger.Clone(WithCallerSkipCount(DefaultCallerSkipCount+1)).Trace(ctx, args...)
 }
 
 // Fatal writes msg to default logger on fatal level
+//
+// Deprecated: Dont use logger methods directly, use instance of logger to avoid additional allocations
 func Fatal(ctx context.Context, args ...interface{}) {
-	DefaultLogger.Fatal(ctx, args...)
+	DefaultLogger.Clone(WithCallerSkipCount(DefaultCallerSkipCount+1)).Fatal(ctx, args...)
 }
 
 // Infof writes formatted msg to default logger on info level
+//
+// Deprecated: Dont use logger methods directly, use instance of logger to avoid additional allocations
 func Infof(ctx context.Context, msg string, args ...interface{}) {
-	DefaultLogger.Infof(ctx, msg, args...)
+	DefaultLogger.Clone(WithCallerSkipCount(DefaultCallerSkipCount+1)).Infof(ctx, msg, args...)
 }
 
 // Errorf writes formatted msg to default logger on error level
+//
+// Deprecated: Dont use logger methods directly, use instance of logger to avoid additional allocations
 func Errorf(ctx context.Context, msg string, args ...interface{}) {
-	DefaultLogger.Errorf(ctx, msg, args...)
+	DefaultLogger.Clone(WithCallerSkipCount(DefaultCallerSkipCount+1)).Errorf(ctx, msg, args...)
 }
 
 // Debugf writes formatted msg to default logger on debug level
+//
+// Deprecated: Dont use logger methods directly, use instance of logger to avoid additional allocations
 func Debugf(ctx context.Context, msg string, args ...interface{}) {
-	DefaultLogger.Debugf(ctx, msg, args...)
+	DefaultLogger.Clone(WithCallerSkipCount(DefaultCallerSkipCount+1)).Debugf(ctx, msg, args...)
 }
 
 // Warnf writes formatted msg to default logger on warn level
+//
+// Deprecated: Dont use logger methods directly, use instance of logger to avoid additional allocations
 func Warnf(ctx context.Context, msg string, args ...interface{}) {
-	DefaultLogger.Warnf(ctx, msg, args...)
+	DefaultLogger.Clone(WithCallerSkipCount(DefaultCallerSkipCount+1)).Warnf(ctx, msg, args...)
 }
 
 // Tracef writes formatted msg to default logger on trace level
+//
+// Deprecated: Dont use logger methods directly, use instance of logger to avoid additional allocations
 func Tracef(ctx context.Context, msg string, args ...interface{}) {
-	DefaultLogger.Tracef(ctx, msg, args...)
+	DefaultLogger.Clone(WithCallerSkipCount(DefaultCallerSkipCount+1)).Tracef(ctx, msg, args...)
 }
 
 // Fatalf writes formatted msg to default logger on fatal level
+//
+// Deprecated: Dont use logger methods directly, use instance of logger to avoid additional allocations
 func Fatalf(ctx context.Context, msg string, args ...interface{}) {
-	DefaultLogger.Fatalf(ctx, msg, args...)
+	DefaultLogger.Clone(WithCallerSkipCount(DefaultCallerSkipCount+1)).Fatalf(ctx, msg, args...)
 }
 
 // V returns true if passed level enabled in default logger
+//
+// Deprecated: Dont use logger methods directly, use instance of logger to avoid additional allocations
 func V(level Level) bool {
 	return DefaultLogger.V(level)
 }
 
 // Init initialize logger
+//
+// Deprecated: Dont use logger methods directly, use instance of logger to avoid additional allocations
 func Init(opts ...Option) error {
 	return DefaultLogger.Init(opts...)
 }
 
 // Fields create logger with specific fields
+//
+// Deprecated: Dont use logger methods directly, use instance of logger to avoid additional allocations
 func Fields(fields ...interface{}) Logger {
 	return DefaultLogger.Fields(fields...)
 }

logger/logger_test.go

@@ -1,138 +0,0 @@
-package logger
-
-import (
-	"bytes"
-	"context"
-	"log"
-	"testing"
-)
-
-func TestContext(t *testing.T) {
-	ctx := context.TODO()
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-
-	nl, ok := FromContext(NewContext(ctx, l.Fields("key", "val")))
-	if !ok {
-		t.Fatal("context without logger")
-	}
-	nl.Info(ctx, "message")
-	if !bytes.Contains(buf.Bytes(), []byte(`"key":"val"`)) {
-		t.Fatalf("logger fields not works, buf contains: %s", buf.Bytes())
-	}
-}
-
-func TestFields(t *testing.T) {
-	ctx := context.TODO()
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-
-	nl := l.Fields("key", "val")
-
-	nl.Info(ctx, "message")
-	if !bytes.Contains(buf.Bytes(), []byte(`"key":"val"`)) {
-		t.Fatalf("logger fields not works, buf contains: %s", buf.Bytes())
-	}
-}
-
-func TestFromContextWithFields(t *testing.T) {
-	ctx := context.TODO()
-	buf := bytes.NewBuffer(nil)
-	var ok bool
-	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-	nl := l.Fields("key", "val")
-
-	ctx = NewContext(ctx, nl)
-
-	l, ok = FromContext(ctx)
-	if !ok {
-		t.Fatalf("context does not have logger")
-	}
-
-	l.Info(ctx, "message")
-	if !bytes.Contains(buf.Bytes(), []byte(`"key":"val"`)) {
-		t.Fatalf("logger fields not works, buf contains: %s", buf.Bytes())
-	}
-}
-
-func TestClone(t *testing.T) {
-	ctx := context.TODO()
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-	nl := l.Clone(WithLevel(ErrorLevel))
-	if err := nl.Init(); err != nil {
-		t.Fatal(err)
-	}
-	nl.Info(ctx, "info message")
-	if len(buf.Bytes()) != 0 {
-		t.Fatal("message must not be logged")
-	}
-	l.Info(ctx, "info message")
-	if len(buf.Bytes()) == 0 {
-		t.Fatal("message must be logged")
-	}
-}
-
-func TestRedirectStdLogger(t *testing.T) {
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-	fn := RedirectStdLogger(l, ErrorLevel)
-	defer fn()
-	log.Print("test")
-	if !bytes.Contains(buf.Bytes(), []byte(`"level":"error","msg":"test","timestamp"`)) {
-		t.Fatalf("logger error, buf %s", buf.Bytes())
-	}
-}
-
-func TestStdLogger(t *testing.T) {
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-	lg := NewStdLogger(l, ErrorLevel)
-	lg.Print("test")
-	if !bytes.Contains(buf.Bytes(), []byte(`"level":"error","msg":"test","timestamp"`)) {
-		t.Fatalf("logger error, buf %s", buf.Bytes())
-	}
-}
-
-func TestLogger(t *testing.T) {
-	ctx := context.TODO()
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-	l.Trace(ctx, "trace_msg1")
-	l.Warn(ctx, "warn_msg1")
-	l.Fields("error", "test").Info(ctx, "error message")
-	l.Warn(ctx, "first", " ", "second")
-	if !bytes.Contains(buf.Bytes(), []byte(`"level":"trace","msg":"trace_msg1"`)) {
-		t.Fatalf("logger error, buf %s", buf.Bytes())
-	}
-	if !bytes.Contains(buf.Bytes(), []byte(`"warn","msg":"warn_msg1"`)) {
-		t.Fatalf("logger error, buf %s", buf.Bytes())
-	}
-	if !bytes.Contains(buf.Bytes(), []byte(`"error":"test","level":"info","msg":"error message"`)) {
-		t.Fatalf("logger error, buf %s", buf.Bytes())
-	}
-	if !bytes.Contains(buf.Bytes(), []byte(`"level":"warn","msg":"first second"`)) {
-		t.Fatalf("logger error, buf %s", buf.Bytes())
-	}
-}

logger/noop.go

@@ -0,0 +1,94 @@
+package logger
+
+import (
+	"context"
+)
+
+type noopLogger struct {
+	opts Options
+}
+
+func NewLogger(opts ...Option) Logger {
+	options := NewOptions(opts...)
+	return &noopLogger{opts: options}
+}
+
+func (l *noopLogger) V(_ Level) bool {
+	return false
+}
+
+func (l *noopLogger) Level(_ Level) {
+}
+
+func (l *noopLogger) Name() string {
+	return l.opts.Name
+}
+
+func (l *noopLogger) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(&l.opts)
+	}
+	return nil
+}
+
+func (l *noopLogger) Clone(opts ...Option) Logger {
+	nl := &noopLogger{opts: l.opts}
+	for _, o := range opts {
+		o(&nl.opts)
+	}
+	return nl
+}
+
+func (l *noopLogger) Fields(_ ...interface{}) Logger {
+	return l
+}
+
+func (l *noopLogger) Options() Options {
+	return l.opts
+}
+
+func (l *noopLogger) String() string {
+	return "noop"
+}
+
+func (l *noopLogger) Log(ctx context.Context, lvl Level, attrs ...interface{}) {
+}
+
+func (l *noopLogger) Info(ctx context.Context, attrs ...interface{}) {
+}
+
+func (l *noopLogger) Debug(ctx context.Context, attrs ...interface{}) {
+}
+
+func (l *noopLogger) Error(ctx context.Context, attrs ...interface{}) {
+}
+
+func (l *noopLogger) Trace(ctx context.Context, attrs ...interface{}) {
+}
+
+func (l *noopLogger) Warn(ctx context.Context, attrs ...interface{}) {
+}
+
+func (l *noopLogger) Fatal(ctx context.Context, attrs ...interface{}) {
+}
+
+func (l *noopLogger) Logf(ctx context.Context, lvl Level, msg string, attrs ...interface{}) {
+}
+
+func (l *noopLogger) Infof(ctx context.Context, msg string, attrs ...interface{}) {
+}
+
+func (l *noopLogger) Debugf(ctx context.Context, msg string, attrs ...interface{}) {
+}
+
+func (l *noopLogger) Errorf(ctx context.Context, msg string, attrs ...interface{}) {
+}
+
+func (l *noopLogger) Tracef(ctx context.Context, msg string, attrs ...interface{}) {
+}
+
+func (l *noopLogger) Warnf(ctx context.Context, msg string, attrs ...interface{}) {
+}
+
+func (l *noopLogger) Fatalf(ctx context.Context, msg string, attrs ...interface{}) {
+}

logger/options.go

@@ -3,10 +3,11 @@ package logger
 import (
 	"context"
 	"io"
+	"log/slog"
 	"os"
 )
 
-// Option func
+// Option func signature
 type Option func(*Options)
 
 // Options holds logger options
@@ -15,31 +16,63 @@ type Options struct {
 	Out io.Writer
 	// Context holds exernal options
 	Context context.Context
-	// Fields holds additional metadata
-	Fields []interface{}
 	// Name holds the logger name
 	Name string
-	// The logging level the logger should log
-	Level Level
+	// Fields holds additional metadata
+	Fields []interface{}
+
 	// CallerSkipCount number of frmaes to skip
 	CallerSkipCount int
+	// ContextAttrFuncs contains funcs that executed before log func on context
+	ContextAttrFuncs []ContextAttrFunc
+	// TimeKey is the key used for the time of the log call
+	TimeKey string
+	// LevelKey is the key used for the level of the log call
+	LevelKey string
+	// ErroreKey is the key used for the error of the log call
+	ErrorKey string
+	// MessageKey is the key used for the message of the log call
+	MessageKey string
+	// SourceKey is the key used for the source file and line of the log call
+	SourceKey string
+	// StacktraceKey is the key used for the stacktrace
+	StacktraceKey string
+	// AddStacktrace controls writing of stacktaces on error
+	AddStacktrace bool
+	// AddSource enabled writing source file and position in log
+	AddSource bool
+	// The logging level the logger should log
+	Level Level
 }
 
 // NewOptions creates new options struct
 func NewOptions(opts ...Option) Options {
 	options := Options{
-		Level:           DefaultLevel,
-		Fields:          make([]interface{}, 0, 6),
-		Out:             os.Stderr,
-		CallerSkipCount: DefaultCallerSkipCount,
-		Context:         context.Background(),
+		Level:            DefaultLevel,
+		Fields:           make([]interface{}, 0, 6),
+		Out:              os.Stderr,
+		CallerSkipCount:  DefaultCallerSkipCount,
+		Context:          context.Background(),
+		ContextAttrFuncs: DefaultContextAttrFuncs,
+		AddSource:        true,
 	}
+
+	WithMicroKeys()(&options)
+
 	for _, o := range opts {
 		o(&options)
 	}
+
 	return options
 }
 
+// WithContextAttrFuncs appends default funcs for the context arrts filler
+func WithContextAttrFuncs(fncs ...ContextAttrFunc) Option {
+	return func(o *Options) {
+		o.ContextAttrFuncs = append(o.ContextAttrFuncs, fncs...)
+	}
+}
+
 // WithFields set default fields for the logger
 func WithFields(fields ...interface{}) Option {
 	return func(o *Options) {
@@ -61,6 +94,20 @@ func WithOutput(out io.Writer) Option {
 	}
 }
 
+// WitAddStacktrace controls writing stacktrace on error
+func WithAddStacktrace(v bool) Option {
+	return func(o *Options) {
+		o.AddStacktrace = v
+	}
+}
+
+// WitAddSource controls writing source file and pos in log
+func WithAddSource(v bool) Option {
+	return func(o *Options) {
+		o.AddSource = v
+	}
+}
+
 // WithCallerSkipCount set frame count to skip
 func WithCallerSkipCount(c int) Option {
 	return func(o *Options) {
@@ -81,3 +128,47 @@ func WithName(n string) Option {
 		o.Name = n
 	}
 }
+
+func WithZapKeys() Option {
+	return func(o *Options) {
+		o.TimeKey = "@timestamp"
+		o.LevelKey = "level"
+		o.MessageKey = "msg"
+		o.SourceKey = "caller"
+		o.StacktraceKey = "stacktrace"
+		o.ErrorKey = "error"
+	}
+}
+
+func WithZerologKeys() Option {
+	return func(o *Options) {
+		o.TimeKey = "time"
+		o.LevelKey = "level"
+		o.MessageKey = "message"
+		o.SourceKey = "caller"
+		o.StacktraceKey = "stacktrace"
+		o.ErrorKey = "error"
+	}
+}
+
+func WithSlogKeys() Option {
+	return func(o *Options) {
+		o.TimeKey = slog.TimeKey
+		o.LevelKey = slog.LevelKey
+		o.MessageKey = slog.MessageKey
+		o.SourceKey = slog.SourceKey
+		o.StacktraceKey = "stacktrace"
+		o.ErrorKey = "error"
+	}
+}
+
+func WithMicroKeys() Option {
+	return func(o *Options) {
+		o.TimeKey = "timestamp"
+		o.LevelKey = "level"
+		o.MessageKey = "msg"
+		o.SourceKey = "caller"
+		o.StacktraceKey = "stacktrace"
+		o.ErrorKey = "error"
+	}
+}

logger/slog/slog.go

@@ -0,0 +1,572 @@
+package slog
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"os"
+	"regexp"
+	"runtime"
+	"strconv"
+	"sync"
+	"time"
+
+	"go.unistack.org/micro/v3/logger"
+	"go.unistack.org/micro/v3/tracer"
+)
+
+var reTrace = regexp.MustCompile(`.*/slog/logger\.go.*\n`)
+
+var (
+	traceValue = slog.StringValue("trace")
+	debugValue = slog.StringValue("debug")
+	infoValue  = slog.StringValue("info")
+	warnValue  = slog.StringValue("warn")
+	errorValue = slog.StringValue("error")
+	fatalValue = slog.StringValue("fatal")
+)
+
+func (s *slogLogger) renameAttr(_ []string, a slog.Attr) slog.Attr {
+	switch a.Key {
+	case slog.SourceKey:
+		source := a.Value.Any().(*slog.Source)
+		a.Value = slog.StringValue(source.File + ":" + strconv.Itoa(source.Line))
+		a.Key = s.opts.SourceKey
+	case slog.TimeKey:
+		a.Key = s.opts.TimeKey
+	case slog.MessageKey:
+		a.Key = s.opts.MessageKey
+	case slog.LevelKey:
+		level := a.Value.Any().(slog.Level)
+		lvl := slogToLoggerLevel(level)
+		a.Key = s.opts.LevelKey
+		switch {
+		case lvl < logger.DebugLevel:
+			a.Value = traceValue
+		case lvl < logger.InfoLevel:
+			a.Value = debugValue
+		case lvl < logger.WarnLevel:
+			a.Value = infoValue
+		case lvl < logger.ErrorLevel:
+			a.Value = warnValue
+		case lvl < logger.FatalLevel:
+			a.Value = errorValue
+		case lvl >= logger.FatalLevel:
+			a.Value = fatalValue
+		default:
+			a.Value = infoValue
+		}
+	}
+
+	return a
+}
+
+type slogLogger struct {
+	slog    *slog.Logger
+	leveler *slog.LevelVar
+	opts    logger.Options
+	mu      sync.RWMutex
+}
+
+func (s *slogLogger) Clone(opts ...logger.Option) logger.Logger {
+	s.mu.RLock()
+	options := s.opts
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	l := &slogLogger{
+		opts: options,
+	}
+
+	l.leveler = new(slog.LevelVar)
+	handleOpt := &slog.HandlerOptions{
+		ReplaceAttr: l.renameAttr,
+		Level:       l.leveler,
+		AddSource:   l.opts.AddSource,
+	}
+	l.leveler.Set(loggerToSlogLevel(l.opts.Level))
+	handler := slog.NewJSONHandler(options.Out, handleOpt)
+	l.slog = slog.New(handler).With(options.Fields...)
+
+	s.mu.RUnlock()
+
+	return l
+}
+
+func (s *slogLogger) V(level logger.Level) bool {
+	return s.opts.Level.Enabled(level)
+}
+
+func (s *slogLogger) Level(level logger.Level) {
+	s.leveler.Set(loggerToSlogLevel(level))
+}
+
+func (s *slogLogger) Options() logger.Options {
+	return s.opts
+}
+
+func (s *slogLogger) Fields(attrs ...interface{}) logger.Logger {
+	s.mu.RLock()
+	l := &slogLogger{opts: s.opts}
+	l.leveler = new(slog.LevelVar)
+	l.leveler.Set(s.leveler.Level())
+
+	handleOpt := &slog.HandlerOptions{
+		ReplaceAttr: l.renameAttr,
+		Level:       l.leveler,
+		AddSource:   l.opts.AddSource,
+	}
+
+	handler := slog.NewJSONHandler(s.opts.Out, handleOpt)
+	l.slog = slog.New(handler).With(attrs...)
+
+	s.mu.RUnlock()
+
+	return l
+}
+
+func (s *slogLogger) Init(opts ...logger.Option) error {
+	s.mu.Lock()
+
+	if len(s.opts.ContextAttrFuncs) == 0 {
+		s.opts.ContextAttrFuncs = logger.DefaultContextAttrFuncs
+	}
+
+	for _, o := range opts {
+		o(&s.opts)
+	}
+
+	s.leveler = new(slog.LevelVar)
+	handleOpt := &slog.HandlerOptions{
+		ReplaceAttr: s.renameAttr,
+		Level:       s.leveler,
+		AddSource:   s.opts.AddSource,
+	}
+	s.leveler.Set(loggerToSlogLevel(s.opts.Level))
+	handler := slog.NewJSONHandler(s.opts.Out, handleOpt)
+	s.slog = slog.New(handler).With(s.opts.Fields...)
+
+	s.mu.Unlock()
+
+	return nil
+}
+
+func (s *slogLogger) Log(ctx context.Context, lvl logger.Level, attrs ...interface{}) {
+	if !s.V(lvl) {
+		return
+	}
+	var pcs [1]uintptr
+	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
+	r := slog.NewRecord(time.Now(), loggerToSlogLevel(lvl), fmt.Sprintf("%s", attrs[0]), pcs[0])
+	for _, fn := range s.opts.ContextAttrFuncs {
+		attrs = append(attrs, fn(ctx)...)
+	}
+
+	for idx, attr := range attrs {
+		if ve, ok := attr.(error); ok && ve != nil {
+			attrs[idx] = slog.String(s.opts.ErrorKey, ve.Error())
+			break
+		}
+	}
+	if s.opts.AddStacktrace && lvl == logger.ErrorLevel {
+		stackInfo := make([]byte, 1024*1024)
+		if stackSize := runtime.Stack(stackInfo, false); stackSize > 0 {
+			traceLines := reTrace.Split(string(stackInfo[:stackSize]), -1)
+			if len(traceLines) != 0 {
+				attrs = append(attrs, slog.String(s.opts.StacktraceKey, traceLines[len(traceLines)-1]))
+			}
+		}
+	}
+	r.Add(attrs[1:]...)
+	r.Attrs(func(a slog.Attr) bool {
+		if a.Key == s.opts.ErrorKey {
+			if span, ok := tracer.SpanFromContext(ctx); ok {
+				span.SetStatus(tracer.SpanStatusError, a.Value.String())
+				return false
+			}
+		}
+		return true
+	})
+	_ = s.slog.Handler().Handle(ctx, r)
+}
+
+func (s *slogLogger) Logf(ctx context.Context, lvl logger.Level, msg string, attrs ...interface{}) {
+	if !s.V(lvl) {
+		return
+	}
+	var pcs [1]uintptr
+	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
+	r := slog.NewRecord(time.Now(), loggerToSlogLevel(lvl), msg, pcs[0])
+	for _, fn := range s.opts.ContextAttrFuncs {
+		attrs = append(attrs, fn(ctx)...)
+	}
+
+	for idx, attr := range attrs {
+		if ve, ok := attr.(error); ok && ve != nil {
+			attrs[idx] = slog.String(s.opts.ErrorKey, ve.Error())
+			break
+		}
+	}
+	if s.opts.AddStacktrace && lvl == logger.ErrorLevel {
+		stackInfo := make([]byte, 1024*1024)
+		if stackSize := runtime.Stack(stackInfo, false); stackSize > 0 {
+			traceLines := reTrace.Split(string(stackInfo[:stackSize]), -1)
+			if len(traceLines) != 0 {
+				attrs = append(attrs, (slog.String(s.opts.StacktraceKey, traceLines[len(traceLines)-1])))
+			}
+		}
+	}
+	r.Add(attrs[1:]...)
+	r.Attrs(func(a slog.Attr) bool {
+		if a.Key == s.opts.ErrorKey {
+			if span, ok := tracer.SpanFromContext(ctx); ok {
+				span.SetStatus(tracer.SpanStatusError, a.Value.String())
+				return false
+			}
+		}
+		return true
+	})
+	_ = s.slog.Handler().Handle(ctx, r)
+}
+
+func (s *slogLogger) Info(ctx context.Context, attrs ...interface{}) {
+	if !s.V(logger.InfoLevel) {
+		return
+	}
+	var pcs [1]uintptr
+	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
+	r := slog.NewRecord(time.Now(), slog.LevelInfo, fmt.Sprintf("%s", attrs[0]), pcs[0])
+	for _, fn := range s.opts.ContextAttrFuncs {
+		attrs = append(attrs, fn(ctx)...)
+	}
+
+	for idx, attr := range attrs {
+		if ve, ok := attr.(error); ok && ve != nil {
+			attrs[idx] = slog.String(s.opts.ErrorKey, ve.Error())
+			break
+		}
+	}
+	r.Add(attrs[1:]...)
+	_ = s.slog.Handler().Handle(ctx, r)
+}
+
+func (s *slogLogger) Infof(ctx context.Context, msg string, attrs ...interface{}) {
+	if !s.V(logger.InfoLevel) {
+		return
+	}
+	var pcs [1]uintptr
+	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
+	r := slog.NewRecord(time.Now(), slog.LevelInfo, msg, pcs[0])
+	for _, fn := range s.opts.ContextAttrFuncs {
+		attrs = append(attrs, fn(ctx)...)
+	}
+
+	for idx, attr := range attrs {
+		if ve, ok := attr.(error); ok && ve != nil {
+			attrs[idx] = slog.String(s.opts.ErrorKey, ve.Error())
+			break
+		}
+	}
+	r.Add(attrs...)
+	_ = s.slog.Handler().Handle(ctx, r)
+}
+
+func (s *slogLogger) Debug(ctx context.Context, attrs ...interface{}) {
+	if !s.V(logger.DebugLevel) {
+		return
+	}
+	var pcs [1]uintptr
+	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
+	r := slog.NewRecord(time.Now(), slog.LevelDebug, fmt.Sprintf("%s", attrs[0]), pcs[0])
+	for _, fn := range s.opts.ContextAttrFuncs {
+		attrs = append(attrs, fn(ctx)...)
+	}
+
+	for idx, attr := range attrs {
+		if ve, ok := attr.(error); ok && ve != nil {
+			attrs[idx] = slog.String(s.opts.ErrorKey, ve.Error())
+			break
+		}
+	}
+	r.Add(attrs[1:]...)
+	_ = s.slog.Handler().Handle(ctx, r)
+}
+
+func (s *slogLogger) Debugf(ctx context.Context, msg string, attrs ...interface{}) {
+	if !s.V(logger.DebugLevel) {
+		return
+	}
+	var pcs [1]uintptr
+	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
+	r := slog.NewRecord(time.Now(), slog.LevelDebug, msg, pcs[0])
+	for _, fn := range s.opts.ContextAttrFuncs {
+		attrs = append(attrs, fn(ctx)...)
+	}
+
+	for idx, attr := range attrs {
+		if ve, ok := attr.(error); ok && ve != nil {
+			attrs[idx] = slog.String(s.opts.ErrorKey, ve.Error())
+			break
+		}
+	}
+	r.Add(attrs...)
+	_ = s.slog.Handler().Handle(ctx, r)
+}
+
+func (s *slogLogger) Trace(ctx context.Context, attrs ...interface{}) {
+	if !s.V(logger.TraceLevel) {
+		return
+	}
+	var pcs [1]uintptr
+	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
+	r := slog.NewRecord(time.Now(), slog.LevelDebug-1, fmt.Sprintf("%s", attrs[0]), pcs[0])
+	for _, fn := range s.opts.ContextAttrFuncs {
+		attrs = append(attrs, fn(ctx)...)
+	}
+
+	for idx, attr := range attrs {
+		if ve, ok := attr.(error); ok && ve != nil {
+			attrs[idx] = slog.String(s.opts.ErrorKey, ve.Error())
+			break
+		}
+	}
+	r.Add(attrs[1:]...)
+	_ = s.slog.Handler().Handle(ctx, r)
+}
+
+func (s *slogLogger) Tracef(ctx context.Context, msg string, attrs ...interface{}) {
+	if !s.V(logger.TraceLevel) {
+		return
+	}
+	var pcs [1]uintptr
+	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
+	r := slog.NewRecord(time.Now(), slog.LevelDebug-1, msg, pcs[0])
+	for _, fn := range s.opts.ContextAttrFuncs {
+		attrs = append(attrs, fn(ctx)...)
+	}
+
+	for idx, attr := range attrs {
+		if ve, ok := attr.(error); ok && ve != nil {
+			attrs[idx] = slog.String(s.opts.ErrorKey, ve.Error())
+			break
+		}
+	}
+	r.Add(attrs[1:]...)
+	_ = s.slog.Handler().Handle(ctx, r)
+}
+
+func (s *slogLogger) Error(ctx context.Context, attrs ...interface{}) {
+	if !s.V(logger.ErrorLevel) {
+		return
+	}
+	var pcs [1]uintptr
+	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
+	r := slog.NewRecord(time.Now(), slog.LevelError, fmt.Sprintf("%s", attrs[0]), pcs[0])
+	for _, fn := range s.opts.ContextAttrFuncs {
+		attrs = append(attrs, fn(ctx)...)
+	}
+
+	for idx, attr := range attrs {
+		if ve, ok := attr.(error); ok && ve != nil {
+			attrs[idx] = slog.String(s.opts.ErrorKey, ve.Error())
+			break
+		}
+	}
+	if s.opts.AddStacktrace {
+		stackInfo := make([]byte, 1024*1024)
+		if stackSize := runtime.Stack(stackInfo, false); stackSize > 0 {
+			traceLines := reTrace.Split(string(stackInfo[:stackSize]), -1)
+			if len(traceLines) != 0 {
+				attrs = append(attrs, slog.String("stacktrace", traceLines[len(traceLines)-1]))
+			}
+		}
+	}
+	r.Add(attrs[1:]...)
+	r.Attrs(func(a slog.Attr) bool {
+		if a.Key == s.opts.ErrorKey {
+			if span, ok := tracer.SpanFromContext(ctx); ok {
+				span.SetStatus(tracer.SpanStatusError, a.Value.String())
+				return false
+			}
+		}
+		return true
+	})
+	_ = s.slog.Handler().Handle(ctx, r)
+}
+
+func (s *slogLogger) Errorf(ctx context.Context, msg string, attrs ...interface{}) {
+	if !s.V(logger.ErrorLevel) {
+		return
+	}
+	var pcs [1]uintptr
+	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
+	r := slog.NewRecord(time.Now(), slog.LevelError, msg, pcs[0])
+	for _, fn := range s.opts.ContextAttrFuncs {
+		attrs = append(attrs, fn(ctx)...)
+	}
+
+	for idx, attr := range attrs {
+		if ve, ok := attr.(error); ok && ve != nil {
+			attrs[idx] = slog.String(s.opts.ErrorKey, ve.Error())
+			break
+		}
+	}
+	if s.opts.AddStacktrace {
+		stackInfo := make([]byte, 1024*1024)
+		if stackSize := runtime.Stack(stackInfo, false); stackSize > 0 {
+			traceLines := reTrace.Split(string(stackInfo[:stackSize]), -1)
+			if len(traceLines) != 0 {
+				attrs = append(attrs, slog.String("stacktrace", traceLines[len(traceLines)-1]))
+			}
+		}
+	}
+	r.Add(attrs...)
+	r.Attrs(func(a slog.Attr) bool {
+		if a.Key == s.opts.ErrorKey {
+			if span, ok := tracer.SpanFromContext(ctx); ok {
+				span.SetStatus(tracer.SpanStatusError, a.Value.String())
+				return false
+			}
+		}
+		return true
+	})
+	_ = s.slog.Handler().Handle(ctx, r)
+}
+
+func (s *slogLogger) Fatal(ctx context.Context, attrs ...interface{}) {
+	if !s.V(logger.FatalLevel) {
+		return
+	}
+	var pcs [1]uintptr
+	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
+	r := slog.NewRecord(time.Now(), slog.LevelError+1, fmt.Sprintf("%s", attrs[0]), pcs[0])
+	for _, fn := range s.opts.ContextAttrFuncs {
+		attrs = append(attrs, fn(ctx)...)
+	}
+
+	for idx, attr := range attrs {
+		if ve, ok := attr.(error); ok && ve != nil {
+			attrs[idx] = slog.String(s.opts.ErrorKey, ve.Error())
+			break
+		}
+	}
+	r.Add(attrs[1:]...)
+	_ = s.slog.Handler().Handle(ctx, r)
+	os.Exit(1)
+}
+
+func (s *slogLogger) Fatalf(ctx context.Context, msg string, attrs ...interface{}) {
+	if !s.V(logger.FatalLevel) {
+		return
+	}
+	var pcs [1]uintptr
+	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
+	r := slog.NewRecord(time.Now(), slog.LevelError+1, msg, pcs[0])
+	for _, fn := range s.opts.ContextAttrFuncs {
+		attrs = append(attrs, fn(ctx)...)
+	}
+
+	for idx, attr := range attrs {
+		if ve, ok := attr.(error); ok && ve != nil {
+			attrs[idx] = slog.String(s.opts.ErrorKey, ve.Error())
+			break
+		}
+	}
+	r.Add(attrs...)
+	_ = s.slog.Handler().Handle(ctx, r)
+	os.Exit(1)
+}
+
+func (s *slogLogger) Warn(ctx context.Context, attrs ...interface{}) {
+	if !s.V(logger.WarnLevel) {
+		return
+	}
+	var pcs [1]uintptr
+	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
+	r := slog.NewRecord(time.Now(), slog.LevelWarn, fmt.Sprintf("%s", attrs[0]), pcs[0])
+	for _, fn := range s.opts.ContextAttrFuncs {
+		attrs = append(attrs, fn(ctx)...)
+	}
+
+	for idx, attr := range attrs {
+		if ve, ok := attr.(error); ok && ve != nil {
+			attrs[idx] = slog.String(s.opts.ErrorKey, ve.Error())
+			break
+		}
+	}
+	r.Add(attrs[1:]...)
+	_ = s.slog.Handler().Handle(ctx, r)
+}
+
+func (s *slogLogger) Warnf(ctx context.Context, msg string, attrs ...interface{}) {
+	if !s.V(logger.WarnLevel) {
+		return
+	}
+	var pcs [1]uintptr
+	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
+	r := slog.NewRecord(time.Now(), slog.LevelWarn, msg, pcs[0])
+	for _, fn := range s.opts.ContextAttrFuncs {
+		attrs = append(attrs, fn(ctx)...)
+	}
+
+	for idx, attr := range attrs {
+		if ve, ok := attr.(error); ok && ve != nil {
+			attrs[idx] = slog.String(s.opts.ErrorKey, ve.Error())
+			break
+		}
+	}
+	r.Add(attrs[1:]...)
+	_ = s.slog.Handler().Handle(ctx, r)
+}
+
+func (s *slogLogger) Name() string {
+	return s.opts.Name
+}
+
+func (s *slogLogger) String() string {
+	return "slog"
+}
+
+func NewLogger(opts ...logger.Option) logger.Logger {
+	s := &slogLogger{
+		opts: logger.NewOptions(opts...),
+	}
+
+	return s
+}
+
+func loggerToSlogLevel(level logger.Level) slog.Level {
+	switch level {
+	case logger.DebugLevel:
+		return slog.LevelDebug
+	case logger.WarnLevel:
+		return slog.LevelWarn
+	case logger.ErrorLevel:
+		return slog.LevelError
+	case logger.TraceLevel:
+		return slog.LevelDebug - 1
+	case logger.FatalLevel:
+		return slog.LevelError + 1
+	default:
+		return slog.LevelInfo
+	}
+}
+
+func slogToLoggerLevel(level slog.Level) logger.Level {
+	switch level {
+	case slog.LevelDebug:
+		return logger.DebugLevel
+	case slog.LevelWarn:
+		return logger.WarnLevel
+	case slog.LevelError:
+		return logger.ErrorLevel
+	case slog.LevelDebug - 1:
+		return logger.TraceLevel
+	case slog.LevelError + 1:
+		return logger.FatalLevel
+	default:
+		return logger.InfoLevel
+	}
+}

logger/slog/slog_test.go

@@ -0,0 +1,176 @@
+package slog
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"log"
+	"testing"
+
+	"go.unistack.org/micro/v3/logger"
+)
+
+func TestError(t *testing.T) {
+	ctx := context.TODO()
+	buf := bytes.NewBuffer(nil)
+	l := NewLogger(logger.WithLevel(logger.ErrorLevel), logger.WithOutput(buf), logger.WithStacktrace(true))
+	if err := l.Init(); err != nil {
+		t.Fatal(err)
+	}
+
+	l.Error(ctx, "message", fmt.Errorf("error message"))
+	if !bytes.Contains(buf.Bytes(), []byte(`"stacktrace":"`)) {
+		t.Fatalf("logger stacktrace not works, buf contains: %s", buf.Bytes())
+	}
+	if !bytes.Contains(buf.Bytes(), []byte(`"error":"`)) {
+		t.Fatalf("logger error not works, buf contains: %s", buf.Bytes())
+	}
+}
+
+func TestErrorf(t *testing.T) {
+	ctx := context.TODO()
+	buf := bytes.NewBuffer(nil)
+	l := NewLogger(logger.WithLevel(logger.ErrorLevel), logger.WithOutput(buf), logger.WithStacktrace(true))
+	if err := l.Init(); err != nil {
+		t.Fatal(err)
+	}
+
+	l.Errorf(ctx, "message", fmt.Errorf("error message"))
+	if !bytes.Contains(buf.Bytes(), []byte(`"stacktrace":"`)) {
+		t.Fatalf("logger stacktrace not works, buf contains: %s", buf.Bytes())
+	}
+	if !bytes.Contains(buf.Bytes(), []byte(`"error":"`)) {
+		t.Fatalf("logger error not works, buf contains: %s", buf.Bytes())
+	}
+}
+
+func TestContext(t *testing.T) {
+	ctx := context.TODO()
+	buf := bytes.NewBuffer(nil)
+	l := NewLogger(logger.WithLevel(logger.TraceLevel), logger.WithOutput(buf))
+	if err := l.Init(); err != nil {
+		t.Fatal(err)
+	}
+
+	nl, ok := logger.FromContext(logger.NewContext(ctx, l.Fields("key", "val")))
+	if !ok {
+		t.Fatal("context without logger")
+	}
+	nl.Info(ctx, "message")
+	if !bytes.Contains(buf.Bytes(), []byte(`"key":"val"`)) {
+		t.Fatalf("logger fields not works, buf contains: %s", buf.Bytes())
+	}
+}
+
+func TestFields(t *testing.T) {
+	ctx := context.TODO()
+	buf := bytes.NewBuffer(nil)
+	l := NewLogger(logger.WithLevel(logger.TraceLevel), logger.WithOutput(buf))
+	if err := l.Init(); err != nil {
+		t.Fatal(err)
+	}
+
+	nl := l.Fields("key", "val")
+
+	nl.Info(ctx, "message")
+	if !bytes.Contains(buf.Bytes(), []byte(`"key":"val"`)) {
+		t.Fatalf("logger fields not works, buf contains: %s", buf.Bytes())
+	}
+}
+
+func TestFromContextWithFields(t *testing.T) {
+	ctx := context.TODO()
+	buf := bytes.NewBuffer(nil)
+	var ok bool
+	l := NewLogger(logger.WithLevel(logger.TraceLevel), logger.WithOutput(buf))
+	if err := l.Init(); err != nil {
+		t.Fatal(err)
+	}
+	nl := l.Fields("key", "val")
+
+	ctx = logger.NewContext(ctx, nl)
+
+	l, ok = logger.FromContext(ctx)
+	if !ok {
+		t.Fatalf("context does not have logger")
+	}
+
+	l.Info(ctx, "message")
+	if !bytes.Contains(buf.Bytes(), []byte(`"key":"val"`)) {
+		t.Fatalf("logger fields not works, buf contains: %s", buf.Bytes())
+	}
+}
+
+func TestClone(t *testing.T) {
+	ctx := context.TODO()
+	buf := bytes.NewBuffer(nil)
+	l := NewLogger(logger.WithLevel(logger.TraceLevel), logger.WithOutput(buf))
+	if err := l.Init(); err != nil {
+		t.Fatal(err)
+	}
+	nl := l.Clone(logger.WithLevel(logger.ErrorLevel))
+	if err := nl.Init(); err != nil {
+		t.Fatal(err)
+	}
+	nl.Info(ctx, "info message")
+	if len(buf.Bytes()) != 0 {
+		t.Fatal("message must not be logged")
+	}
+	l.Info(ctx, "info message")
+	if len(buf.Bytes()) == 0 {
+		t.Fatal("message must be logged")
+	}
+}
+
+func TestRedirectStdLogger(t *testing.T) {
+	buf := bytes.NewBuffer(nil)
+	l := NewLogger(logger.WithLevel(logger.ErrorLevel), logger.WithOutput(buf))
+	if err := l.Init(); err != nil {
+		t.Fatal(err)
+	}
+	fn := logger.RedirectStdLogger(l, logger.ErrorLevel)
+	defer fn()
+	log.Print("test")
+	if !(bytes.Contains(buf.Bytes(), []byte(`"level":"error"`)) && bytes.Contains(buf.Bytes(), []byte(`"msg":"test"`))) {
+		t.Fatalf("logger error, buf %s", buf.Bytes())
+	}
+}
+
+func TestStdLogger(t *testing.T) {
+	buf := bytes.NewBuffer(nil)
+	l := NewLogger(logger.WithLevel(logger.TraceLevel), logger.WithOutput(buf))
+	if err := l.Init(); err != nil {
+		t.Fatal(err)
+	}
+	lg := logger.NewStdLogger(l, logger.ErrorLevel)
+	lg.Print("test")
+	if !(bytes.Contains(buf.Bytes(), []byte(`"level":"error"`)) && bytes.Contains(buf.Bytes(), []byte(`"msg":"test"`))) {
+		t.Fatalf("logger error, buf %s", buf.Bytes())
+	}
+}
+
+func TestLogger(t *testing.T) {
+	ctx := context.TODO()
+	buf := bytes.NewBuffer(nil)
+	l := NewLogger(logger.WithLevel(logger.TraceLevel), logger.WithOutput(buf))
+	if err := l.Init(); err != nil {
+		t.Fatal(err)
+	}
+	l.Trace(ctx, "trace_msg1")
+	l.Warn(ctx, "warn_msg1")
+	l.Fields("error", "test").Info(ctx, "error message")
+	l.Warn(ctx, "first second")
+
+	if !(bytes.Contains(buf.Bytes(), []byte(`"level":"trace"`)) && bytes.Contains(buf.Bytes(), []byte(`"msg":"trace_msg1"`))) {
+		t.Fatalf("logger tracer, buf %s", buf.Bytes())
+	}
+	if !(bytes.Contains(buf.Bytes(), []byte(`"level":"warn"`)) && bytes.Contains(buf.Bytes(), []byte(`"msg":"warn_msg1"`))) {
+		t.Fatalf("logger warn, buf %s", buf.Bytes())
+	}
+	if !(bytes.Contains(buf.Bytes(), []byte(`"level":"info"`)) && bytes.Contains(buf.Bytes(), []byte(`"msg":"error message","error":"test"`))) {
+		t.Fatalf("logger info, buf %s", buf.Bytes())
+	}
+	if !(bytes.Contains(buf.Bytes(), []byte(`"level":"warn"`)) && bytes.Contains(buf.Bytes(), []byte(`"msg":"first second"`))) {
+		t.Fatalf("logger warn, buf %s", buf.Bytes())
+	}
+}

metadata/context.go

@@ -39,8 +39,6 @@ func FromOutgoingContext(ctx context.Context) (Metadata, bool) {
 
 // FromContext returns metadata from the given context
 // returned metadata shoud not be modified or race condition happens
-//
-// Deprecated: use FromIncomingContext or FromOutgoingContext
 func FromContext(ctx context.Context) (Metadata, bool) {
 	if ctx == nil {
 		return nil, false
@@ -53,8 +51,6 @@ func FromContext(ctx context.Context) (Metadata, bool) {
 }
 
 // NewContext creates a new context with the given metadata
-//
-// Deprecated: use NewIncomingContext or NewOutgoingContext
 func NewContext(ctx context.Context, md Metadata) context.Context {
 	if ctx == nil {
 		ctx = context.Background()

metadata/metadata.go

@@ -19,6 +19,8 @@ var (
 	HeaderTimeout = "Micro-Timeout"
 	// HeaderAuthorization specifies Authorization header
 	HeaderAuthorization = "Authorization"
+	// HeaderXRequestID specifies request id
+	HeaderXRequestID = "X-Request-Id"
 )
 
 // Metadata is our way of representing request headers internally.

meter/meter.go

@@ -1,5 +1,5 @@
 // Package meter is for instrumentation
-package meter // import "go.unistack.org/micro/v3/meter"
+package meter
 
 import (
 	"io"
@@ -11,7 +11,7 @@ import (
 
 var (
 	// DefaultMeter is the default meter
-	DefaultMeter = NewMeter()
+	DefaultMeter Meter = NewMeter()
 	// DefaultAddress data will be made available on this host:port
 	DefaultAddress = ":9090"
 	// DefaultPath the meter endpoint where the Meter data will be made available

micro.go

@@ -0,0 +1,94 @@
+package micro
+
+import (
+	"reflect"
+
+	"go.unistack.org/micro/v3/broker"
+	"go.unistack.org/micro/v3/client"
+	"go.unistack.org/micro/v3/codec"
+	"go.unistack.org/micro/v3/flow"
+	"go.unistack.org/micro/v3/fsm"
+	"go.unistack.org/micro/v3/logger"
+	"go.unistack.org/micro/v3/meter"
+	"go.unistack.org/micro/v3/register"
+	"go.unistack.org/micro/v3/resolver"
+	"go.unistack.org/micro/v3/router"
+	"go.unistack.org/micro/v3/selector"
+	"go.unistack.org/micro/v3/server"
+	"go.unistack.org/micro/v3/store"
+	"go.unistack.org/micro/v3/sync"
+	"go.unistack.org/micro/v3/tracer"
+)
+
+func As(b any, target any) bool {
+	if b == nil {
+		return false
+	}
+	if target == nil {
+		return false
+	}
+	val := reflect.ValueOf(target)
+	typ := val.Type()
+	if typ.Kind() != reflect.Ptr || val.IsNil() {
+		return false
+	}
+	targetType := typ.Elem()
+	if targetType.Kind() != reflect.Interface {
+		switch {
+		case targetType.Implements(brokerType):
+			break
+		case targetType.Implements(loggerType):
+			break
+		case targetType.Implements(clientType):
+			break
+		case targetType.Implements(serverType):
+			break
+		case targetType.Implements(codecType):
+			break
+		case targetType.Implements(flowType):
+			break
+		case targetType.Implements(fsmType):
+			break
+		case targetType.Implements(meterType):
+			break
+		case targetType.Implements(registerType):
+			break
+		case targetType.Implements(resolverType):
+			break
+		case targetType.Implements(selectorType):
+			break
+		case targetType.Implements(storeType):
+			break
+		case targetType.Implements(syncType):
+			break
+		case targetType.Implements(serviceType):
+			break
+		case targetType.Implements(routerType):
+			break
+		default:
+			return false
+		}
+	}
+	if reflect.TypeOf(b).AssignableTo(targetType) {
+		val.Elem().Set(reflect.ValueOf(b))
+		return true
+	}
+	return false
+}
+
+var brokerType = reflect.TypeOf((*broker.Broker)(nil)).Elem()
+var loggerType = reflect.TypeOf((*logger.Logger)(nil)).Elem()
+var clientType = reflect.TypeOf((*client.Client)(nil)).Elem()
+var serverType = reflect.TypeOf((*server.Server)(nil)).Elem()
+var codecType = reflect.TypeOf((*codec.Codec)(nil)).Elem()
+var flowType = reflect.TypeOf((*flow.Flow)(nil)).Elem()
+var fsmType = reflect.TypeOf((*fsm.FSM)(nil)).Elem()
+var meterType = reflect.TypeOf((*meter.Meter)(nil)).Elem()
+var registerType = reflect.TypeOf((*register.Register)(nil)).Elem()
+var resolverType = reflect.TypeOf((*resolver.Resolver)(nil)).Elem()
+var routerType = reflect.TypeOf((*router.Router)(nil)).Elem()
+var selectorType = reflect.TypeOf((*selector.Selector)(nil)).Elem()
+var storeType = reflect.TypeOf((*store.Store)(nil)).Elem()
+var syncType = reflect.TypeOf((*sync.Sync)(nil)).Elem()
+var tracerType = reflect.TypeOf((*tracer.Tracer)(nil)).Elem()
+var serviceType = reflect.TypeOf((*Service)(nil)).Elem()

micro_test.go

@@ -0,0 +1,115 @@
+package micro
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+	"testing"
+
+	"go.unistack.org/micro/v3/broker"
+	"go.unistack.org/micro/v3/fsm"
+)
+
+func TestAs(t *testing.T) {
+	var b *bro
+	broTarget := &bro{name: "kafka"}
+	fsmTarget := &fsmT{name: "fsm"}
+
+	testCases := []struct {
+		b      any
+		target any
+		match  bool
+		want   any
+	}{
+		{
+			broTarget,
+			&b,
+			true,
+			broTarget,
+		},
+		{
+			nil,
+			&b,
+			false,
+			nil,
+		},
+		{
+			fsmTarget,
+			&b,
+			false,
+			nil,
+		},
+	}
+	for i, tc := range testCases {
+		name := fmt.Sprintf("%d:As(Errorf(..., %v), %v)", i, tc.b, tc.target)
+		// Clear the target pointer, in case it was set in a previous test.
+		rtarget := reflect.ValueOf(tc.target)
+		rtarget.Elem().Set(reflect.Zero(reflect.TypeOf(tc.target).Elem()))
+		t.Run(name, func(t *testing.T) {
+			match := As(tc.b, tc.target)
+			if match != tc.match {
+				t.Fatalf("match: got %v; want %v", match, tc.match)
+			}
+			if !match {
+				return
+			}
+			if got := rtarget.Elem().Interface(); got != tc.want {
+				t.Fatalf("got %#v, want %#v", got, tc.want)
+			}
+		})
+	}
+}
+
+type bro struct {
+	name string
+}
+
+func (p *bro) Name() string { return p.name }
+
+func (p *bro) Init(opts ...broker.Option) error { return nil }
+
+// Options returns broker options
+func (p *bro) Options() broker.Options { return broker.Options{} }
+
+// Address return configured address
+func (p *bro) Address() string { return "" }
+
+// Connect connects to broker
+func (p *bro) Connect(ctx context.Context) error { return nil }
+
+// Disconnect disconnect from broker
+func (p *bro) Disconnect(ctx context.Context) error { return nil }
+
+// Publish message, msg can be single broker.Message or []broker.Message
+func (p *bro) Publish(ctx context.Context, topic string, msg *broker.Message, opts ...broker.PublishOption) error {
+	return nil
+}
+
+// BatchPublish messages to broker with multiple topics
+func (p *bro) BatchPublish(ctx context.Context, msgs []*broker.Message, opts ...broker.PublishOption) error {
+	return nil
+}
+
+// BatchSubscribe subscribes to topic messages via handler
+func (p *bro) BatchSubscribe(ctx context.Context, topic string, h broker.BatchHandler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
+	return nil, nil
+}
+
+// Subscribe subscribes to topic message via handler
+func (p *bro) Subscribe(ctx context.Context, topic string, handler broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
+	return nil, nil
+}
+
+// String type of broker
+func (p *bro) String() string { return p.name }
+
+type fsmT struct {
+	name string
+}
+
+func (f *fsmT) Start(ctx context.Context, a interface{}, o ...Option) (interface{}, error) {
+	return nil, nil
+}
+func (f *fsmT) Current() string                  { return f.name }
+func (f *fsmT) Reset()                           {}
+func (f *fsmT) State(s string, sf fsm.StateFunc) {}

register/memory/memory.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"go.unistack.org/micro/v3/logger"
+	"go.unistack.org/micro/v3/register"
 	"go.unistack.org/micro/v3/util/id"
 )
 
@@ -16,7 +17,7 @@ var (
 
 type node struct {
 	LastSeen time.Time
-	*Node
+	*register.Node
 	TTL time.Duration
 }
 
@@ -25,23 +26,23 @@ type record struct {
 	Version   string
 	Metadata  map[string]string
 	Nodes     map[string]*node
-	Endpoints []*Endpoint
+	Endpoints []*register.Endpoint
 }
 
 type memory struct {
 	sync.RWMutex
 	records  map[string]services
 	watchers map[string]*watcher
-	opts     Options
+	opts     register.Options
 }
 
 // services is a KV map with service name as the key and a map of records as the value
 type services map[string]map[string]*record
 
 // NewRegister returns an initialized in-memory register
-func NewRegister(opts ...Option) Register {
+func NewRegister(opts ...register.Option) register.Register {
 	r := &memory{
-		opts:     NewOptions(opts...),
+		opts:     register.NewOptions(opts...),
 		records:  make(map[string]services),
 		watchers: make(map[string]*watcher),
 	}
@@ -75,7 +76,7 @@ func (m *memory) ttlPrune() {
 	}
 }
 
-func (m *memory) sendEvent(r *Result) {
+func (m *memory) sendEvent(r *register.Result) {
 	m.RLock()
 	watchers := make([]*watcher, 0, len(m.watchers))
 	for _, w := range m.watchers {
@@ -106,7 +107,7 @@ func (m *memory) Disconnect(ctx context.Context) error {
 	return nil
 }
 
-func (m *memory) Init(opts ...Option) error {
+func (m *memory) Init(opts ...register.Option) error {
 	for _, o := range opts {
 		o(&m.opts)
 	}
@@ -118,15 +119,15 @@ func (m *memory) Init(opts ...Option) error {
 	return nil
 }
 
-func (m *memory) Options() Options {
+func (m *memory) Options() register.Options {
 	return m.opts
 }
 
-func (m *memory) Register(ctx context.Context, s *Service, opts ...RegisterOption) error {
+func (m *memory) Register(ctx context.Context, s *register.Service, opts ...register.RegisterOption) error {
 	m.Lock()
 	defer m.Unlock()
 
-	options := NewRegisterOptions(opts...)
+	options := register.NewRegisterOptions(opts...)
 
 	// get the services for this domain from the register
 	srvs, ok := m.records[options.Domain]
@@ -153,7 +154,7 @@ func (m *memory) Register(ctx context.Context, s *Service, opts ...RegisterOptio
 			m.opts.Logger.Debugf(m.opts.Context, "Register added new service: %s, version: %s", s.Name, s.Version)
 		}
 		m.records[options.Domain] = srvs
-		go m.sendEvent(&Result{Action: "create", Service: s})
+		go m.sendEvent(&register.Result{Action: "create", Service: s})
 	}
 
 	var addedNodes bool
@@ -176,7 +177,7 @@ func (m *memory) Register(ctx context.Context, s *Service, opts ...RegisterOptio
 
 		// add the node
 		srvs[s.Name][s.Version].Nodes[n.ID] = &node{
-			Node: &Node{
+			Node: &register.Node{
 				ID:       n.ID,
 				Address:  n.Address,
 				Metadata: metadata,
@@ -192,7 +193,7 @@ func (m *memory) Register(ctx context.Context, s *Service, opts ...RegisterOptio
 		if m.opts.Logger.V(logger.DebugLevel) {
 			m.opts.Logger.Debugf(m.opts.Context, "Register added new node to service: %s, version: %s", s.Name, s.Version)
 		}
-		go m.sendEvent(&Result{Action: "update", Service: s})
+		go m.sendEvent(&register.Result{Action: "update", Service: s})
 	} else {
 		// refresh TTL and timestamp
 		for _, n := range s.Nodes {
@@ -208,11 +209,11 @@ func (m *memory) Register(ctx context.Context, s *Service, opts ...RegisterOptio
 	return nil
 }
 
-func (m *memory) Deregister(ctx context.Context, s *Service, opts ...DeregisterOption) error {
+func (m *memory) Deregister(ctx context.Context, s *register.Service, opts ...register.DeregisterOption) error {
 	m.Lock()
 	defer m.Unlock()
 
-	options := NewDeregisterOptions(opts...)
+	options := register.NewDeregisterOptions(opts...)
 
 	// domain is set in metadata so it can be passed to watchers
 	if s.Metadata == nil {
@@ -252,7 +253,7 @@ func (m *memory) Deregister(ctx context.Context, s *Service, opts ...DeregisterO
 	// is cleanup
 	if len(version.Nodes) > 0 {
 		m.records[options.Domain][s.Name][s.Version] = version
-		go m.sendEvent(&Result{Action: "update", Service: s})
+		go m.sendEvent(&register.Result{Action: "update", Service: s})
 		return nil
 	}
 
@@ -260,7 +261,7 @@ func (m *memory) Deregister(ctx context.Context, s *Service, opts ...DeregisterO
 	// register and exit
 	if len(versions) == 1 {
 		delete(m.records[options.Domain], s.Name)
-		go m.sendEvent(&Result{Action: "delete", Service: s})
+		go m.sendEvent(&register.Result{Action: "delete", Service: s})
 
 		if m.opts.Logger.V(logger.DebugLevel) {
 			m.opts.Logger.Debugf(m.opts.Context, "Register removed service: %s", s.Name)
@@ -270,7 +271,7 @@ func (m *memory) Deregister(ctx context.Context, s *Service, opts ...DeregisterO
 
 	// there are other versions of the service running, so only remove this version of it
 	delete(m.records[options.Domain][s.Name], s.Version)
-	go m.sendEvent(&Result{Action: "delete", Service: s})
+	go m.sendEvent(&register.Result{Action: "delete", Service: s})
 	if m.opts.Logger.V(logger.DebugLevel) {
 		m.opts.Logger.Debugf(m.opts.Context, "Register removed service: %s, version: %s", s.Name, s.Version)
 	}
@@ -278,20 +279,20 @@ func (m *memory) Deregister(ctx context.Context, s *Service, opts ...DeregisterO
 	return nil
 }
 
-func (m *memory) LookupService(ctx context.Context, name string, opts ...LookupOption) ([]*Service, error) {
-	options := NewLookupOptions(opts...)
+func (m *memory) LookupService(ctx context.Context, name string, opts ...register.LookupOption) ([]*register.Service, error) {
+	options := register.NewLookupOptions(opts...)
 
 	// if it's a wildcard domain, return from all domains
-	if options.Domain == WildcardDomain {
+	if options.Domain == register.WildcardDomain {
 		m.RLock()
 		recs := m.records
 		m.RUnlock()
 
-		var services []*Service
+		var services []*register.Service
 
 		for domain := range recs {
-			srvs, err := m.LookupService(ctx, name, append(opts, LookupDomain(domain))...)
-			if err == ErrNotFound {
+			srvs, err := m.LookupService(ctx, name, append(opts, register.LookupDomain(domain))...)
+			if err == register.ErrNotFound {
 				continue
 			} else if err != nil {
 				return nil, err
@@ -300,7 +301,7 @@ func (m *memory) LookupService(ctx context.Context, name string, opts ...LookupO
 		}
 
 		if len(services) == 0 {
-			return nil, ErrNotFound
+			return nil, register.ErrNotFound
 		}
 		return services, nil
 	}
@@ -311,17 +312,17 @@ func (m *memory) LookupService(ctx context.Context, name string, opts ...LookupO
 	// check the domain exists
 	services, ok := m.records[options.Domain]
 	if !ok {
-		return nil, ErrNotFound
+		return nil, register.ErrNotFound
 	}
 
 	// check the service exists
 	versions, ok := services[name]
 	if !ok || len(versions) == 0 {
-		return nil, ErrNotFound
+		return nil, register.ErrNotFound
 	}
 
 	// serialize the response
-	result := make([]*Service, len(versions))
+	result := make([]*register.Service, len(versions))
 
 	var i int
 
@@ -333,19 +334,19 @@ func (m *memory) LookupService(ctx context.Context, name string, opts ...LookupO
 	return result, nil
 }
 
-func (m *memory) ListServices(ctx context.Context, opts ...ListOption) ([]*Service, error) {
-	options := NewListOptions(opts...)
+func (m *memory) ListServices(ctx context.Context, opts ...register.ListOption) ([]*register.Service, error) {
+	options := register.NewListOptions(opts...)
 
 	// if it's a wildcard domain, list from all domains
-	if options.Domain == WildcardDomain {
+	if options.Domain == register.WildcardDomain {
 		m.RLock()
 		recs := m.records
 		m.RUnlock()
 
-		var services []*Service
+		var services []*register.Service
 
 		for domain := range recs {
-			srvs, err := m.ListServices(ctx, append(opts, ListDomain(domain))...)
+			srvs, err := m.ListServices(ctx, append(opts, register.ListDomain(domain))...)
 			if err != nil {
 				return nil, err
 			}
@@ -361,11 +362,11 @@ func (m *memory) ListServices(ctx context.Context, opts ...ListOption) ([]*Servi
 	// ensure the domain exists
 	services, ok := m.records[options.Domain]
 	if !ok {
-		return make([]*Service, 0), nil
+		return make([]*register.Service, 0), nil
 	}
 
 	// serialize the result, each version counts as an individual service
-	var result []*Service
+	var result []*register.Service
 
 	for _, service := range services {
 		for _, version := range service {
@@ -376,16 +377,16 @@ func (m *memory) ListServices(ctx context.Context, opts ...ListOption) ([]*Servi
 	return result, nil
 }
 
-func (m *memory) Watch(ctx context.Context, opts ...WatchOption) (Watcher, error) {
+func (m *memory) Watch(ctx context.Context, opts ...register.WatchOption) (register.Watcher, error) {
 	id, err := id.New()
 	if err != nil {
 		return nil, err
 	}
-	wo := NewWatchOptions(opts...)
+	wo := register.NewWatchOptions(opts...)
 	// construct the watcher
 	w := &watcher{
 		exit: make(chan bool),
-		res:  make(chan *Result),
+		res:  make(chan *register.Result),
 		id:   id,
 		wo:   wo,
 	}
@@ -406,13 +407,13 @@ func (m *memory) String() string {
 }
 
 type watcher struct {
-	res  chan *Result
+	res  chan *register.Result
 	exit chan bool
-	wo   WatchOptions
+	wo   register.WatchOptions
 	id   string
 }
 
-func (m *watcher) Next() (*Result, error) {
+func (m *watcher) Next() (*register.Result, error) {
 	for {
 		select {
 		case r := <-m.res:
@@ -429,15 +430,15 @@ func (m *watcher) Next() (*Result, error) {
 			if r.Service.Metadata != nil && len(r.Service.Metadata["domain"]) > 0 {
 				domain = r.Service.Metadata["domain"]
 			} else {
-				domain = DefaultDomain
+				domain = register.DefaultDomain
 			}
 
 			// only send the event if watching the wildcard or this specific domain
-			if m.wo.Domain == WildcardDomain || m.wo.Domain == domain {
+			if m.wo.Domain == register.WildcardDomain || m.wo.Domain == domain {
 				return r, nil
 			}
 		case <-m.exit:
-			return nil, ErrWatcherStopped
+			return nil, register.ErrWatcherStopped
 		}
 	}
 }
@@ -451,7 +452,7 @@ func (m *watcher) Stop() {
 	}
 }
 
-func serviceToRecord(s *Service, ttl time.Duration) *record {
+func serviceToRecord(s *register.Service, ttl time.Duration) *record {
 	metadata := make(map[string]string, len(s.Metadata))
 	for k, v := range s.Metadata {
 		metadata[k] = v
@@ -466,7 +467,7 @@ func serviceToRecord(s *Service, ttl time.Duration) *record {
 		}
 	}
 
-	endpoints := make([]*Endpoint, len(s.Endpoints))
+	endpoints := make([]*register.Endpoint, len(s.Endpoints))
 	for i, e := range s.Endpoints {
 		endpoints[i] = e
 	}
@@ -480,7 +481,7 @@ func serviceToRecord(s *Service, ttl time.Duration) *record {
 	}
 }
 
-func recordToService(r *record, domain string) *Service {
+func recordToService(r *record, domain string) *register.Service {
 	metadata := make(map[string]string, len(r.Metadata))
 	for k, v := range r.Metadata {
 		metadata[k] = v
@@ -489,14 +490,14 @@ func recordToService(r *record, domain string) *Service {
 	// set the domain in metadata so it can be determined when a wildcard query is performed
 	metadata["domain"] = domain
 
-	endpoints := make([]*Endpoint, len(r.Endpoints))
+	endpoints := make([]*register.Endpoint, len(r.Endpoints))
 	for i, e := range r.Endpoints {
 		md := make(map[string]string, len(e.Metadata))
 		for k, v := range e.Metadata {
 			md[k] = v
 		}
 
-		endpoints[i] = &Endpoint{
+		endpoints[i] = &register.Endpoint{
 			Name:     e.Name,
 			Request:  e.Request,
 			Response: e.Response,
@@ -504,7 +505,7 @@ func recordToService(r *record, domain string) *Service {
 		}
 	}
 
-	nodes := make([]*Node, len(r.Nodes))
+	nodes := make([]*register.Node, len(r.Nodes))
 	i := 0
 	for _, n := range r.Nodes {
 		md := make(map[string]string, len(n.Metadata))
@@ -512,7 +513,7 @@ func recordToService(r *record, domain string) *Service {
 			md[k] = v
 		}
 
-		nodes[i] = &Node{
+		nodes[i] = &register.Node{
 			ID:       n.ID,
 			Address:  n.Address,
 			Metadata: md,
@@ -520,7 +521,7 @@ func recordToService(r *record, domain string) *Service {
 		i++
 	}
 
-	return &Service{
+	return &register.Service{
 		Name:      r.Name,
 		Version:   r.Version,
 		Metadata:  metadata,

register/memory/memory_test.go

@@ -6,14 +6,16 @@ import (
 	"sync"
 	"testing"
 	"time"
+
+	"go.unistack.org/micro/v3/register"
 )
 
-var testData = map[string][]*Service{
+var testData = map[string][]*register.Service{
 	"foo": {
 		{
 			Name:    "foo",
 			Version: "1.0.0",
-			Nodes: []*Node{
+			Nodes: []*register.Node{
 				{
 					ID:      "foo-1.0.0-123",
 					Address: "localhost:9999",
@@ -27,7 +29,7 @@ var testData = map[string][]*Service{
 		{
 			Name:    "foo",
 			Version: "1.0.1",
-			Nodes: []*Node{
+			Nodes: []*register.Node{
 				{
 					ID:      "foo-1.0.1-321",
 					Address: "localhost:6666",
@@ -37,7 +39,7 @@ var testData = map[string][]*Service{
 		{
 			Name:    "foo",
 			Version: "1.0.3",
-			Nodes: []*Node{
+			Nodes: []*register.Node{
 				{
 					ID:      "foo-1.0.3-345",
 					Address: "localhost:8888",
@@ -49,7 +51,7 @@ var testData = map[string][]*Service{
 		{
 			Name:    "bar",
 			Version: "default",
-			Nodes: []*Node{
+			Nodes: []*register.Node{
 				{
 					ID:      "bar-1.0.0-123",
 					Address: "localhost:9999",
@@ -63,7 +65,7 @@ var testData = map[string][]*Service{
 		{
 			Name:    "bar",
 			Version: "latest",
-			Nodes: []*Node{
+			Nodes: []*register.Node{
 				{
 					ID:      "bar-1.0.1-321",
 					Address: "localhost:6666",
@@ -78,7 +80,7 @@ func TestMemoryRegistry(t *testing.T) {
 	ctx := context.TODO()
 	m := NewRegister()
 
-	fn := func(k string, v []*Service) {
+	fn := func(k string, v []*register.Service) {
 		services, err := m.LookupService(ctx, k)
 		if err != nil {
 			t.Errorf("Unexpected error getting service %s: %v", k, err)
@@ -155,8 +157,8 @@ func TestMemoryRegistry(t *testing.T) {
 	for _, v := range testData {
 		for _, service := range v {
 			services, err := m.LookupService(ctx, service.Name)
-			if err != ErrNotFound {
-				t.Errorf("Expected error: %v, got: %v", ErrNotFound, err)
+			if err != register.ErrNotFound {
+				t.Errorf("Expected error: %v, got: %v", register.ErrNotFound, err)
 			}
 			if len(services) != 0 {
 				t.Errorf("Expected %d services for %s, got %d", 0, service.Name, len(services))
@@ -171,7 +173,7 @@ func TestMemoryRegistryTTL(t *testing.T) {
 
 	for _, v := range testData {
 		for _, service := range v {
-			if err := m.Register(ctx, service, RegisterTTL(time.Millisecond)); err != nil {
+			if err := m.Register(ctx, service, register.RegisterTTL(time.Millisecond)); err != nil {
 				t.Fatal(err)
 			}
 		}
@@ -200,7 +202,7 @@ func TestMemoryRegistryTTLConcurrent(t *testing.T) {
 	ctx := context.TODO()
 	for _, v := range testData {
 		for _, service := range v {
-			if err := m.Register(ctx, service, RegisterTTL(waitTime/2)); err != nil {
+			if err := m.Register(ctx, service, register.RegisterTTL(waitTime/2)); err != nil {
 				t.Fatal(err)
 			}
 		}
@@ -249,34 +251,34 @@ func TestMemoryWildcard(t *testing.T) {
 	m := NewRegister()
 	ctx := context.TODO()
 
-	testSrv := &Service{Name: "foo", Version: "1.0.0"}
+	testSrv := &register.Service{Name: "foo", Version: "1.0.0"}
 
-	if err := m.Register(ctx, testSrv, RegisterDomain("one")); err != nil {
+	if err := m.Register(ctx, testSrv, register.RegisterDomain("one")); err != nil {
 		t.Fatalf("Register err: %v", err)
 	}
-	if err := m.Register(ctx, testSrv, RegisterDomain("two")); err != nil {
+	if err := m.Register(ctx, testSrv, register.RegisterDomain("two")); err != nil {
 		t.Fatalf("Register err: %v", err)
 	}
 
-	if recs, err := m.ListServices(ctx, ListDomain("one")); err != nil {
+	if recs, err := m.ListServices(ctx, register.ListDomain("one")); err != nil {
 		t.Errorf("List err: %v", err)
 	} else if len(recs) != 1 {
 		t.Errorf("Expected 1 record, got %v", len(recs))
 	}
 
-	if recs, err := m.ListServices(ctx, ListDomain("*")); err != nil {
+	if recs, err := m.ListServices(ctx, register.ListDomain("*")); err != nil {
 		t.Errorf("List err: %v", err)
 	} else if len(recs) != 2 {
 		t.Errorf("Expected 2 records, got %v", len(recs))
 	}
 
-	if recs, err := m.LookupService(ctx, testSrv.Name, LookupDomain("one")); err != nil {
+	if recs, err := m.LookupService(ctx, testSrv.Name, register.LookupDomain("one")); err != nil {
 		t.Errorf("Lookup err: %v", err)
 	} else if len(recs) != 1 {
 		t.Errorf("Expected 1 record, got %v", len(recs))
 	}
 
-	if recs, err := m.LookupService(ctx, testSrv.Name, LookupDomain("*")); err != nil {
+	if recs, err := m.LookupService(ctx, testSrv.Name, register.LookupDomain("*")); err != nil {
 		t.Errorf("Lookup err: %v", err)
 	} else if len(recs) != 2 {
 		t.Errorf("Expected 2 records, got %v", len(recs))
@@ -284,7 +286,7 @@ func TestMemoryWildcard(t *testing.T) {
 }
 
 func TestWatcher(t *testing.T) {
-	testSrv := &Service{Name: "foo", Version: "1.0.0"}
+	testSrv := &register.Service{Name: "foo", Version: "1.0.0"}
 
 	ctx := context.TODO()
 	m := NewRegister()

register/noop.go

@@ -0,0 +1,72 @@
+package register
+
+import "context"
+
+type noop struct {
+	opts Options
+}
+
+func NewRegister(opts ...Option) Register {
+	return &noop{
+		opts: NewOptions(opts...),
+	}
+}
+
+func (n *noop) Name() string {
+	return n.opts.Name
+}
+
+func (n *noop) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(&n.opts)
+	}
+	return nil
+}
+
+func (n *noop) Options() Options {
+	return n.opts
+}
+
+func (n *noop) Connect(ctx context.Context) error {
+	return nil
+}
+
+func (n *noop) Disconnect(ctx context.Context) error {
+	return nil
+}
+
+func (n *noop) Register(ctx context.Context, service *Service, option ...RegisterOption) error {
+	return nil
+}
+
+func (n *noop) Deregister(ctx context.Context, service *Service, option ...DeregisterOption) error {
+	return nil
+}
+
+func (n *noop) LookupService(ctx context.Context, s string, option ...LookupOption) ([]*Service, error) {
+	return nil, nil
+}
+
+func (n *noop) ListServices(ctx context.Context, option ...ListOption) ([]*Service, error) {
+	return nil, nil
+}
+
+func (n *noop) Watch(ctx context.Context, opts ...WatchOption) (Watcher, error) {
+	wOpts := NewWatchOptions(opts...)
+
+	return &watcher{wo: wOpts}, nil
+}
+
+func (n *noop) String() string {
+	return "noop"
+}
+
+type watcher struct {
+	wo WatchOptions
+}
+
+func (m *watcher) Next() (*Result, error) {
+	return nil, nil
+}
+
+func (m *watcher) Stop() {}

register/register.go

@@ -18,7 +18,7 @@ var DefaultDomain = "micro"
 
 var (
 	// DefaultRegister is the global default register
-	DefaultRegister = NewRegister()
+	DefaultRegister Register = NewRegister()
 	// ErrNotFound returned when LookupService is called and no services found
 	ErrNotFound = errors.New("service not found")
 	// ErrWatcherStopped returned when when watcher is stopped

resolver/resolver.go

@@ -1,5 +1,5 @@
 // Package resolver resolves network names to addresses
-package resolver // import "go.unistack.org/micro/v3/resolver"
+package resolver
 
 // Resolver is network resolver. It's used to find network nodes
 // via the name to connect to. This is done based on Network.Name().

router/router.go

@@ -7,7 +7,7 @@ import (
 
 var (
 	// DefaultRouter is the global default router
-	DefaultRouter = NewRouter()
+	DefaultRouter Router = NewRouter()
 	// DefaultNetwork is default micro network
 	DefaultNetwork = "micro"
 	// ErrRouteNotFound is returned when no route was found in the routing table

server/noop.go

@@ -202,39 +202,6 @@ func (n *noopServer) Register() error {
 	n.Lock()
 	defer n.Unlock()
 
-	cx := config.Context
-
-	var sub broker.Subscriber
-
-	for sb := range n.subscribers {
-		if sb.Options().Context != nil {
-			cx = sb.Options().Context
-		}
-
-		opts := []broker.SubscribeOption{broker.SubscribeContext(cx), broker.SubscribeAutoAck(sb.Options().AutoAck)}
-		if queue := sb.Options().Queue; len(queue) > 0 {
-			opts = append(opts, broker.SubscribeGroup(queue))
-		}
-
-		if sb.Options().Batch {
-			// batch processing handler
-			sub, err = config.Broker.BatchSubscribe(cx, sb.Topic(), n.newBatchSubHandler(sb, config), opts...)
-		} else {
-			// single processing handler
-			sub, err = config.Broker.Subscribe(cx, sb.Topic(), n.newSubHandler(sb, config), opts...)
-		}
-
-		if err != nil {
-			return err
-		}
-
-		if config.Logger.V(logger.InfoLevel) {
-			config.Logger.Infof(n.opts.Context, "subscribing to topic: %s", sb.Topic())
-		}
-
-		n.subscribers[sb] = []broker.Subscriber{sub}
-	}
-
 	n.registered = true
 	if cacheService {
 		n.rsvc = service
@@ -366,6 +333,10 @@ func (n *noopServer) Start() error {
 		}
 	}
 
+	if err := n.subscribe(); err != nil {
+		return err
+	}
+
 	go func() {
 		t := new(time.Ticker)
 
@@ -449,6 +420,45 @@ func (n *noopServer) Start() error {
 	return nil
 }
 
+func (n *noopServer) subscribe() error {
+	config := n.Options()
+
+	cx := config.Context
+	var err error
+	var sub broker.Subscriber
+
+	for sb := range n.subscribers {
+		if sb.Options().Context != nil {
+			cx = sb.Options().Context
+		}
+
+		opts := []broker.SubscribeOption{broker.SubscribeContext(cx), broker.SubscribeAutoAck(sb.Options().AutoAck)}
+		if queue := sb.Options().Queue; len(queue) > 0 {
+			opts = append(opts, broker.SubscribeGroup(queue))
+		}
+
+		if sb.Options().Batch {
+			// batch processing handler
+			sub, err = config.Broker.BatchSubscribe(cx, sb.Topic(), n.createBatchSubHandler(sb, config), opts...)
+		} else {
+			// single processing handler
+			sub, err = config.Broker.Subscribe(cx, sb.Topic(), n.createSubHandler(sb, config), opts...)
+		}
+
+		if err != nil {
+			return err
+		}
+
+		if config.Logger.V(logger.InfoLevel) {
+			config.Logger.Infof(n.opts.Context, "subscribing to topic: %s", sb.Topic())
+		}
+
+		n.subscribers[sb] = []broker.Subscriber{sub}
+	}
+
+	return nil
+}
+
 func (n *noopServer) Stop() error {
 	n.RLock()
 	if !n.started {

server/options.go

@@ -86,6 +86,8 @@ type Options struct {
 	DeregisterAttempts int
 	// Hooks may contains SubscriberWrapper, HandlerWrapper or Server func wrapper
 	Hooks options.Hooks
+	// GracefulTimeout timeout for graceful stop server
+	GracefulTimeout time.Duration
 }
 
 // NewOptions returns new options struct with default or passed values
@@ -108,6 +110,7 @@ func NewOptions(opts ...Option) Options {
 		Version:          DefaultVersion,
 		ID:               id.Must(),
 		Namespace:        DefaultNamespace,
+		GracefulTimeout:  DefaultGracefulTimeout,
 	}
 
 	for _, o := range opts {
@@ -321,6 +324,14 @@ func Listener(l net.Listener) Option {
 // HandlerOption func
 type HandlerOption func(*HandlerOptions)
 
+// GracefulTimeout duration
+func GracefulTimeout(td time.Duration) Option {
+	return func(o *Options) {
+		o.GracefulTimeout = td
+	}
+}
+
+
 // HandlerOptions struct
 type HandlerOptions struct {
 	// Context holds external options

server/server.go

@@ -11,7 +11,7 @@ import (
 )
 
 // DefaultServer default server
-var DefaultServer = NewServer()
+var DefaultServer Server = NewServer()
 
 var (
 	// DefaultAddress will be used if no address passed, use secure localhost
@@ -34,6 +34,8 @@ var (
 	DefaultMaxMsgRecvSize = 1024 * 1024 * 4 // 4Mb
 	// DefaultMaxMsgSendSize holds default max send size
 	DefaultMaxMsgSendSize = 1024 * 1024 * 4 // 4Mb
+	// DefaultGracefulTimeout default time for graceful stop
+	DefaultGracefulTimeout = 5 * time.Second
 )
 
 // Server is a simple micro server abstraction

server/subscriber.go

@@ -191,7 +191,7 @@ func newSubscriber(topic string, sub interface{}, opts ...SubscriberOption) Subs
 }
 
 //nolint:gocyclo
-func (n *noopServer) newBatchSubHandler(sb *subscriber, opts Options) broker.BatchHandler {
+func (n *noopServer) createBatchSubHandler(sb *subscriber, opts Options) broker.BatchHandler {
 	return func(ps broker.Events) (err error) {
 		defer func() {
 			if r := recover(); r != nil {
@@ -309,7 +309,7 @@ func (n *noopServer) newBatchSubHandler(sb *subscriber, opts Options) broker.Bat
 }
 
 //nolint:gocyclo
-func (n *noopServer) newSubHandler(sb *subscriber, opts Options) broker.Handler {
+func (n *noopServer) createSubHandler(sb *subscriber, opts Options) broker.Handler {
 	return func(p broker.Event) (err error) {
 		defer func() {
 			if r := recover(); r != nil {
@@ -342,9 +342,6 @@ func (n *noopServer) newSubHandler(sb *subscriber, opts Options) broker.Handler
 
 		hdr := metadata.New(len(msg.Header))
 		for k, v := range msg.Header {
-			if k == "Content-Type" {
-				continue
-			}
 			hdr.Set(k, v)
 		}
 

service.go

@@ -72,8 +72,8 @@ func RegisterSubscriber(topic string, s server.Server, h interface{}, opts ...se
 }
 
 type service struct {
-	sync.RWMutex
 	opts Options
+	sync.RWMutex
 }
 
 // NewService creates and returns a new Service based on the packages within.
@@ -88,6 +88,7 @@ func (s *service) Name() string {
 // Init initialises options. Additionally it calls cmd.Init
 // which parses command line flags. cmd.Init is only called
 // on first Init.
+//
 //nolint:gocyclo
 func (s *service) Init(opts ...Option) error {
 	var err error
@@ -375,17 +376,13 @@ func (s *service) Run() error {
 	return s.Stop()
 }
 
-type nameIface interface {
+type Namer interface {
 	Name() string
 }
 
-func getNameIndex(n string, ifaces interface{}) int {
-	values, ok := ifaces.([]interface{})
-	if !ok {
-		return 0
-	}
-	for idx, iface := range values {
-		if ifc, ok := iface.(nameIface); ok && ifc.Name() == n {
+func getNameIndex[T Namer](n string, ifaces []T) int {
+	for idx, iface := range ifaces {
+		if iface.Name() == n {
 			return idx
 		}
 	}

service_test.go

@@ -17,6 +17,22 @@ import (
 	"go.unistack.org/micro/v3/tracer"
 )
 
+func TestClient(t *testing.T) {
+	c1 := client.NewClient(client.Name("test1"))
+	c2 := client.NewClient(client.Name("test2"))
+
+	svc := NewService(Client(c1, c2))
+
+	if err := svc.Init(); err != nil {
+		t.Fatal(err)
+	}
+
+	x1 := svc.Client("test2")
+	if x1.Name() != "test2" {
+		t.Fatalf("invalid client %#+v", svc.Options().Clients)
+	}
+}
+
 type testItem struct {
 	name string
 }
@@ -25,12 +41,11 @@ func (ti *testItem) Name() string {
 	return ti.name
 }
 
-func TestGetNameIndex(t *testing.T) {
-	item1 := &testItem{name: "first"}
-	item2 := &testItem{name: "second"}
-	items := []interface{}{item1, item2}
-	if idx := getNameIndex("second", items); idx != 1 {
-		t.Fatalf("getNameIndex func error, item not found")
+func Test_getNameIndex(t *testing.T) {
+	items := []*testItem{{name: "test1"}, {name: "test2"}}
+	idx := getNameIndex("test2", items)
+	if items[idx].Name() != "test2" {
+		t.Fatal("getNameIndex wrong")
 	}
 }
 

store/store.go

@@ -12,7 +12,7 @@ var (
 	// ErrInvalidKey is returned when a key has empty or have invalid format
 	ErrInvalidKey = errors.New("invalid key")
 	// DefaultStore is the global default store
-	DefaultStore = NewStore()
+	DefaultStore Store = NewStore()
 	// DefaultSeparator is the gloabal default key parts separator
 	DefaultSeparator = "/"
 )

tracer/memory/memory.go

@@ -0,0 +1,139 @@
+package memory
+
+import (
+	"context"
+	"time"
+
+	"go.unistack.org/micro/v3/tracer"
+	"go.unistack.org/micro/v3/util/id"
+)
+
+var _ tracer.Tracer = (*Tracer)(nil)
+
+type Tracer struct {
+	opts  tracer.Options
+	spans []tracer.Span
+}
+
+func (t *Tracer) Spans() []tracer.Span {
+	return t.spans
+}
+
+func (t *Tracer) Start(ctx context.Context, name string, opts ...tracer.SpanOption) (context.Context, tracer.Span) {
+	options := tracer.NewSpanOptions(opts...)
+	span := &Span{
+		name:      name,
+		ctx:       ctx,
+		tracer:    t,
+		kind:      options.Kind,
+		startTime: time.Now(),
+	}
+	span.spanID.s, _ = id.New()
+	span.traceID.s, _ = id.New()
+	if span.ctx == nil {
+		span.ctx = context.Background()
+	}
+	t.spans = append(t.spans, span)
+	return tracer.NewSpanContext(ctx, span), span
+}
+
+func (t *Tracer) Flush(_ context.Context) error {
+	return nil
+}
+
+func (t *Tracer) Init(opts ...tracer.Option) error {
+	for _, o := range opts {
+		o(&t.opts)
+	}
+	return nil
+}
+
+func (t *Tracer) Name() string {
+	return t.opts.Name
+}
+
+type noopStringer struct {
+	s string
+}
+
+func (s noopStringer) String() string {
+	return s.s
+}
+
+type Span struct {
+	ctx        context.Context
+	tracer     tracer.Tracer
+	name       string
+	statusMsg  string
+	startTime  time.Time
+	finishTime time.Time
+	traceID    noopStringer
+	spanID     noopStringer
+	events     []*Event
+	labels     []interface{}
+	logs       []interface{}
+	kind       tracer.SpanKind
+	status     tracer.SpanStatus
+}
+
+func (s *Span) Finish(_ ...tracer.SpanOption) {
+	s.finishTime = time.Now()
+}
+
+func (s *Span) Context() context.Context {
+	return s.ctx
+}
+
+func (s *Span) Tracer() tracer.Tracer {
+	return s.tracer
+}
+
+type Event struct {
+	name   string
+	labels []interface{}
+}
+
+func (s *Span) AddEvent(name string, opts ...tracer.EventOption) {
+	options := tracer.NewEventOptions(opts...)
+	s.events = append(s.events, &Event{name: name, labels: options.Labels})
+}
+
+func (s *Span) SetName(name string) {
+	s.name = name
+}
+
+func (s *Span) AddLogs(kv ...interface{}) {
+	s.logs = append(s.logs, kv...)
+}
+
+func (s *Span) AddLabels(kv ...interface{}) {
+	s.labels = append(s.labels, kv...)
+}
+
+func (s *Span) Kind() tracer.SpanKind {
+	return s.kind
+}
+
+func (s *Span) TraceID() string {
+	return s.traceID.String()
+}
+
+func (s *Span) SpanID() string {
+	return s.spanID.String()
+}
+
+func (s *Span) Status() (tracer.SpanStatus, string) {
+	return s.status, s.statusMsg
+}
+
+func (s *Span) SetStatus(st tracer.SpanStatus, msg string) {
+	s.status = st
+	s.statusMsg = msg
+}
+
+// NewTracer returns new memory tracer
+func NewTracer(opts ...tracer.Option) *Tracer {
+	return &Tracer{
+		opts: tracer.NewOptions(opts...),
+	}
+}

tracer/memory/memory_test.go

@@ -0,0 +1,38 @@
+package memory
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strings"
+	"testing"
+
+	"go.unistack.org/micro/v3/logger"
+	"go.unistack.org/micro/v3/logger/slog"
+	"go.unistack.org/micro/v3/tracer"
+)
+
+func TestLoggerWithTracer(t *testing.T) {
+	ctx := context.TODO()
+	buf := bytes.NewBuffer(nil)
+	logger.DefaultLogger = slog.NewLogger(logger.WithOutput(buf))
+
+	if err := logger.Init(); err != nil {
+		t.Fatal(err)
+	}
+	var span tracer.Span
+	tr := NewTracer()
+	ctx, span = tr.Start(ctx, "test1")
+
+	logger.Error(ctx, "my test error", fmt.Errorf("error"))
+
+	if !strings.Contains(buf.String(), span.TraceID()) {
+		t.Fatalf("log does not contains trace id: %s", buf.Bytes())
+	}
+
+	_, _ = tr.Start(ctx, "test2")
+
+	for _, s := range tr.Spans() {
+		_ = s
+	}
+}

tracer/noop.go

@@ -2,25 +2,51 @@ package tracer
 
 import (
 	"context"
+
+	"go.unistack.org/micro/v3/util/id"
 )
 
+var _ Tracer = (*noopTracer)(nil)
+
 type noopTracer struct {
-	opts Options
+	opts  Options
+	spans []Span
+}
+
+func (t *noopTracer) Spans() []Span {
+	return t.spans
 }
 
 func (t *noopTracer) Start(ctx context.Context, name string, opts ...SpanOption) (context.Context, Span) {
+	options := NewSpanOptions(opts...)
 	span := &noopSpan{
 		name:   name,
 		ctx:    ctx,
 		tracer: t,
-		opts:   NewSpanOptions(opts...),
+		labels: options.Labels,
+		kind:   options.Kind,
 	}
+	span.spanID.s, _ = id.New()
+	span.traceID.s, _ = id.New()
 	if span.ctx == nil {
 		span.ctx = context.Background()
 	}
+	t.spans = append(t.spans, span)
 	return NewSpanContext(ctx, span), span
 }
 
+type noopStringer struct {
+	s string
+}
+
+func (s noopStringer) String() string {
+	return s.s
+}
+
+func (t *noopTracer) Flush(ctx context.Context) error {
+	return nil
+}
+
 func (t *noopTracer) Init(opts ...Option) error {
 	for _, o := range opts {
 		o(&t.opts)
@@ -32,16 +58,34 @@ func (t *noopTracer) Name() string {
 	return t.opts.Name
 }
 
+type noopEvent struct {
+	name   string
+	labels []interface{}
+}
+
 type noopSpan struct {
 	ctx       context.Context
 	tracer    Tracer
 	name      string
-	opts      SpanOptions
-	status    SpanStatus
 	statusMsg string
+	traceID   noopStringer
+	spanID    noopStringer
+	events    []*noopEvent
+	labels    []interface{}
+	logs      []interface{}
+	kind      SpanKind
+	status    SpanStatus
 }
 
-func (s *noopSpan) Finish(opts ...SpanOption) {
+func (s *noopSpan) TraceID() string {
+	return s.traceID.String()
+}
+
+func (s *noopSpan) SpanID() string {
+	return s.spanID.String()
+}
+
+func (s *noopSpan) Finish(_ ...SpanOption) {
 }
 
 func (s *noopSpan) Context() context.Context {
@@ -53,22 +97,24 @@ func (s *noopSpan) Tracer() Tracer {
 }
 
 func (s *noopSpan) AddEvent(name string, opts ...EventOption) {
+	options := NewEventOptions(opts...)
+	s.events = append(s.events, &noopEvent{name: name, labels: options.Labels})
 }
 
 func (s *noopSpan) SetName(name string) {
 	s.name = name
 }
 
-func (s *noopSpan) SetLabels(labels ...interface{}) {
-	s.opts.Labels = labels
+func (s *noopSpan) AddLogs(kv ...interface{}) {
+	s.logs = append(s.logs, kv...)
 }
 
-func (s *noopSpan) AddLabels(labels ...interface{}) {
-	s.opts.Labels = append(s.opts.Labels, labels...)
+func (s *noopSpan) AddLabels(kv ...interface{}) {
+	s.labels = append(s.labels, kv...)
 }
 
 func (s *noopSpan) Kind() SpanKind {
-	return s.opts.Kind
+	return s.kind
 }
 
 func (s *noopSpan) Status() (SpanStatus, string) {

tracer/options.go

@@ -91,14 +91,22 @@ type SpanOptions struct {
 type SpanOption func(o *SpanOptions)
 
 // EventOptions contains event options
-type EventOptions struct{}
+type EventOptions struct {
+	Labels []interface{}
+}
 
 // EventOption func signature
 type EventOption func(o *EventOptions)
 
-func WithSpanLabels(labels ...interface{}) SpanOption {
+func WithEventLabels(kv ...interface{}) EventOption {
+	return func(o *EventOptions) {
+		o.Labels = kv
+	}
+}
+
+func WithSpanLabels(kv ...interface{}) SpanOption {
 	return func(o *SpanOptions) {
-		o.Labels = labels
+		o.Labels = kv
 	}
 }
 
@@ -128,6 +136,15 @@ func Logger(l logger.Logger) Option {
 	}
 }
 
+// NewEventOptions returns default EventOptions
+func NewEventOptions(opts ...EventOption) EventOptions {
+	options := EventOptions{}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
 // NewSpanOptions returns default SpanOptions
 func NewSpanOptions(opts ...SpanOption) SpanOptions {
 	options := SpanOptions{

tracer/tracer.go

@@ -3,10 +3,34 @@ package tracer // import "go.unistack.org/micro/v3/tracer"
 
 import (
 	"context"
+	"fmt"
+	"sort"
+
+	"go.unistack.org/micro/v3/logger"
 )
 
 // DefaultTracer is the global default tracer
-var DefaultTracer = NewTracer()
+var DefaultTracer Tracer = NewTracer()
+
+var (
+	// TraceIDKey is the key used for the trace id in the log call
+	TraceIDKey = "trace-id"
+	// SpanIDKey is the key used for the span id in the log call
+	SpanIDKey = "span-id"
+)
+
+func init() {
+	logger.DefaultContextAttrFuncs = append(logger.DefaultContextAttrFuncs,
+		func(ctx context.Context) []interface{} {
+			if span, ok := SpanFromContext(ctx); ok {
+				return []interface{}{
+					TraceIDKey, span.TraceID(),
+					SpanIDKey, span.SpanID(),
+				}
+			}
+			return nil
+		})
+}
 
 // Tracer is an interface for distributed tracing
 type Tracer interface {
@@ -16,6 +40,8 @@ type Tracer interface {
 	Init(...Option) error
 	// Start a trace
 	Start(ctx context.Context, name string, opts ...SpanOption) (context.Context, Span)
+	// Flush flushes spans
+	Flush(ctx context.Context) error
 }
 
 type Span interface {
@@ -23,8 +49,6 @@ type Span interface {
 	Tracer() Tracer
 	// Finish complete and send span
 	Finish(opts ...SpanOption)
-	// AddEvent add event to span
-	AddEvent(name string, opts ...EventOption)
 	// Context return context with span
 	Context() context.Context
 	// SetName set the span name
@@ -33,10 +57,50 @@ type Span interface {
 	SetStatus(status SpanStatus, msg string)
 	// Status returns span status and msg
 	Status() (SpanStatus, string)
-	// SetLabels set the span labels
-	SetLabels(labels ...interface{})
-	// AddLabels append the span labels
-	AddLabels(labels ...interface{})
+	// AddLabels append labels to span
+	AddLabels(kv ...interface{})
+	// AddEvent append event to span
+	AddEvent(name string, opts ...EventOption)
+	// AddEvent append event to span
+	AddLogs(kv ...interface{})
 	// Kind returns span kind
 	Kind() SpanKind
+	// TraceID returns trace id
+	TraceID() string
+	// SpanID returns span id
+	SpanID() string
+}
+
+// sort labels alphabeticaly by label name
+type byKey []interface{}
+
+func (k byKey) Len() int           { return len(k) / 2 }
+func (k byKey) Less(i, j int) bool { return fmt.Sprintf("%s", k[i*2]) < fmt.Sprintf("%s", k[j*2]) }
+func (k byKey) Swap(i, j int) {
+	k[i*2], k[j*2] = k[j*2], k[i*2]
+	k[i*2+1], k[j*2+1] = k[j*2+1], k[i*2+1]
+}
+
+func UniqLabels(labels []interface{}) []interface{} {
+	if len(labels)%2 == 1 {
+		labels = labels[:len(labels)-1]
+	}
+
+	if len(labels) > 2 {
+		sort.Sort(byKey(labels))
+
+		idx := 0
+		for {
+			if labels[idx] == labels[idx+2] {
+				copy(labels[idx:], labels[idx+2:])
+				labels = labels[:len(labels)-2]
+			} else {
+				idx += 2
+			}
+			if idx+2 >= len(labels) {
+				break
+			}
+		}
+	}
+	return labels
 }

tracer/tracer_test.go

@@ -0,0 +1,13 @@
+package tracer
+
+import (
+	"testing"
+)
+
+func TestUniqLabels(t *testing.T) {
+	labels := []interface{}{"key1", "val1", "key1", "val2"}
+	labels = UniqLabels(labels)
+	if labels[1] != "val2" {
+		t.Fatalf("UniqLabels not works")
+	}
+}

tracer/wrapper/wrapper.go

@@ -4,6 +4,7 @@ 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"
@@ -11,107 +12,87 @@ import (
 	"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) {
-		sp.SetName(fmt.Sprintf("Call %s.%s", req.Service(), req.Method()))
 		var labels []interface{}
 		if md, ok := metadata.FromOutgoingContext(ctx); ok {
-			labels = make([]interface{}, 0, len(md)+1)
-			for k, v := range md {
-				labels = append(labels, k, v)
-			}
+			labels = append(labels, ExtractDefaultLabels(md)...)
 		}
 		if err != nil {
-			labels = append(labels, "error", err.Error())
 			sp.SetStatus(tracer.SpanStatusError, err.Error())
 		}
-		labels = append(labels, "kind", sp.Kind())
-		sp.SetLabels(labels...)
+		sp.AddLabels(labels...)
 	}
 
 	DefaultClientStreamObserver = func(ctx context.Context, req client.Request, opts []client.CallOption, stream client.Stream, sp tracer.Span, err error) {
-		sp.SetName(fmt.Sprintf("Stream %s.%s", req.Service(), req.Method()))
 		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)
-			}
+			labels = append(labels, ExtractDefaultLabels(md)...)
 		}
 		if err != nil {
-			labels = append(labels, "error", err.Error())
 			sp.SetStatus(tracer.SpanStatusError, err.Error())
 		}
-		labels = append(labels, "kind", sp.Kind())
-		sp.SetLabels(labels...)
+		sp.AddLabels(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)
-			}
+			labels = append(labels, ExtractDefaultLabels(md)...)
 		}
+		labels = append(labels, ExtractDefaultLabels(msg.Metadata())...)
 		if err != nil {
-			labels = append(labels, "error", err.Error())
 			sp.SetStatus(tracer.SpanStatusError, err.Error())
 		}
-		labels = append(labels, "kind", sp.Kind())
-		sp.SetLabels(labels...)
+		sp.AddLabels(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{}
 		if md, ok := metadata.FromIncomingContext(ctx); ok {
-			labels = make([]interface{}, 0, len(md))
-			for k, v := range md {
-				labels = append(labels, k, v)
-			}
+			labels = append(labels, ExtractDefaultLabels(md)...)
 		}
 		if err != nil {
-			labels = append(labels, "error", err.Error())
 			sp.SetStatus(tracer.SpanStatusError, err.Error())
 		}
-		labels = append(labels, "kind", sp.Kind())
-		sp.SetLabels(labels...)
+		sp.AddLabels(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)
-			}
+			labels = append(labels, ExtractDefaultLabels(md)...)
 		}
+		labels = append(labels, ExtractDefaultLabels(msg.Header())...)
+
 		if err != nil {
-			labels = append(labels, "error", err.Error())
 			sp.SetStatus(tracer.SpanStatusError, err.Error())
 		}
-		labels = append(labels, "kind", sp.Kind())
-		sp.SetLabels(labels...)
+		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("Call %s.%s", req.Service(), req.Method()))
+		sp.SetName(fmt.Sprintf("%s.%s call", req.Service(), req.Method()))
 		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)
-			}
+			labels = append(labels, ExtractDefaultLabels(md)...)
 		}
 		if err != nil {
-			labels = append(labels, "error", err.Error())
 			sp.SetStatus(tracer.SpanStatusError, err.Error())
 		}
-		labels = append(labels, "kind", sp.Kind())
-		sp.SetLabels(labels...)
+		sp.AddLabels(labels...)
 	}
 
 	DefaultSkipEndpoints = []string{"Meter.Metrics", "Health.Live", "Health.Ready", "Health.Version"}
@@ -241,16 +222,22 @@ func (ot *tWrapper) Call(ctx context.Context, req client.Request, rsp interface{
 		}
 	}
 
-	sp, ok := tracer.SpanFromContext(ctx)
-	if !ok {
-		ctx, sp = ot.opts.Tracer.Start(ctx, "", tracer.WithSpanKind(tracer.SpanKindClient))
-	}
+	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(ctx, req, rsp, opts...)
+	err := ot.Client.Call(nctx, req, rsp, opts...)
 
 	for _, o := range ot.opts.ClientCallObservers {
-		o(ctx, req, rsp, opts, sp, err)
+		o(nctx, req, rsp, opts, sp, err)
 	}
 
 	return err
@@ -264,32 +251,36 @@ func (ot *tWrapper) Stream(ctx context.Context, req client.Request, opts ...clie
 		}
 	}
 
-	sp, ok := tracer.SpanFromContext(ctx)
-	if !ok {
-		ctx, sp = ot.opts.Tracer.Start(ctx, "", tracer.WithSpanKind(tracer.SpanKindClient))
-	}
+	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(ctx, req, opts...)
+	stream, err := ot.Client.Stream(nctx, req, opts...)
 
 	for _, o := range ot.opts.ClientStreamObservers {
-		o(ctx, req, opts, stream, sp, err)
+		o(nctx, req, opts, stream, sp, err)
 	}
 
 	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))
-	}
+	nctx, sp := ot.opts.Tracer.Start(ctx, msg.Topic()+" publish", tracer.WithSpanKind(tracer.SpanKindProducer))
 	defer sp.Finish()
-
-	err := ot.Client.Publish(ctx, msg, opts...)
+	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(ctx, msg, opts, sp, err)
+		o(nctx, msg, opts, sp, err)
 	}
 
 	return err
@@ -303,32 +294,41 @@ func (ot *tWrapper) ServerHandler(ctx context.Context, req server.Request, rsp i
 		}
 	}
 
-	sp, ok := tracer.SpanFromContext(ctx)
-	if !ok {
-		ctx, sp = ot.opts.Tracer.Start(ctx, "", tracer.WithSpanKind(tracer.SpanKindServer))
+	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(ctx, req, rsp)
+	err := ot.serverHandler(nctx, req, rsp)
 
 	for _, o := range ot.opts.ServerHandlerObservers {
-		o(ctx, req, rsp, sp, err)
+		o(nctx, req, rsp, sp, err)
 	}
 
 	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))
-	}
+	nctx, sp := ot.opts.Tracer.Start(ctx, msg.Topic()+" process", tracer.WithSpanKind(tracer.SpanKindConsumer))
 	defer sp.Finish()
-
-	err := ot.serverSubscriber(ctx, msg)
+	sp.AddLabels("messaging.operation", "process")
+	sp.AddLabels("messaging.source.name", msg.Topic())
+	err := ot.serverSubscriber(nctx, msg)
 
 	for _, o := range ot.opts.ServerSubscriberObservers {
-		o(ctx, msg, sp, err)
+		o(nctx, msg, sp, err)
 	}
 
 	return err
@@ -366,16 +366,23 @@ func (ot *tWrapper) ClientCallFunc(ctx context.Context, addr string, req client.
 		}
 	}
 
-	sp, ok := tracer.SpanFromContext(ctx)
-	if !ok {
-		ctx, sp = ot.opts.Tracer.Start(ctx, "", tracer.WithSpanKind(tracer.SpanKindClient))
-	}
+	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(ctx, addr, req, rsp, opts)
+	err := ot.clientCallFunc(nctx, addr, req, rsp, opts)
 
 	for _, o := range ot.opts.ClientCallFuncObservers {
-		o(ctx, addr, req, rsp, opts, sp, err)
+		o(nctx, addr, req, rsp, opts, sp, err)
 	}
 
 	return err

util/grpc/tracer.go

@@ -0,0 +1,271 @@
+package grpc_util
+
+import (
+	"context"
+	"net"
+	"strconv"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	"go.unistack.org/micro/v3/tracer"
+	grpc_codes "google.golang.org/grpc/codes"
+	"google.golang.org/grpc/peer"
+	"google.golang.org/grpc/stats"
+	"google.golang.org/grpc/status"
+)
+
+type gRPCContextKey struct{}
+
+type gRPCContext struct {
+	messagesReceived int64
+	messagesSent     int64
+}
+
+type Options struct {
+	Tracer tracer.Tracer
+}
+
+type Option func(*Options)
+
+func Tracer(tr tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = tr
+	}
+}
+
+// NewServerHandler creates a stats.Handler for gRPC server.
+func NewServerHandler(opts ...Option) stats.Handler {
+	options := Options{Tracer: tracer.DefaultTracer}
+	for _, o := range opts {
+		o(&options)
+	}
+	h := &serverHandler{
+		opts: options,
+	}
+	return h
+}
+
+type serverHandler struct {
+	opts Options
+}
+
+// TagRPC can attach some information to the given context.
+func (h *serverHandler) TagRPC(ctx context.Context, info *stats.RPCTagInfo) context.Context {
+	name, attrs := parseFullMethod(info.FullMethodName)
+	attrs = append(attrs, "rpc.system", "grpc")
+	ctx, _ = h.opts.Tracer.Start(
+		ctx,
+		name,
+		tracer.WithSpanKind(tracer.SpanKindServer),
+		tracer.WithSpanLabels(attrs...),
+	)
+
+	gctx := gRPCContext{}
+	return context.WithValue(ctx, gRPCContextKey{}, &gctx)
+}
+
+// HandleRPC processes the RPC stats.
+func (h *serverHandler) HandleRPC(ctx context.Context, rs stats.RPCStats) {
+	handleRPC(ctx, rs)
+}
+
+// TagConn can attach some information to the given context.
+func (h *serverHandler) TagConn(ctx context.Context, info *stats.ConnTagInfo) context.Context {
+	if span, ok := tracer.SpanFromContext(ctx); ok {
+		attrs := peerAttr(peerFromCtx(ctx))
+		span.AddLabels(attrs...)
+	}
+	return ctx
+}
+
+// HandleConn processes the Conn stats.
+func (h *serverHandler) HandleConn(ctx context.Context, info stats.ConnStats) {
+}
+
+type clientHandler struct {
+	opts Options
+}
+
+// NewClientHandler creates a stats.Handler for gRPC client.
+func NewClientHandler(opts ...Option) stats.Handler {
+	options := Options{Tracer: tracer.DefaultTracer}
+	for _, o := range opts {
+		o(&options)
+	}
+	h := &clientHandler{
+		opts: options,
+	}
+	return h
+}
+
+// TagRPC can attach some information to the given context.
+func (h *clientHandler) TagRPC(ctx context.Context, info *stats.RPCTagInfo) context.Context {
+	name, attrs := parseFullMethod(info.FullMethodName)
+	attrs = append(attrs, "rpc.system", "grpc", "rpc.flavor", "grpc", "rpc.call", info.FullMethodName)
+	ctx, _ = h.opts.Tracer.Start(
+		ctx,
+		name,
+		tracer.WithSpanKind(tracer.SpanKindClient),
+		tracer.WithSpanLabels(attrs...),
+	)
+
+	gctx := gRPCContext{}
+
+	return context.WithValue(ctx, gRPCContextKey{}, &gctx)
+}
+
+// HandleRPC processes the RPC stats.
+func (h *clientHandler) HandleRPC(ctx context.Context, rs stats.RPCStats) {
+	handleRPC(ctx, rs)
+}
+
+// TagConn can attach some information to the given context.
+func (h *clientHandler) TagConn(ctx context.Context, cti *stats.ConnTagInfo) context.Context {
+	// TODO
+	if span, ok := tracer.SpanFromContext(ctx); ok {
+		attrs := peerAttr(cti.RemoteAddr.String())
+		span.AddLabels(attrs...)
+	}
+	return ctx
+}
+
+// HandleConn processes the Conn stats.
+func (h *clientHandler) HandleConn(context.Context, stats.ConnStats) {
+	// no-op
+}
+
+func handleRPC(ctx context.Context, rs stats.RPCStats) {
+	span, ok := tracer.SpanFromContext(ctx)
+	gctx, _ := ctx.Value(gRPCContextKey{}).(*gRPCContext)
+	var messageID int64
+	if rs.IsClient() {
+		span.AddLabels("span.kind", "client")
+	} else {
+		span.AddLabels("span.kind", "server")
+	}
+
+	switch rs := rs.(type) {
+	case *stats.Begin:
+		if rs.IsClientStream || rs.IsServerStream {
+			span.AddLabels("rpc.call_type", "stream")
+		} else {
+			span.AddLabels("rpc.call_type", "unary")
+		}
+		span.AddEvent("message",
+			tracer.WithEventLabels(
+				"message.begin_time", rs.BeginTime.Format(time.RFC3339),
+			),
+		)
+	case *stats.InPayload:
+		if gctx != nil {
+			messageID = atomic.AddInt64(&gctx.messagesReceived, 1)
+		}
+		if ok {
+			span.AddEvent("message",
+				tracer.WithEventLabels(
+					"message.recv_time", rs.RecvTime.Format(time.RFC3339),
+					"message.type", "RECEIVED",
+					"message.id", messageID,
+					"message.compressed_size", rs.CompressedLength,
+					"message.uncompressed_size", rs.Length,
+				),
+			)
+		}
+	case *stats.OutPayload:
+		if gctx != nil {
+			messageID = atomic.AddInt64(&gctx.messagesSent, 1)
+		}
+		if ok {
+			span.AddEvent("message",
+				tracer.WithEventLabels(
+					"message.sent_time", rs.SentTime.Format(time.RFC3339),
+					"message.type", "SENT",
+					"message.id", messageID,
+					"message.compressed_size", rs.CompressedLength,
+					"message.uncompressed_size", rs.Length,
+				),
+			)
+		}
+	case *stats.End:
+		if ok {
+			span.AddEvent("message",
+				tracer.WithEventLabels(
+					"message.begin_time", rs.BeginTime.Format(time.RFC3339),
+					"message.end_time", rs.EndTime.Format(time.RFC3339),
+				),
+			)
+			if rs.Error != nil {
+				s, _ := status.FromError(rs.Error)
+				span.SetStatus(tracer.SpanStatusError, s.Message())
+				span.AddLabels("rpc.grpc.status_code", s.Code())
+			} else {
+				span.AddLabels("rpc.grpc.status_code", grpc_codes.OK)
+			}
+			span.Finish()
+		}
+	default:
+		return
+	}
+}
+
+func parseFullMethod(fullMethod string) (string, []interface{}) {
+	if !strings.HasPrefix(fullMethod, "/") {
+		// Invalid format, does not follow `/package.service/method`.
+		return fullMethod, nil
+	}
+	name := fullMethod[1:]
+	pos := strings.LastIndex(name, "/")
+	if pos < 0 {
+		// Invalid format, does not follow `/package.service/method`.
+		return name, nil
+	}
+	service, method := name[:pos], name[pos+1:]
+
+	var attrs []interface{}
+	if service != "" {
+		attrs = append(attrs, "rpc.service", service)
+	}
+	if method != "" {
+		attrs = append(attrs, "rpc.method", method)
+	}
+	return name, attrs
+}
+
+func peerAttr(addr string) []interface{} {
+	host, p, err := net.SplitHostPort(addr)
+	if err != nil {
+		return nil
+	}
+
+	if host == "" {
+		host = "127.0.0.1"
+	}
+	port, err := strconv.Atoi(p)
+	if err != nil {
+		return nil
+	}
+
+	var attr []interface{}
+	if ip := net.ParseIP(host); ip != nil {
+		attr = []interface{}{
+			"net.sock.peer.addr", host,
+			"net.sock.peer.port", port,
+		}
+	} else {
+		attr = []interface{}{
+			"net.peer.name", host,
+			"net.peer.port", port,
+		}
+	}
+
+	return attr
+}
+
+func peerFromCtx(ctx context.Context) string {
+	p, ok := peer.FromContext(ctx)
+	if !ok {
+		return ""
+	}
+	return p.Addr.String()
+}

util/http/clienttracer.go

@@ -0,0 +1,253 @@
+//
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package http
+
+import (
+	"context"
+	"crypto/tls"
+	"net/http/httptrace"
+	"net/textproto"
+	"strings"
+	"sync"
+
+	"go.unistack.org/micro/v3/tracer"
+)
+
+const (
+	httpStatus     = "http.status"
+	httpHeaderMIME = "http.mime"
+	httpRemoteAddr = "http.remote"
+	httpLocalAddr  = "http.local"
+	httpHost       = "http.host"
+)
+
+var hookMap = map[string]string{
+	"http.dns":     "http.getconn",
+	"http.connect": "http.getconn",
+	"http.tls":     "http.getconn",
+}
+
+func parentHook(hook string) string {
+	if strings.HasPrefix(hook, "http.connect") {
+		return hookMap["http.connect"]
+	}
+	return hookMap[hook]
+}
+
+type clientTracer struct {
+	context.Context
+	tr          tracer.Tracer
+	activeHooks map[string]context.Context
+	root        tracer.Span
+	mtx         sync.Mutex
+}
+
+func NewClientTrace(ctx context.Context, tr tracer.Tracer) *httptrace.ClientTrace {
+	ct := &clientTracer{
+		Context:     ctx,
+		activeHooks: make(map[string]context.Context),
+		tr:          tr,
+	}
+
+	return &httptrace.ClientTrace{
+		GetConn:              ct.getConn,
+		GotConn:              ct.gotConn,
+		PutIdleConn:          ct.putIdleConn,
+		GotFirstResponseByte: ct.gotFirstResponseByte,
+		Got100Continue:       ct.got100Continue,
+		Got1xxResponse:       ct.got1xxResponse,
+		DNSStart:             ct.dnsStart,
+		DNSDone:              ct.dnsDone,
+		ConnectStart:         ct.connectStart,
+		ConnectDone:          ct.connectDone,
+		TLSHandshakeStart:    ct.tlsHandshakeStart,
+		TLSHandshakeDone:     ct.tlsHandshakeDone,
+		WroteHeaderField:     ct.wroteHeaderField,
+		WroteHeaders:         ct.wroteHeaders,
+		Wait100Continue:      ct.wait100Continue,
+		WroteRequest:         ct.wroteRequest,
+	}
+}
+
+func (ct *clientTracer) start(hook, spanName string, attrs ...interface{}) {
+	ct.mtx.Lock()
+	defer ct.mtx.Unlock()
+
+	if hookCtx, found := ct.activeHooks[hook]; !found {
+		var sp tracer.Span
+		ct.activeHooks[hook], sp = ct.tr.Start(ct.getParentContext(hook), spanName, tracer.WithSpanLabels(attrs...), tracer.WithSpanKind(tracer.SpanKindClient))
+		if ct.root == nil {
+			ct.root = sp
+		}
+	} else {
+		// end was called before start finished, add the start attributes and end the span here
+		if span, ok := tracer.SpanFromContext(hookCtx); ok {
+			span.AddLabels(attrs...)
+			span.Finish()
+		}
+
+		delete(ct.activeHooks, hook)
+	}
+}
+
+func (ct *clientTracer) end(hook string, err error, attrs ...interface{}) {
+	ct.mtx.Lock()
+	defer ct.mtx.Unlock()
+	if ctx, ok := ct.activeHooks[hook]; ok { // nolint:nestif
+		if span, ok := tracer.SpanFromContext(ctx); ok {
+			if err != nil {
+				span.SetStatus(tracer.SpanStatusError, err.Error())
+			}
+			span.AddLabels(attrs...)
+			span.Finish()
+		}
+		delete(ct.activeHooks, hook)
+	} else {
+		// start is not finished before end is called.
+		// Start a span here with the ending attributes that will be finished when start finishes.
+		// Yes, it's backwards. v0v
+		ctx, span := ct.tr.Start(ct.getParentContext(hook), hook, tracer.WithSpanLabels(attrs...), tracer.WithSpanKind(tracer.SpanKindClient))
+		if err != nil {
+			span.SetStatus(tracer.SpanStatusError, err.Error())
+		}
+		ct.activeHooks[hook] = ctx
+	}
+}
+
+func (ct *clientTracer) getParentContext(hook string) context.Context {
+	ctx, ok := ct.activeHooks[parentHook(hook)]
+	if !ok {
+		return ct.Context
+	}
+	return ctx
+}
+
+func (ct *clientTracer) span(hook string) (tracer.Span, bool) {
+	ct.mtx.Lock()
+	defer ct.mtx.Unlock()
+	if ctx, ok := ct.activeHooks[hook]; ok {
+		return tracer.SpanFromContext(ctx)
+	}
+	return nil, false
+}
+
+func (ct *clientTracer) getConn(host string) {
+	ct.start("http.getconn", "http.getconn", httpHost, host)
+}
+
+func (ct *clientTracer) gotConn(info httptrace.GotConnInfo) {
+	ct.end("http.getconn",
+		nil,
+		httpRemoteAddr, info.Conn.RemoteAddr().String(),
+		httpLocalAddr, info.Conn.LocalAddr().String(),
+	)
+}
+
+func (ct *clientTracer) putIdleConn(err error) {
+	ct.end("http.receive", err)
+}
+
+func (ct *clientTracer) gotFirstResponseByte() {
+	ct.start("http.receive", "http.receive")
+}
+
+func (ct *clientTracer) dnsStart(info httptrace.DNSStartInfo) {
+	ct.start("http.dns", "http.dns", httpHost, info.Host)
+}
+
+func (ct *clientTracer) dnsDone(info httptrace.DNSDoneInfo) {
+	ct.end("http.dns", info.Err)
+}
+
+func (ct *clientTracer) connectStart(network, addr string) {
+	_ = network
+	ct.start("http.connect."+addr, "http.connect", httpRemoteAddr, addr)
+}
+
+func (ct *clientTracer) connectDone(network, addr string, err error) {
+	_ = network
+	ct.end("http.connect."+addr, err)
+}
+
+func (ct *clientTracer) tlsHandshakeStart() {
+	ct.start("http.tls", "http.tls")
+}
+
+func (ct *clientTracer) tlsHandshakeDone(_ tls.ConnectionState, err error) {
+	ct.end("http.tls", err)
+}
+
+func (ct *clientTracer) wroteHeaderField(k string, v []string) {
+	if sp, ok := ct.span("http.headers"); !ok || sp == nil {
+		ct.start("http.headers", "http.headers")
+	}
+	ct.root.AddLabels("http."+strings.ToLower(k), sliceToString(v))
+}
+
+func (ct *clientTracer) wroteHeaders() {
+	ct.start("http.send", "http.send")
+}
+
+func (ct *clientTracer) wroteRequest(info httptrace.WroteRequestInfo) {
+	if info.Err != nil {
+		ct.root.SetStatus(tracer.SpanStatusError, info.Err.Error())
+	}
+	ct.end("http.send", info.Err)
+}
+
+func (ct *clientTracer) got100Continue() {
+	if sp, ok := ct.span("http.receive"); ok && sp != nil {
+		sp.AddEvent("GOT 100 - Continue")
+	}
+}
+
+func (ct *clientTracer) wait100Continue() {
+	if sp, ok := ct.span("http.receive"); ok && sp != nil {
+		sp.AddEvent("GOT 100 - Wait")
+	}
+}
+
+func (ct *clientTracer) got1xxResponse(code int, header textproto.MIMEHeader) error {
+	if sp, ok := ct.span("http.receive"); ok && sp != nil {
+		sp.AddEvent("GOT 1xx",
+			tracer.WithEventLabels(
+				httpStatus, code,
+				httpHeaderMIME, sm2s(header),
+			),
+		)
+	}
+	return nil
+}
+
+func sliceToString(value []string) string {
+	if len(value) == 0 {
+		return "undefined"
+	}
+	return strings.Join(value, ",")
+}
+
+func sm2s(value map[string][]string) string {
+	var buf strings.Builder
+	for k, v := range value {
+		if buf.Len() != 0 {
+			buf.WriteString(",")
+		}
+		buf.WriteString(k)
+		buf.WriteString("=")
+		buf.WriteString(sliceToString(v))
+	}
+	return buf.String()
+}

util/http/trie_test.go

@@ -5,8 +5,32 @@ import (
 	"testing"
 )
 
-func TestTrieBackwards(t *testing.T) {
-	_ = &Trie{}
+func TestTrieRPC(t *testing.T) {
+	var err error
+	type handler struct {
+		name string
+	}
+	tr := NewTrie()
+	if err = tr.Insert([]string{"helloworld"}, "Call", &handler{name: "helloworld.Call"}); err != nil {
+		t.Fatal(err)
+	}
+	if err = tr.Insert([]string{"helloworld"}, "Stream", &handler{name: "helloworld.Stream"}); err != nil {
+		t.Fatal(err)
+	}
+	h, _, err := tr.Search("helloworld", "Call")
+	if err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+	if h.(*handler).name != "helloworld.Call" {
+		t.Fatalf("invalid handler %v", h)
+	}
+	h, _, err = tr.Search("helloworld", "Stream")
+	if err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+	if h.(*handler).name != "helloworld.Stream" {
+		t.Fatalf("invalid handler %v", h)
+	}
 }
 
 func TestTrieWildcardPathPrefix(t *testing.T) {

util/reflect/reflect.go

@@ -508,3 +508,74 @@ func FieldName(name string) string {
 
 	return string(newstr)
 }
+
+func Equal(src interface{}, dst interface{}, excptFields ...string) bool {
+	srcVal := reflect.ValueOf(src)
+	dstVal := reflect.ValueOf(dst)
+
+	switch srcVal.Kind() {
+	case reflect.Array, reflect.Slice:
+		for i := 0; i < srcVal.Len(); i++ {
+			e := srcVal.Index(i).Interface()
+			a := dstVal.Index(i).Interface()
+			if !Equal(e, a, excptFields...) {
+				return false
+			}
+		}
+		return true
+	case reflect.Map:
+		for i := 0; i < len(srcVal.MapKeys()); i++ {
+			key := srcVal.MapKeys()[i]
+			keyStr := fmt.Sprintf("%v", key.Interface())
+			if stringContains(keyStr, excptFields) {
+				continue
+			}
+			s := srcVal.MapIndex(key)
+			d := dstVal.MapIndex(key)
+			if !Equal(s.Interface(), d.Interface(), excptFields...) {
+				return false
+			}
+		}
+		return true
+	case reflect.Struct, reflect.Interface:
+		for i := 0; i < srcVal.NumField(); i++ {
+			typeField := srcVal.Type().Field(i)
+			if stringContains(typeField.Name, excptFields) {
+				continue
+			}
+			s := srcVal.Field(i)
+			d := dstVal.FieldByName(typeField.Name)
+			if s.CanInterface() && d.CanInterface() {
+				if !Equal(s.Interface(), d.Interface(), excptFields...) {
+					return false
+				}
+			} else {
+				return false
+			}
+		}
+		return true
+	case reflect.Ptr:
+		if srcVal.IsNil() {
+			return dstVal.IsNil()
+		}
+		s := srcVal.Elem()
+		d := reflect.Indirect(dstVal)
+		if s.CanInterface() && d.CanInterface() {
+			return Equal(s.Interface(), d.Interface(), excptFields...)
+		}
+		return false
+	case reflect.String, reflect.Int, reflect.Int64, reflect.Float32, reflect.Float64, reflect.Bool:
+		return src == dst
+	default:
+		return srcVal.Interface() == dstVal.Interface()
+	}
+}
+
+func stringContains(a string, list []string) bool {
+	for _, b := range list {
+		if b == a {
+			return true
+		}
+	}
+	return false
+}

util/reflect/reflect_test.go

@@ -133,3 +133,16 @@ func TestMergeNested(t *testing.T) {
 		t.Fatalf("merge error: %#+v", dst.Nested)
 	}
 }
+
+func TestEqual(t *testing.T) {
+	type tstr struct {
+		Key1 string
+		Key2 string
+	}
+
+	src := &tstr{Key1: "val1", Key2: "micro:generate"}
+	dst := &tstr{Key1: "val1", Key2: "val2"}
+	if !Equal(src, dst, "Key2") {
+		t.Fatal("invalid Equal test")
+	}
+}

util/test/test.go

@@ -0,0 +1,505 @@
+package test
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"database/sql/driver"
+	"encoding/csv"
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"time"
+
+	sqlmock "github.com/DATA-DOG/go-sqlmock"
+	"go.unistack.org/micro/v3/client"
+	"go.unistack.org/micro/v3/codec"
+	"go.unistack.org/micro/v3/errors"
+	"go.unistack.org/micro/v3/metadata"
+	"golang.org/x/sync/errgroup"
+	"google.golang.org/grpc/status"
+	"google.golang.org/protobuf/proto"
+)
+
+var ErrUnknownContentType = fmt.Errorf("unknown content type")
+
+type Extension struct {
+	Ext []string
+}
+
+var (
+	// ExtToTypes map file extension to content type
+	ExtToTypes = map[string][]string{
+		"json":  {"application/json", "application/grpc+json"},
+		"yaml":  {"application/yaml", "application/yml", "text/yaml", "text/yml"},
+		"yml":   {"application/yaml", "application/yml", "text/yaml", "text/yml"},
+		"proto": {"application/grpc", "application/grpc+proto", "application/proto"},
+	}
+	// DefaultExts specifies default file extensions to load data
+	DefaultExts = []string{"csv", "json", "yaml", "yml", "proto"}
+	// Codecs map to detect codec for test file or request content type
+	Codecs map[string]codec.Codec
+
+	// ResponseCompareFunc used to compare actual response with test case data
+	ResponseCompareFunc = func(expectRsp []byte, testRsp interface{}, expectCodec codec.Codec, testCodec codec.Codec) error {
+		var err error
+
+		expectMap := make(map[string]interface{})
+		if err = expectCodec.Unmarshal(expectRsp, &expectMap); err != nil {
+			return fmt.Errorf("failed to unmarshal err: %w", err)
+		}
+
+		testMap := make(map[string]interface{})
+		switch v := testRsp.(type) {
+		case *codec.Frame:
+			if err = testCodec.Unmarshal(v.Data, &testMap); err != nil {
+				return fmt.Errorf("failed to unmarshal err: %w", err)
+			}
+		case *errors.Error:
+			if err = expectCodec.Unmarshal([]byte(v.Error()), &testMap); err != nil {
+				return fmt.Errorf("failed to unmarshal err: %w", err)
+			}
+		case error:
+			st, ok := status.FromError(v)
+			if !ok {
+				return v
+			}
+			me := errors.Parse(st.Message())
+			if me.Code != 0 {
+				if err = expectCodec.Unmarshal([]byte(me.Error()), &testMap); err != nil {
+					return fmt.Errorf("failed to unmarshal err: %w", err)
+				}
+				break
+			}
+			for _, se := range st.Details() {
+				switch ne := se.(type) {
+				case proto.Message:
+					buf, err := testCodec.Marshal(ne)
+					if err != nil {
+						return fmt.Errorf("failed to marshal err: %w", err)
+					}
+					if err = testCodec.Unmarshal(buf, &testMap); err != nil {
+						return fmt.Errorf("failed to unmarshal err: %w", err)
+					}
+				default:
+					return st.Err()
+				}
+			}
+		case interface{ GRPCStatus() *status.Status }:
+			st := v.GRPCStatus()
+			me := errors.Parse(st.Message())
+			if me.Code != 0 {
+				if err = expectCodec.Unmarshal([]byte(me.Error()), &testMap); err != nil {
+					return fmt.Errorf("failed to unmarshal err: %w", err)
+				}
+				break
+			}
+		case *status.Status:
+			me := errors.Parse(v.Message())
+			if me.Code != 0 {
+				if err = expectCodec.Unmarshal([]byte(me.Error()), &testMap); err != nil {
+					return fmt.Errorf("failed to unmarshal err: %w", err)
+				}
+				break
+			}
+			for _, se := range v.Details() {
+				switch ne := se.(type) {
+				case proto.Message:
+					buf, err := testCodec.Marshal(ne)
+					if err != nil {
+						return fmt.Errorf("failed to marshal err: %w", err)
+					}
+					if err = testCodec.Unmarshal(buf, &testMap); err != nil {
+						return fmt.Errorf("failed to unmarshal err: %w", err)
+					}
+				default:
+					return v.Err()
+				}
+			}
+		}
+
+		if !reflect.DeepEqual(expectMap, testMap) {
+			return fmt.Errorf("test: %s != rsp: %s", expectMap, testMap)
+		}
+
+		return nil
+	}
+)
+
+func FromCSVString(columns []*sqlmock.Column, rows *sqlmock.Rows, s string) *sqlmock.Rows {
+	res := strings.NewReader(strings.TrimSpace(s))
+	csvReader := csv.NewReader(res)
+
+	for {
+		res, err := csvReader.Read()
+		if err != nil || res == nil {
+			break
+		}
+
+		var row []driver.Value
+		for i, v := range res {
+			item := CSVColumnParser(strings.TrimSpace(v))
+			if null, nullOk := columns[i].IsNullable(); null && nullOk && item == nil {
+				row = append(row, nil)
+			} else {
+				row = append(row, item)
+			}
+
+		}
+		rows = rows.AddRow(row...)
+	}
+
+	return rows
+}
+
+func CSVColumnParser(s string) []byte {
+	switch {
+	case strings.ToLower(s) == "null":
+		return nil
+	case s == "":
+		return nil
+	}
+	return []byte(s)
+}
+
+func NewResponseFromFile(rspfile string) (*codec.Frame, error) {
+	rspbuf, err := os.ReadFile(rspfile)
+	if err != nil {
+		return nil, err
+	}
+	return &codec.Frame{Data: rspbuf}, nil
+}
+
+func getCodec(codecs map[string]codec.Codec, ext string) (codec.Codec, error) {
+	var c codec.Codec
+	if cts, ok := ExtToTypes[ext]; ok {
+		for _, t := range cts {
+			if c, ok = codecs[t]; ok {
+				return c, nil
+			}
+		}
+	}
+	return nil, ErrUnknownContentType
+}
+
+func getContentType(codecs map[string]codec.Codec, ext string) (string, error) {
+	if cts, ok := ExtToTypes[ext]; ok {
+		for _, t := range cts {
+			if _, ok = codecs[t]; ok {
+				return t, nil
+			}
+		}
+	}
+	return "", ErrUnknownContentType
+}
+
+func getExt(name string) string {
+	ext := filepath.Ext(name)
+	if len(ext) > 0 && ext[0] == '.' {
+		ext = ext[1:]
+	}
+	return ext
+}
+
+func getNameWithoutExt(name string) string {
+	return strings.TrimSuffix(name, filepath.Ext(name))
+}
+
+func NewRequestFromFile(c client.Client, reqfile string) (client.Request, error) {
+	reqbuf, err := os.ReadFile(reqfile)
+	if err != nil {
+		return nil, err
+	}
+
+	endpoint := path.Base(path.Dir(reqfile))
+	if idx := strings.Index(endpoint, "_"); idx > 0 {
+		endpoint = endpoint[idx+1:]
+	}
+	ext := getExt(reqfile)
+
+	ct, err := getContentType(c.Options().Codecs, ext)
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.NewRequest("test", endpoint, &codec.Frame{Data: reqbuf}, client.RequestContentType(ct))
+
+	return req, nil
+}
+
+func SQLFromFile(m sqlmock.Sqlmock, name string) error {
+	fp, err := os.Open(name)
+	if err != nil {
+		return err
+	}
+	defer fp.Close()
+	return SQLFromReader(m, fp)
+}
+
+func SQLFromBytes(m sqlmock.Sqlmock, buf []byte) error {
+	return SQLFromReader(m, bytes.NewReader(buf))
+}
+
+func SQLFromString(m sqlmock.Sqlmock, buf string) error {
+	return SQLFromReader(m, strings.NewReader(buf))
+}
+
+func SQLFromReader(m sqlmock.Sqlmock, r io.Reader) error {
+	var rows *sqlmock.Rows
+	var exp *sqlmock.ExpectedQuery
+	var columns []*sqlmock.Column
+
+	br := bufio.NewReader(r)
+
+	for {
+		s, err := br.ReadString('\n')
+		if err != nil && err != io.EOF {
+			return err
+		} else if err == io.EOF && len(s) == 0 {
+			if rows != nil && exp != nil {
+				exp.WillReturnRows(rows)
+			}
+			return nil
+		}
+
+		if s[0] != '#' {
+			r := csv.NewReader(strings.NewReader(s))
+			r.Comma = ','
+			var records [][]string
+			records, err = r.ReadAll()
+			if err != nil {
+				return err
+			}
+			if rows == nil && len(columns) > 0 {
+				rows = m.NewRowsWithColumnDefinition(columns...)
+			} else {
+				for idx := 0; idx < len(records); idx++ {
+					if len(columns) == 0 {
+						return fmt.Errorf("csv file not valid, does not have %q line", "# columns ")
+					}
+					rows = FromCSVString(columns, rows, strings.Join(records[idx], ","))
+				}
+			}
+			continue
+		}
+
+		if rows != nil {
+			exp.WillReturnRows(rows)
+			rows = nil
+		}
+
+		switch {
+		case strings.HasPrefix(strings.ToLower(s[2:]), "columns"):
+			for _, field := range strings.Split(s[2+len("columns")+1:], ",") {
+				args := strings.Split(field, "|")
+
+				column := sqlmock.NewColumn(args[0]).Nullable(false)
+
+				if len(args) > 1 {
+					for _, arg := range args {
+						switch arg {
+						case "BOOLEAN", "BOOL":
+							column = column.OfType("BOOL", false)
+						case "NUMBER", "DECIMAL":
+							column = column.OfType("DECIMAL", float64(0.0)).WithPrecisionAndScale(10, 4)
+						case "VARCHAR":
+							column = column.OfType("VARCHAR", nil)
+						case "NULL":
+							column = column.Nullable(true)
+						}
+					}
+				}
+
+				columns = append(columns, column)
+			}
+		case strings.HasPrefix(strings.ToLower(s[2:]), "begin"):
+			m.ExpectBegin()
+		case strings.HasPrefix(strings.ToLower(s[2:]), "commit"):
+			m.ExpectCommit()
+		case strings.HasPrefix(strings.ToLower(s[2:]), "rollback"):
+			m.ExpectRollback()
+		case strings.HasPrefix(strings.ToLower(s[2:]), "exec "):
+			m.ExpectExec(s[2+len("exec "):])
+		case strings.HasPrefix(strings.ToLower(s[2:]), "query "):
+			exp = m.ExpectQuery(s[2+len("query "):])
+		}
+	}
+}
+
+func Run(ctx context.Context, c client.Client, m sqlmock.Sqlmock, dir string, exts []string) error {
+	tcases, err := GetCases(dir, exts)
+	if err != nil {
+		return err
+	}
+
+	g, gctx := errgroup.WithContext(ctx)
+	if !strings.Contains(dir, "parallel") {
+		g.SetLimit(1)
+	}
+
+	for _, tcase := range tcases {
+
+		for _, dbfile := range tcase.dbfiles {
+			if err = SQLFromFile(m, dbfile); err != nil {
+				return err
+			}
+		}
+
+		tc := tcase
+		g.Go(func() error {
+			var xrid string
+			var gerr error
+
+			treq, err := NewRequestFromFile(c, tc.reqfile)
+			if err != nil {
+				gerr = fmt.Errorf("failed to read request from file %s err: %w", tc.reqfile, err)
+				return gerr
+			}
+
+			xrid = fmt.Sprintf("%s-%d", treq.Endpoint(), time.Now().Unix())
+
+			defer func() {
+				if gerr == nil {
+					fmt.Printf("test %s xrid: %s status: success\n", filepath.Dir(tc.reqfile), xrid)
+				} else {
+					fmt.Printf("test %s xrid: %s status: failure error: %v\n", filepath.Dir(tc.reqfile), xrid, err)
+				}
+			}()
+
+			data := &codec.Frame{}
+			md := metadata.New(1)
+			md.Set("X-Request-Id", xrid)
+			cerr := c.Call(metadata.NewOutgoingContext(gctx, md), treq, data, client.WithContentType(treq.ContentType()))
+
+			var rspfile string
+
+			if tc.errfile != "" {
+				rspfile = tc.errfile
+			} else if tc.rspfile != "" {
+				rspfile = tc.rspfile
+			} else {
+				gerr = fmt.Errorf("errfile and rspfile is empty")
+				return gerr
+			}
+
+			expectRsp, err := NewResponseFromFile(rspfile)
+			if err != nil {
+				gerr = fmt.Errorf("failed to read response from file %s err: %w", rspfile, err)
+				return gerr
+			}
+
+			testCodec, err := getCodec(Codecs, getExt(tc.reqfile))
+			if err != nil {
+				gerr = fmt.Errorf("failed to get response file codec err: %w", err)
+				return gerr
+			}
+
+			expectCodec, err := getCodec(Codecs, getExt(rspfile))
+			if err != nil {
+				gerr = fmt.Errorf("failed to get response file codec err: %w", err)
+				return gerr
+			}
+
+			if cerr == nil && tc.errfile != "" {
+				gerr = fmt.Errorf("expected err %s not happened", expectRsp.Data)
+				return gerr
+			} else if cerr != nil && tc.errfile != "" {
+				if err = ResponseCompareFunc(expectRsp.Data, cerr, expectCodec, testCodec); err != nil {
+					gerr = err
+					return gerr
+				}
+			} else if cerr != nil && tc.errfile == "" {
+				gerr = cerr
+				return gerr
+			} else if cerr == nil && tc.errfile == "" {
+				if err = ResponseCompareFunc(expectRsp.Data, data, expectCodec, testCodec); err != nil {
+					gerr = err
+					return gerr
+				}
+			}
+
+			/*
+				cf, err := getCodec(c.Options().Codecs, getExt(tc.rspfile))
+				if err != nil {
+					return err
+				}
+			*/
+
+			return nil
+		})
+
+	}
+
+	return g.Wait()
+}
+
+type Case struct {
+	dbfiles []string
+	reqfile string
+	rspfile string
+	errfile string
+}
+
+func GetCases(dir string, exts []string) ([]Case, error) {
+	var tcases []Case
+	entries, err := os.ReadDir(dir)
+	if len(entries) == 0 && err != nil {
+		return tcases, err
+	}
+
+	if exts == nil {
+		exts = DefaultExts
+	}
+
+	var dirs []string
+	var dbfiles []string
+	var reqfile, rspfile, errfile string
+
+	for _, entry := range entries {
+		if entry.IsDir() {
+			dirs = append(dirs, filepath.Join(dir, entry.Name()))
+			continue
+		}
+		if info, err := entry.Info(); err != nil {
+			return tcases, err
+		} else if !info.Mode().IsRegular() {
+			continue
+		}
+
+		for _, ext := range exts {
+			if getExt(entry.Name()) == ext {
+				name := getNameWithoutExt(entry.Name())
+				switch {
+				case strings.HasSuffix(name, "_db"):
+					dbfiles = append(dbfiles, filepath.Join(dir, entry.Name()))
+				case strings.HasSuffix(name, "_req"):
+					reqfile = filepath.Join(dir, entry.Name())
+				case strings.HasSuffix(name, "_rsp"):
+					rspfile = filepath.Join(dir, entry.Name())
+				case strings.HasSuffix(name, "_err"):
+					errfile = filepath.Join(dir, entry.Name())
+				}
+			}
+		}
+	}
+
+	if reqfile != "" && (rspfile != "" || errfile != "") {
+		tcases = append(tcases, Case{dbfiles: dbfiles, reqfile: reqfile, rspfile: rspfile, errfile: errfile})
+	}
+
+	for _, dir = range dirs {
+		ntcases, err := GetCases(dir, exts)
+		if len(ntcases) == 0 && err != nil {
+			return tcases, err
+		} else if len(ntcases) == 0 {
+			continue
+		}
+		tcases = append(tcases, ntcases...)
+	}
+
+	return tcases, nil
+}

util/test/test_test.go

@@ -0,0 +1,72 @@
+package test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/DATA-DOG/go-sqlmock"
+)
+
+func Test_SQLFromFile(t *testing.T) {
+	ctx := context.TODO()
+	db, c, err := sqlmock.New()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	if err = SQLFromFile(c, "testdata/result/01_firstcase/Call_db.csv"); err != nil {
+		t.Fatal(err)
+	}
+
+	tx, err := db.BeginTx(ctx, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	rows, err := tx.QueryContext(ctx, "select * from test;")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for rows.Next() {
+		var id int64
+		var name string
+		err = rows.Scan(&id, &name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if id != 1 || name != "test" {
+			t.Fatalf("invalid rows %v %v", id, name)
+		}
+	}
+
+	if err = rows.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	if err = rows.Err(); err != nil {
+		t.Fatal(err)
+	}
+
+	if err = tx.Commit(); err != nil {
+		t.Fatal(err)
+	}
+	if err = c.ExpectationsWereMet(); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func Test_GetCases(t *testing.T) {
+	files, err := GetCases("testdata/", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(files) == 0 {
+		t.Fatalf("no files matching")
+	}
+
+	if n := len(files); n != 1 {
+		t.Fatalf("invalid number of test cases %d", n)
+	}
+}

util/test/testdata/result/01_firstcase/Call_db.csv

@@ -0,0 +1,6 @@
+# begin
+# query select \* from test;
+# columns id|VARCHAR,name|VARCHAR
+id,name
+1,test
+# commit

util/test/testdata/result/01_firstcase/Call_req.json

@@ -0,0 +1 @@
+{}

util/test/testdata/result/01_firstcase/Call_rsp.json

@@ -0,0 +1 @@
+{}

util/time/duration.go

@@ -2,7 +2,9 @@ package time
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
+	"strconv"
 	"time"
 )
 
@@ -13,39 +15,42 @@ func ParseDuration(s string) (time.Duration, error) {
 		return 0, fmt.Errorf(`time: invalid duration "` + s + `"`)
 	}
 
-	//var sb strings.Builder
-	/*
-		for i, r := range s {
-			switch r {
-			case 'd':
-				n, err := strconv.Atoi(s[idx:i])
-				if err != nil {
-					return 0, errors.New("time: invalid duration " + s)
-				}
-				s[idx:i] = fmt.Sprintf("%d", n*24)
-			default:
-				sb.WriteRune(r)
+	var p int
+	var hours int
+loop:
+	for i, r := range s {
+		switch r {
+		case 's', 'm':
+			break loop
+		case 'h':
+			d, err := strconv.Atoi(s[p:i])
+			if err != nil {
+				return 0, errors.New("time: invalid duration " + s)
 			}
-		}
-	*/
-	var td time.Duration
-	var err error
-	switch s[len(s)-1] {
-	case 's', 'm', 'h':
-		td, err = time.ParseDuration(s)
-	case 'd':
-		if td, err = time.ParseDuration(s[:len(s)-1] + "h"); err == nil {
-			td *= 24
-		}
-	case 'y':
-		if td, err = time.ParseDuration(s[:len(s)-1] + "h"); err == nil {
-			year := time.Date(time.Now().Year(), time.December, 31, 0, 0, 0, 0, time.Local)
-			days := year.YearDay()
-			td *= 24 * time.Duration(days)
+			hours += d
+			p = i + 1
+		case 'd':
+			d, err := strconv.Atoi(s[p:i])
+			if err != nil {
+				return 0, errors.New("time: invalid duration " + s)
+			}
+			hours += d * 24
+			p = i + 1
+		case 'y':
+			n, err := strconv.Atoi(s[p:i])
+			if err != nil {
+				return 0, errors.New("time: invalid duration " + s)
+			}
+			var d int
+			for j := n - 1; j >= 0; j-- {
+				d += time.Date(time.Now().Year()+j, time.December, 31, 0, 0, 0, 0, time.Local).YearDay()
+			}
+			hours += d * 24
+			p = i + 1
 		}
 	}
 
-	return td, err
+	return time.ParseDuration(fmt.Sprintf("%dh%s", hours, s[p:]))
 }
 
 func (d Duration) MarshalJSON() ([]byte, error) {
@@ -62,7 +67,7 @@ func (d *Duration) UnmarshalJSON(b []byte) error {
 		*d = Duration(time.Duration(value))
 		return nil
 	case string:
-		dv, err := time.ParseDuration(value)
+		dv, err := ParseDuration(value)
 		if err != nil {
 			return err
 		}

util/time/duration_test.go

@@ -23,32 +23,39 @@ func TestUnmarshalJSON(t *testing.T) {
 		TTL Duration `json:"ttl"`
 	}
 	v := &str{}
+	var err error
 
-	err := json.Unmarshal([]byte(`{"ttl":"10ms"}`), v)
+	err = json.Unmarshal([]byte(`{"ttl":"10ms"}`), v)
 	if err != nil {
 		t.Fatal(err)
 	} else if v.TTL != 10000000 {
 		t.Fatalf("invalid duration %v != 10000000", v.TTL)
 	}
+
+	err = json.Unmarshal([]byte(`{"ttl":"1y"}`), v)
+	if err != nil {
+		t.Fatal(err)
+	} else if v.TTL != 31622400000000000 {
+		t.Fatalf("invalid duration %v != 31622400000000000", v.TTL)
+	}
 }
 
 func TestParseDuration(t *testing.T) {
 	var td time.Duration
 	var err error
-	t.Skip()
+
 	td, err = ParseDuration("14d4h")
 	if err != nil {
 		t.Fatalf("ParseDuration error: %v", err)
 	}
-	if td.String() != "336h0m0s" {
-		t.Fatalf("ParseDuration 14d != 336h0m0s : %s", td.String())
+	if td.String() != "340h0m0s" {
+		t.Fatalf("ParseDuration 14d != 340h0m0s : %s", td.String())
 	}
-
 	td, err = ParseDuration("1y")
 	if err != nil {
 		t.Fatalf("ParseDuration error: %v", err)
 	}
-	if td.String() != "8760h0m0s" {
-		t.Fatalf("ParseDuration 1y != 8760h0m0s : %s", td.String())
+	if td.String() != "8784h0m0s" {
+		t.Fatalf("ParseDuration 1y != 8784h0m0s : %s", td.String())
 	}
 }