semconv: fix broker group lag metric name

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

.gitignore

@@ -1,6 +1,8 @@
 # Develop tools
 /.vscode/
 /.idea/
+.idea
+.vscode
 
 # Binaries for programs and plugins
 *.exe
@@ -13,6 +15,7 @@
 _obj
 _test
 _build
+.DS_Store
 
 # Architecture specific extensions/prefixes
 *.[568vq]

broker/broker.go

@@ -4,19 +4,22 @@ package broker // import "go.unistack.org/micro/v3/broker"
 import (
 	"context"
 	"errors"
+	"time"
 
 	"go.unistack.org/micro/v3/codec"
 	"go.unistack.org/micro/v3/metadata"
 )
 
 // DefaultBroker default memory broker
-var DefaultBroker = NewBroker()
+var DefaultBroker Broker = NewBroker()
 
 var (
 	// ErrNotConnected returns when broker used but not connected yet
 	ErrNotConnected = errors.New("broker not connected")
 	// ErrDisconnected returns when broker disconnected
 	ErrDisconnected = errors.New("broker disconnected")
+	// DefaultGracefulTimeout
+	DefaultGracefulTimeout = 5 * time.Second
 )
 
 // Broker is an interface used for asynchronous messaging.

broker/options.go

@@ -9,6 +9,7 @@ import (
 	"go.unistack.org/micro/v3/logger"
 	"go.unistack.org/micro/v3/meter"
 	"go.unistack.org/micro/v3/register"
+	"go.unistack.org/micro/v3/sync"
 	"go.unistack.org/micro/v3/tracer"
 )
 
@@ -36,17 +37,22 @@ type Options struct {
 	Name string
 	// Addrs holds the broker address
 	Addrs []string
+
+	Wait *sync.WaitGroup
+
+	GracefulTimeout time.Duration
 }
 
 // NewOptions create new Options
 func NewOptions(opts ...Option) Options {
 	options := Options{
-		Register: register.DefaultRegister,
-		Logger:   logger.DefaultLogger,
-		Context:  context.Background(),
-		Meter:    meter.DefaultMeter,
-		Codec:    codec.DefaultCodec,
-		Tracer:   tracer.DefaultTracer,
+		Register:        register.DefaultRegister,
+		Logger:          logger.DefaultLogger,
+		Context:         context.Background(),
+		Meter:           meter.DefaultMeter,
+		Codec:           codec.DefaultCodec,
+		Tracer:          tracer.DefaultTracer,
+		GracefulTimeout: DefaultGracefulTimeout,
 	}
 	for _, o := range opts {
 		o(&options)

cluster/cluster.go

@@ -0,0 +1,41 @@
+package cluster
+
+import (
+	"context"
+
+	"go.unistack.org/micro/v3/metadata"
+)
+
+// Message sent to member in cluster
+type Message interface {
+	// Header returns message headers
+	Header() metadata.Metadata
+	// Body returns broker message may be []byte slice or some go struct or interface
+	Body() interface{}
+}
+
+type Node interface {
+	// Name returns node name
+	Name() string
+	// Address returns node address
+	Address() string
+	// Metadata returns node metadata
+	Metadata() metadata.Metadata
+}
+
+// Cluster interface used for cluster communication across nodes
+type Cluster interface {
+	// Join is used to take an existing members and performing state sync
+	Join(ctx context.Context, addr ...string) error
+	// Leave broadcast a leave message and stop listeners
+	Leave(ctx context.Context) error
+	// Ping is used to probe live status of the node
+	Ping(ctx context.Context, node Node, payload []byte) error
+	// Members returns the cluster members
+	Members() ([]Node, error)
+	// Broadcast send message for all members in cluster, if filter is not nil, nodes may be filtered
+	// by key/value pairs
+	Broadcast(ctx context.Context, msg Message, filter ...string) error
+	// Unicast send message to single member in cluster
+	Unicast(ctx context.Context, node Node, msg Message) error
+}

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,8 +7,8 @@ import (
 	"strings"
 	"time"
 
+	"dario.cat/mergo"
 	"github.com/google/uuid"
-	"github.com/imdario/mergo"
 	mid "go.unistack.org/micro/v3/util/id"
 	rutil "go.unistack.org/micro/v3/util/reflect"
 	mtime "go.unistack.org/micro/v3/util/time"

go.mod

@@ -3,9 +3,9 @@ module go.unistack.org/micro/v3
 go 1.20
 
 require (
+	dario.cat/mergo v1.0.0
 	github.com/DATA-DOG/go-sqlmock v1.5.0
 	github.com/google/uuid v1.3.0
-	github.com/imdario/mergo v0.3.15
 	github.com/patrickmn/go-cache v2.1.0+incompatible
 	github.com/silas/dag v0.0.0-20220518035006-a7e85ada93c5
 	golang.org/x/sync v0.3.0

go.sum

@@ -1,3 +1,5 @@
+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=
@@ -7,8 +9,6 @@ github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 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/imdario/mergo v0.3.15 h1:M8XP7IuFNsqUx6VPK2P9OSmsYsI/YFaGil0uD21V3dM=
-github.com/imdario/mergo v0.3.15/go.mod h1:WBLT9ZmE3lPoWsEzCh9LPo3TiwVN+ZKEjmz+hD27ysY=
 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-20220518035006-a7e85ada93c5 h1:G/FZtUu7a6NTWl3KUHMV9jkLAh/Rvtf03NWMHaEDl+E=

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
@@ -67,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/options.go

@@ -3,7 +3,9 @@ package logger
 import (
 	"context"
 	"io"
+	"log/slog"
 	"os"
+	"time"
 )
 
 // Option func signature
@@ -21,27 +23,59 @@ type Options struct {
 	Fields []interface{}
 	// CallerSkipCount number of frmaes to skip
 	CallerSkipCount int
-	// Stacktrace controls writing of stacktaces on error
-	Stacktrace bool
+	// 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
+	// TimeFunc used to obtain current time
+	TimeFunc func() time.Time
 }
 
 // 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,
+		TimeFunc:         time.Now,
 	}
+
+	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) {
@@ -63,10 +97,17 @@ func WithOutput(out io.Writer) Option {
 	}
 }
 
-// WithStacktrace controls writing stacktrace on error
-func WithStacktrace(v bool) Option {
+// WitAddStacktrace controls writing stacktrace on error
+func WithAddStacktrace(v bool) Option {
 	return func(o *Options) {
-		o.Stacktrace = v
+		o.AddStacktrace = v
+	}
+}
+
+// WitAddSource controls writing source file and pos in log
+func WithAddSource(v bool) Option {
+	return func(o *Options) {
+		o.AddSource = v
 	}
 }
 
@@ -90,3 +131,54 @@ func WithName(n string) Option {
 		o.Name = n
 	}
 }
+
+// WithTimeFunc sets the func to obtain current time
+func WithTimeFunc(fn func() time.Time) Option {
+	return func(o *Options) {
+		o.TimeFunc = fn
+	}
+}
+
+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/options.go

@@ -1,27 +0,0 @@
-package slog
-
-import "go.unistack.org/micro/v3/logger"
-
-type sourceKey struct{}
-
-func WithSourceKey(v string) logger.Option {
-	return logger.SetOption(sourceKey{}, v)
-}
-
-type timeKey struct{}
-
-func WithTimeKey(v string) logger.Option {
-	return logger.SetOption(timeKey{}, v)
-}
-
-type messageKey struct{}
-
-func WithMessageKey(v string) logger.Option {
-	return logger.SetOption(messageKey{}, v)
-}
-
-type levelKey struct{}
-
-func WithLevelKey(v string) logger.Option {
-	return logger.SetOption(levelKey{}, v)
-}

logger/slog/slog.go

@@ -9,7 +9,6 @@ import (
 	"runtime"
 	"strconv"
 	"sync"
-	"time"
 
 	"go.unistack.org/micro/v3/logger"
 	"go.unistack.org/micro/v3/tracer"
@@ -17,13 +16,6 @@ import (
 
 var reTrace = regexp.MustCompile(`.*/slog/logger\.go.*\n`)
 
-var (
-	DefaultSourceKey  = slog.SourceKey
-	DefaultTimeKey    = slog.TimeKey
-	DefaultMessageKey = slog.MessageKey
-	DefaultLevelKey   = slog.LevelKey
-)
-
 var (
 	traceValue = slog.StringValue("trace")
 	debugValue = slog.StringValue("debug")
@@ -38,15 +30,15 @@ func (s *slogLogger) renameAttr(_ []string, a slog.Attr) slog.Attr {
 	case slog.SourceKey:
 		source := a.Value.Any().(*slog.Source)
 		a.Value = slog.StringValue(source.File + ":" + strconv.Itoa(source.Line))
-		a.Key = s.sourceKey
+		a.Key = s.opts.SourceKey
 	case slog.TimeKey:
-		a.Key = s.timeKey
+		a.Key = s.opts.TimeKey
 	case slog.MessageKey:
-		a.Key = s.messageKey
+		a.Key = s.opts.MessageKey
 	case slog.LevelKey:
 		level := a.Value.Any().(slog.Level)
 		lvl := slogToLoggerLevel(level)
-		a.Key = s.levelKey
+		a.Key = s.opts.LevelKey
 		switch {
 		case lvl < logger.DebugLevel:
 			a.Value = traceValue
@@ -69,56 +61,33 @@ func (s *slogLogger) renameAttr(_ []string, a slog.Attr) slog.Attr {
 }
 
 type slogLogger struct {
-	slog       *slog.Logger
-	leveler    *slog.LevelVar
-	levelKey   string
-	messageKey string
-	sourceKey  string
-	timeKey    string
-	opts       logger.Options
-	mu         sync.RWMutex
+	leveler *slog.LevelVar
+	handler slog.Handler
+	opts    logger.Options
+	mu      sync.RWMutex
 }
 
 func (s *slogLogger) Clone(opts ...logger.Option) logger.Logger {
 	s.mu.RLock()
 	options := s.opts
+	s.mu.RUnlock()
 
 	for _, o := range opts {
 		o(&options)
 	}
 
 	l := &slogLogger{
-		opts:       options,
-		levelKey:   s.levelKey,
-		messageKey: s.messageKey,
-		sourceKey:  s.sourceKey,
-		timeKey:    s.timeKey,
-	}
-
-	if v, ok := l.opts.Context.Value(levelKey{}).(string); ok && v != "" {
-		l.levelKey = v
-	}
-	if v, ok := l.opts.Context.Value(messageKey{}).(string); ok && v != "" {
-		l.messageKey = v
-	}
-	if v, ok := l.opts.Context.Value(sourceKey{}).(string); ok && v != "" {
-		l.sourceKey = v
-	}
-	if v, ok := l.opts.Context.Value(timeKey{}).(string); ok && v != "" {
-		l.timeKey = v
+		opts: options,
 	}
 
 	l.leveler = new(slog.LevelVar)
 	handleOpt := &slog.HandlerOptions{
-		ReplaceAttr: s.renameAttr,
+		ReplaceAttr: l.renameAttr,
 		Level:       l.leveler,
-		AddSource:   true,
+		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()
+	l.handler = slog.New(slog.NewJSONHandler(options.Out, handleOpt)).With(options.Fields...).Handler()
 
 	return l
 }
@@ -137,61 +106,44 @@ func (s *slogLogger) Options() logger.Options {
 
 func (s *slogLogger) Fields(attrs ...interface{}) logger.Logger {
 	s.mu.RLock()
-	nl := &slogLogger{
-		opts:       s.opts,
-		levelKey:   s.levelKey,
-		messageKey: s.messageKey,
-		sourceKey:  s.sourceKey,
-		timeKey:    s.timeKey,
-	}
-	nl.leveler = new(slog.LevelVar)
-	nl.leveler.Set(s.leveler.Level())
-
-	handleOpt := &slog.HandlerOptions{
-		ReplaceAttr: nl.renameAttr,
-		Level:       nl.leveler,
-		AddSource:   true,
-	}
-
-	handler := slog.NewJSONHandler(s.opts.Out, handleOpt)
-	nl.slog = slog.New(handler).With(attrs...)
-
+	level := s.leveler.Level()
+	options := s.opts
 	s.mu.RUnlock()
 
-	return nl
+	l := &slogLogger{opts: options}
+	l.leveler = new(slog.LevelVar)
+	l.leveler.Set(level)
+
+	handleOpt := &slog.HandlerOptions{
+		ReplaceAttr: l.renameAttr,
+		Level:       l.leveler,
+		AddSource:   l.opts.AddSource,
+	}
+
+	l.handler = slog.New(slog.NewJSONHandler(l.opts.Out, handleOpt)).With(attrs...).Handler()
+
+	return l
 }
 
 func (s *slogLogger) Init(opts ...logger.Option) error {
 	s.mu.Lock()
-	for _, o := range opts {
-		o(&s.opts)
+
+	if len(s.opts.ContextAttrFuncs) == 0 {
+		s.opts.ContextAttrFuncs = logger.DefaultContextAttrFuncs
 	}
 
-	if v, ok := s.opts.Context.Value(levelKey{}).(string); ok && v != "" {
-		s.levelKey = v
-	}
-	if v, ok := s.opts.Context.Value(messageKey{}).(string); ok && v != "" {
-		s.messageKey = v
-	}
-	if v, ok := s.opts.Context.Value(sourceKey{}).(string); ok && v != "" {
-		s.sourceKey = v
-	}
-	if v, ok := s.opts.Context.Value(timeKey{}).(string); ok && v != "" {
-		s.timeKey = v
+	for _, o := range opts {
+		o(&s.opts)
 	}
 
 	s.leveler = new(slog.LevelVar)
 	handleOpt := &slog.HandlerOptions{
 		ReplaceAttr: s.renameAttr,
 		Level:       s.leveler,
-		AddSource:   true,
+		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...)
-
-	slog.SetDefault(s.slog)
-
+	s.handler = slog.New(slog.NewJSONHandler(s.opts.Out, handleOpt)).With(s.opts.Fields...).Handler()
 	s.mu.Unlock()
 
 	return nil
@@ -203,9 +155,37 @@ func (s *slogLogger) Log(ctx context.Context, lvl logger.Level, attrs ...interfa
 	}
 	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])
-	// r.Add(attrs[1:]...)
-	_ = s.slog.Handler().Handle(ctx, r)
+	r := slog.NewRecord(s.opts.TimeFunc(), 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.handler.Handle(ctx, r)
 }
 
 func (s *slogLogger) Logf(ctx context.Context, lvl logger.Level, msg string, attrs ...interface{}) {
@@ -214,9 +194,37 @@ func (s *slogLogger) Logf(ctx context.Context, lvl logger.Level, msg string, att
 	}
 	var pcs [1]uintptr
 	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
-	r := slog.NewRecord(time.Now(), loggerToSlogLevel(lvl), fmt.Sprintf(msg, attrs...), pcs[0])
-	// r.Add(attrs...)
-	_ = s.slog.Handler().Handle(ctx, r)
+	r := slog.NewRecord(s.opts.TimeFunc(), 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.handler.Handle(ctx, r)
 }
 
 func (s *slogLogger) Info(ctx context.Context, attrs ...interface{}) {
@@ -225,9 +233,19 @@ func (s *slogLogger) Info(ctx context.Context, attrs ...interface{}) {
 	}
 	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])
-	// r.Add(attrs[1:]...)
-	_ = s.slog.Handler().Handle(ctx, r)
+	r := slog.NewRecord(s.opts.TimeFunc(), 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.handler.Handle(ctx, r)
 }
 
 func (s *slogLogger) Infof(ctx context.Context, msg string, attrs ...interface{}) {
@@ -236,9 +254,19 @@ func (s *slogLogger) Infof(ctx context.Context, msg string, attrs ...interface{}
 	}
 	var pcs [1]uintptr
 	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
-	r := slog.NewRecord(time.Now(), slog.LevelInfo, fmt.Sprintf(msg, attrs...), pcs[0])
-	// r.Add(attrs...)
-	_ = s.slog.Handler().Handle(ctx, r)
+	r := slog.NewRecord(s.opts.TimeFunc(), 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.handler.Handle(ctx, r)
 }
 
 func (s *slogLogger) Debug(ctx context.Context, attrs ...interface{}) {
@@ -247,9 +275,19 @@ func (s *slogLogger) Debug(ctx context.Context, attrs ...interface{}) {
 	}
 	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])
-	// r.Add(attrs[1:]...)
-	_ = s.slog.Handler().Handle(ctx, r)
+	r := slog.NewRecord(s.opts.TimeFunc(), 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.handler.Handle(ctx, r)
 }
 
 func (s *slogLogger) Debugf(ctx context.Context, msg string, attrs ...interface{}) {
@@ -258,9 +296,19 @@ func (s *slogLogger) Debugf(ctx context.Context, msg string, attrs ...interface{
 	}
 	var pcs [1]uintptr
 	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
-	r := slog.NewRecord(time.Now(), slog.LevelDebug, fmt.Sprintf(msg, attrs...), pcs[0])
-	// r.Add(attrs...)
-	_ = s.slog.Handler().Handle(ctx, r)
+	r := slog.NewRecord(s.opts.TimeFunc(), 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.handler.Handle(ctx, r)
 }
 
 func (s *slogLogger) Trace(ctx context.Context, attrs ...interface{}) {
@@ -269,9 +317,19 @@ func (s *slogLogger) Trace(ctx context.Context, attrs ...interface{}) {
 	}
 	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])
-	// r.Add(attrs[1:]...)
-	_ = s.slog.Handler().Handle(ctx, r)
+	r := slog.NewRecord(s.opts.TimeFunc(), 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.handler.Handle(ctx, r)
 }
 
 func (s *slogLogger) Tracef(ctx context.Context, msg string, attrs ...interface{}) {
@@ -280,9 +338,19 @@ func (s *slogLogger) Tracef(ctx context.Context, msg string, attrs ...interface{
 	}
 	var pcs [1]uintptr
 	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
-	r := slog.NewRecord(time.Now(), slog.LevelDebug-1, fmt.Sprintf(msg, attrs...), pcs[0])
-	// r.Add(attrs...)
-	_ = s.slog.Handler().Handle(ctx, r)
+	r := slog.NewRecord(s.opts.TimeFunc(), 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.handler.Handle(ctx, r)
 }
 
 func (s *slogLogger) Error(ctx context.Context, attrs ...interface{}) {
@@ -291,19 +359,29 @@ func (s *slogLogger) Error(ctx context.Context, attrs ...interface{}) {
 	}
 	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])
-	//	r.Add(attrs[1:]...)
-	if s.opts.Stacktrace {
+	r := slog.NewRecord(s.opts.TimeFunc(), 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 {
-				r.AddAttrs(slog.String("stacktrace", traceLines[len(traceLines)-1]))
+				attrs = append(attrs, slog.String("stacktrace", traceLines[len(traceLines)-1]))
 			}
 		}
 	}
+	r.Add(attrs[1:]...)
 	r.Attrs(func(a slog.Attr) bool {
-		if a.Key == "error" {
+		if a.Key == s.opts.ErrorKey {
 			if span, ok := tracer.SpanFromContext(ctx); ok {
 				span.SetStatus(tracer.SpanStatusError, a.Value.String())
 				return false
@@ -311,7 +389,7 @@ func (s *slogLogger) Error(ctx context.Context, attrs ...interface{}) {
 		}
 		return true
 	})
-	_ = s.slog.Handler().Handle(ctx, r)
+	_ = s.handler.Handle(ctx, r)
 }
 
 func (s *slogLogger) Errorf(ctx context.Context, msg string, attrs ...interface{}) {
@@ -320,19 +398,29 @@ func (s *slogLogger) Errorf(ctx context.Context, msg string, attrs ...interface{
 	}
 	var pcs [1]uintptr
 	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
-	r := slog.NewRecord(time.Now(), slog.LevelError, fmt.Sprintf(msg, attrs...), pcs[0])
-	// r.Add(attrs...)
-	if s.opts.Stacktrace {
+	r := slog.NewRecord(s.opts.TimeFunc(), 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 {
-				r.AddAttrs(slog.String("stacktrace", traceLines[len(traceLines)-1]))
+				attrs = append(attrs, slog.String("stacktrace", traceLines[len(traceLines)-1]))
 			}
 		}
 	}
+	r.Add(attrs...)
 	r.Attrs(func(a slog.Attr) bool {
-		if a.Key == "error" {
+		if a.Key == s.opts.ErrorKey {
 			if span, ok := tracer.SpanFromContext(ctx); ok {
 				span.SetStatus(tracer.SpanStatusError, a.Value.String())
 				return false
@@ -340,7 +428,7 @@ func (s *slogLogger) Errorf(ctx context.Context, msg string, attrs ...interface{
 		}
 		return true
 	})
-	_ = s.slog.Handler().Handle(ctx, r)
+	_ = s.handler.Handle(ctx, r)
 }
 
 func (s *slogLogger) Fatal(ctx context.Context, attrs ...interface{}) {
@@ -349,9 +437,19 @@ func (s *slogLogger) Fatal(ctx context.Context, attrs ...interface{}) {
 	}
 	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])
-	// r.Add(attrs[1:]...)
-	_ = s.slog.Handler().Handle(ctx, r)
+	r := slog.NewRecord(s.opts.TimeFunc(), 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.handler.Handle(ctx, r)
 	os.Exit(1)
 }
 
@@ -361,9 +459,19 @@ func (s *slogLogger) Fatalf(ctx context.Context, msg string, attrs ...interface{
 	}
 	var pcs [1]uintptr
 	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
-	r := slog.NewRecord(time.Now(), slog.LevelError+1, fmt.Sprintf(msg, attrs...), pcs[0])
-	// r.Add(attrs...)
-	_ = s.slog.Handler().Handle(ctx, r)
+	r := slog.NewRecord(s.opts.TimeFunc(), 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.handler.Handle(ctx, r)
 	os.Exit(1)
 }
 
@@ -373,9 +481,19 @@ func (s *slogLogger) Warn(ctx context.Context, attrs ...interface{}) {
 	}
 	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])
-	// r.Add(attrs[1:]...)
-	_ = s.slog.Handler().Handle(ctx, r)
+	r := slog.NewRecord(s.opts.TimeFunc(), 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.handler.Handle(ctx, r)
 }
 
 func (s *slogLogger) Warnf(ctx context.Context, msg string, attrs ...interface{}) {
@@ -384,9 +502,19 @@ func (s *slogLogger) Warnf(ctx context.Context, msg string, attrs ...interface{}
 	}
 	var pcs [1]uintptr
 	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, Infof]
-	r := slog.NewRecord(time.Now(), slog.LevelWarn, fmt.Sprintf(msg, attrs...), pcs[0])
-	// r.Add(attrs...)
-	_ = s.slog.Handler().Handle(ctx, r)
+	r := slog.NewRecord(s.opts.TimeFunc(), 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.handler.Handle(ctx, r)
 }
 
 func (s *slogLogger) Name() string {
@@ -399,24 +527,9 @@ func (s *slogLogger) String() string {
 
 func NewLogger(opts ...logger.Option) logger.Logger {
 	s := &slogLogger{
-		opts:       logger.NewOptions(opts...),
-		sourceKey:  DefaultSourceKey,
-		timeKey:    DefaultTimeKey,
-		messageKey: DefaultMessageKey,
-		levelKey:   DefaultLevelKey,
-	}
-	if v, ok := s.opts.Context.Value(levelKey{}).(string); ok && v != "" {
-		s.levelKey = v
-	}
-	if v, ok := s.opts.Context.Value(messageKey{}).(string); ok && v != "" {
-		s.messageKey = v
-	}
-	if v, ok := s.opts.Context.Value(sourceKey{}).(string); ok && v != "" {
-		s.sourceKey = v
-	}
-	if v, ok := s.opts.Context.Value(timeKey{}).(string); ok && v != "" {
-		s.timeKey = v
+		opts: logger.NewOptions(opts...),
 	}
+
 	return s
 }
 

logger/slog/slog_test.go

@@ -3,6 +3,7 @@ package slog
 import (
 	"bytes"
 	"context"
+	"fmt"
 	"log"
 	"testing"
 
@@ -12,15 +13,35 @@ import (
 func TestError(t *testing.T) {
 	ctx := context.TODO()
 	buf := bytes.NewBuffer(nil)
-	l := NewLogger(logger.WithLevel(logger.ErrorLevel), logger.WithOutput(buf), logger.WithStacktrace(true))
+	l := NewLogger(logger.WithLevel(logger.ErrorLevel), logger.WithOutput(buf), logger.WithAddStacktrace(true))
 	if err := l.Init(); err != nil {
 		t.Fatal(err)
 	}
 
-	l.Error(ctx, "message")
+	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.WithAddStacktrace(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) {

metadata/metadata.go

@@ -98,11 +98,12 @@ func (md Metadata) Del(keys ...string) {
 }
 
 // Copy makes a copy of the metadata
-func Copy(md Metadata) Metadata {
+func Copy(md Metadata, exclude ...string) Metadata {
 	nmd := New(len(md))
 	for key, val := range md {
 		nmd.Set(key, val)
 	}
+	nmd.Del(exclude...)
 	return nmd
 }
 

metadata/metadata_test.go

@@ -190,3 +190,14 @@ func TestMetadataContext(t *testing.T) {
 		t.Errorf("Expected metadata length 1 got %d", i)
 	}
 }
+
+func TestCopy(t *testing.T) {
+	md := New(2)
+	md.Set("key1", "val1", "key2", "val2")
+	nmd := Copy(md, "key2")
+	if len(nmd) != 1 {
+		t.Fatal("Copy exclude not works")
+	} else if nmd["Key1"] != "val1" {
+		t.Fatal("Copy exclude not works")
+	}
+}

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

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

semconv/broker.go

@@ -0,0 +1,22 @@
+package semconv
+
+var (
+	// PublishMessageDurationSeconds specifies meter metric name
+	PublishMessageDurationSeconds = "publish_message_duration_seconds"
+	// PublishMessageLatencyMicroseconds specifies meter metric name
+	PublishMessageLatencyMicroseconds = "publish_message_latency_microseconds"
+	// PublishMessageTotal specifies meter metric name
+	PublishMessageTotal = "publish_message_total"
+	// PublishMessageInflight specifies meter metric name
+	PublishMessageInflight = "publish_message_inflight"
+	// SubscribeMessageDurationSeconds specifies meter metric name
+	SubscribeMessageDurationSeconds = "subscribe_message_duration_seconds"
+	// SubscribeMessageLatencyMicroseconds specifies meter metric name
+	SubscribeMessageLatencyMicroseconds = "subscribe_message_latency_microseconds"
+	// SubscribeMessageTotal specifies meter metric name
+	SubscribeMessageTotal = "subscribe_message_total"
+	// SubscribeMessageInflight specifies meter metric name
+	SubscribeMessageInflight = "subscribe_message_inflight"
+	// BrokerGroupLag specifies broker lag
+	BrokerGroupLag = "broker_group_lag"
+)

semconv/client.go

@@ -0,0 +1,12 @@
+package semconv
+
+var (
+	// ClientRequestDurationSeconds specifies meter metric name
+	ClientRequestDurationSeconds = "client_request_duration_seconds"
+	// ClientRequestLatencyMicroseconds specifies meter metric name
+	ClientRequestLatencyMicroseconds = "client_request_latency_microseconds"
+	// ClientRequestTotal specifies meter metric name
+	ClientRequestTotal = "client_request_total"
+	// ClientRequestInflight specifies meter metric name
+	ClientRequestInflight = "client_request_inflight"
+)

semconv/server.go

@@ -0,0 +1,12 @@
+package semconv
+
+var (
+	// ServerRequestDurationSeconds specifies meter metric name
+	ServerRequestDurationSeconds = "server_request_duration_seconds"
+	// ServerRequestLatencyMicroseconds specifies meter metric name
+	ServerRequestLatencyMicroseconds = "server_request_latency_microseconds"
+	// ServerRequestTotal specifies meter metric name
+	ServerRequestTotal = "server_request_total"
+	// ServerRequestInflight specifies meter metric name
+	ServerRequestInflight = "server_request_inflight"
+)

server/options.go

@@ -15,6 +15,7 @@ import (
 	"go.unistack.org/micro/v3/network/transport"
 	"go.unistack.org/micro/v3/options"
 	"go.unistack.org/micro/v3/register"
+	msync "go.unistack.org/micro/v3/sync"
 	"go.unistack.org/micro/v3/tracer"
 	"go.unistack.org/micro/v3/util/id"
 )
@@ -47,7 +48,7 @@ type Options struct {
 	// Listener may be passed if already created
 	Listener net.Listener
 	// Wait group
-	Wait *sync.WaitGroup
+	Wait *msync.WaitGroup
 	// TLSConfig specifies tls.Config for secure serving
 	TLSConfig *tls.Config
 	// Metadata holds the server metadata
@@ -282,7 +283,7 @@ func Wait(wg *sync.WaitGroup) Option {
 		if wg == nil {
 			wg = new(sync.WaitGroup)
 		}
-		o.Wait = wg
+		o.Wait = msync.WrapWaitGroup(wg)
 	}
 }
 
@@ -331,7 +332,6 @@ func GracefulTimeout(td time.Duration) Option {
 	}
 }
 
-
 // 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

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 = "/"
 )

sync/waitgroup.go

@@ -0,0 +1,69 @@
+package sync
+
+import (
+	"context"
+	"sync"
+)
+
+type WaitGroup struct {
+	wg *sync.WaitGroup
+	c  int
+	mu sync.Mutex
+}
+
+func WrapWaitGroup(wg *sync.WaitGroup) *WaitGroup {
+	g := &WaitGroup{
+		wg: wg,
+	}
+	return g
+}
+
+func NewWaitGroup() *WaitGroup {
+	var wg sync.WaitGroup
+	return WrapWaitGroup(&wg)
+}
+
+func (g *WaitGroup) Add(n int) {
+	g.mu.Lock()
+	g.c += n
+	g.wg.Add(n)
+	g.mu.Unlock()
+}
+
+func (g *WaitGroup) Done() {
+	g.mu.Lock()
+	g.c += -1
+	g.wg.Add(-1)
+	g.mu.Unlock()
+}
+
+func (g *WaitGroup) Wait() {
+	g.wg.Wait()
+}
+
+func (g *WaitGroup) WaitContext(ctx context.Context) {
+	done := make(chan struct{})
+	go func() {
+		g.wg.Wait()
+		close(done)
+	}()
+
+	select {
+	case <-ctx.Done():
+		g.mu.Lock()
+		g.wg.Add(-g.c)
+		<-done
+		g.wg.Add(g.c)
+		g.mu.Unlock()
+		return
+	case <-done:
+		return
+	}
+}
+
+func (g *WaitGroup) Waiters() int {
+	g.mu.Lock()
+	c := g.c
+	g.mu.Unlock()
+	return c
+}

sync/waitgroup_test.go

@@ -0,0 +1,37 @@
+package sync
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+func TestWaitGroupContext(t *testing.T) {
+	wg := NewWaitGroup()
+	_ = t
+	wg.Add(1)
+	ctx, cancel := context.WithTimeout(context.TODO(), 1*time.Second)
+	defer cancel()
+	wg.WaitContext(ctx)
+}
+
+func TestWaitGroupReuse(t *testing.T) {
+	wg := NewWaitGroup()
+	defer func() {
+		if wg.Waiters() != 0 {
+			t.Fatal("lost goroutines")
+		}
+	}()
+
+	wg.Add(1)
+	defer wg.Done()
+	ctx, cancel := context.WithTimeout(context.TODO(), 1*time.Second)
+	defer cancel()
+	wg.WaitContext(ctx)
+
+	wg.Add(1)
+	defer wg.Done()
+	ctx, cancel = context.WithTimeout(context.TODO(), 1*time.Second)
+	defer cancel()
+	wg.WaitContext(ctx)
+}

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,6 +2,8 @@ package tracer
 
 import (
 	"context"
+
+	"go.unistack.org/micro/v3/util/id"
 )
 
 var _ Tracer = (*noopTracer)(nil)
@@ -24,6 +26,8 @@ func (t *noopTracer) Start(ctx context.Context, name string, opts ...SpanOption)
 		labels: options.Labels,
 		kind:   options.Kind,
 	}
+	span.spanID.s, _ = id.New()
+	span.traceID.s, _ = id.New()
 	if span.ctx == nil {
 		span.ctx = context.Background()
 	}
@@ -31,6 +35,14 @@ func (t *noopTracer) Start(ctx context.Context, name string, opts ...SpanOption)
 	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
 }
@@ -56,6 +68,8 @@ type noopSpan struct {
 	tracer    Tracer
 	name      string
 	statusMsg string
+	traceID   noopStringer
+	spanID    noopStringer
 	events    []*noopEvent
 	labels    []interface{}
 	logs      []interface{}
@@ -63,7 +77,15 @@ type noopSpan struct {
 	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 {

tracer/options.go

@@ -100,13 +100,13 @@ type EventOption func(o *EventOptions)
 
 func WithEventLabels(kv ...interface{}) EventOption {
 	return func(o *EventOptions) {
-		o.Labels = kv
+		o.Labels = append(o.Labels, kv...)
 	}
 }
 
 func WithSpanLabels(kv ...interface{}) SpanOption {
 	return func(o *SpanOptions) {
-		o.Labels = kv
+		o.Labels = append(o.Labels, kv...)
 	}
 }
 
@@ -159,7 +159,8 @@ func NewSpanOptions(opts ...SpanOption) SpanOptions {
 // NewOptions returns default options
 func NewOptions(opts ...Option) Options {
 	options := Options{
-		Logger: logger.DefaultLogger,
+		Logger:  logger.DefaultLogger,
+		Context: context.Background(),
 	}
 	for _, o := range opts {
 		o(&options)

tracer/tracer.go

@@ -3,12 +3,32 @@ 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 {
@@ -43,38 +63,8 @@ type Span interface {
 	AddLogs(kv ...interface{})
 	// Kind returns span kind
 	Kind() SpanKind
-}
-
-// 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
+	// TraceID returns trace id
+	TraceID() string
+	// SpanID returns span id
+	SpanID() string
 }

util/reflect/reflect.go

@@ -1,6 +1,7 @@
-package reflect // import "go.unistack.org/micro/v3/util/reflect"
+package reflect
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"reflect"
@@ -45,15 +46,23 @@ func SliceAppend(b bool) Option {
 
 // Merge merges map[string]interface{} to destination struct
 func Merge(dst interface{}, mp map[string]interface{}, opts ...Option) error {
-	var err error
-	var sval reflect.Value
-	var fname string
-
 	options := Options{}
 	for _, o := range opts {
 		o(&options)
 	}
 
+	if unmarshaler, ok := dst.(json.Unmarshaler); ok {
+		buf, err := json.Marshal(mp)
+		if err == nil {
+			err = unmarshaler.UnmarshalJSON(buf)
+		}
+		return err
+	}
+
+	var err error
+	var sval reflect.Value
+	var fname string
+
 	dviface := reflect.ValueOf(dst)
 	if dviface.Kind() == reflect.Ptr {
 		dviface = dviface.Elem()

util/sort/sort.go

@@ -0,0 +1,40 @@
+package sort
+
+import (
+	"fmt"
+	"sort"
+)
+
+// 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 Uniq(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
+}