Apply Code Coverage Badge

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

README.md

@@ -1,5 +1,5 @@
 # Micro
-![Coverage](https://img.shields.io/badge/Coverage-33.6%25-yellow)
+![Coverage](https://img.shields.io/badge/Coverage-33.8%25-yellow)
 [![License](https://img.shields.io/:license-apache-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![Doc](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/go.unistack.org/micro/v4?tab=overview)
 [![Status](https://git.unistack.org/unistack-org/micro/actions/workflows/job_tests.yml/badge.svg?branch=v4)](https://git.unistack.org/unistack-org/micro/actions?query=workflow%3Abuild+branch%3Av4+event%3Apush)

broker/broker.go

@@ -41,7 +41,7 @@ type Broker interface {
 	// Disconnect disconnect from broker
 	Disconnect(ctx context.Context) error
 	// NewMessage create new broker message to publish.
-	NewMessage(ctx context.Context, hdr metadata.Metadata, body interface{}, opts ...PublishOption) (Message, error)
+	NewMessage(ctx context.Context, hdr metadata.Metadata, body interface{}, opts ...MessageOption) (Message, error)
 	// Publish message to broker topic
 	Publish(ctx context.Context, topic string, messages ...Message) error
 	// Subscribe subscribes to topic message via handler

broker/context.go

@@ -42,9 +42,9 @@ func SetSubscribeOption(k, v interface{}) SubscribeOption {
 	}
 }
 
-// SetPublishOption returns a function to setup a context with given value
-func SetPublishOption(k, v interface{}) PublishOption {
-	return func(o *PublishOptions) {
+// SetMessageOption returns a function to setup a context with given value
+func SetMessageOption(k, v interface{}) MessageOption {
+	return func(o *MessageOptions) {
 		if o.Context == nil {
 			o.Context = context.Background()
 		}

broker/memory/memory.go

@@ -22,8 +22,8 @@ type Broker struct {
 	subscribers   map[string][]*Subscriber
 	addr          string
 	opts          broker.Options
-	sync.RWMutex
-	connected bool
+	mu            sync.RWMutex
+	connected     bool
 }
 
 type memoryMessage struct {
@@ -32,7 +32,7 @@ type memoryMessage struct {
 	ctx   context.Context
 	body  []byte
 	hdr   metadata.Metadata
-	opts  broker.PublishOptions
+	opts  broker.MessageOptions
 }
 
 func (m *memoryMessage) Ack() error {
@@ -72,9 +72,9 @@ func (b *Broker) newCodec(ct string) (codec.Codec, error) {
 	if idx := strings.IndexRune(ct, ';'); idx >= 0 {
 		ct = ct[:idx]
 	}
-	b.RLock()
+	b.mu.RLock()
 	c, ok := b.opts.Codecs[ct]
-	b.RUnlock()
+	b.mu.RUnlock()
 	if ok {
 		return c, nil
 	}
@@ -96,8 +96,8 @@ func (b *Broker) Connect(ctx context.Context) error {
 	default:
 	}
 
-	b.Lock()
-	defer b.Unlock()
+	b.mu.Lock()
+	defer b.mu.Unlock()
 
 	if b.connected {
 		return nil
@@ -126,8 +126,8 @@ func (b *Broker) Disconnect(ctx context.Context) error {
 	default:
 	}
 
-	b.Lock()
-	defer b.Unlock()
+	b.mu.Lock()
+	defer b.mu.Unlock()
 
 	if !b.connected {
 		return nil
@@ -157,8 +157,11 @@ func (b *Broker) Init(opts ...broker.Option) error {
 	return nil
 }
 
-func (b *Broker) NewMessage(ctx context.Context, hdr metadata.Metadata, body interface{}, opts ...broker.PublishOption) (broker.Message, error) {
-	options := broker.NewPublishOptions(opts...)
+func (b *Broker) NewMessage(ctx context.Context, hdr metadata.Metadata, body interface{}, opts ...broker.MessageOption) (broker.Message, error) {
+	options := broker.NewMessageOptions(opts...)
+	if options.ContentType == "" {
+		options.ContentType = b.opts.ContentType
+	}
 	m := &memoryMessage{ctx: ctx, hdr: hdr, opts: options}
 	c, err := b.newCodec(m.opts.ContentType)
 	if err == nil {
@@ -180,12 +183,12 @@ func (b *Broker) fnPublish(ctx context.Context, topic string, messages ...broker
 }
 
 func (b *Broker) publish(ctx context.Context, topic string, messages ...broker.Message) error {
-	b.RLock()
+	b.mu.RLock()
 	if !b.connected {
-		b.RUnlock()
+		b.mu.RUnlock()
 		return broker.ErrNotConnected
 	}
-	b.RUnlock()
+	b.mu.RUnlock()
 
 	select {
 	case <-ctx.Done():
@@ -193,9 +196,9 @@ func (b *Broker) publish(ctx context.Context, topic string, messages ...broker.M
 	default:
 	}
 
-	b.RLock()
+	b.mu.RLock()
 	subs, ok := b.subscribers[topic]
-	b.RUnlock()
+	b.mu.RUnlock()
 	if !ok {
 		return nil
 	}
@@ -252,12 +255,12 @@ func (b *Broker) fnSubscribe(ctx context.Context, topic string, handler interfac
 		return nil, err
 	}
 
-	b.RLock()
+	b.mu.RLock()
 	if !b.connected {
-		b.RUnlock()
+		b.mu.RUnlock()
 		return nil, broker.ErrNotConnected
 	}
-	b.RUnlock()
+	b.mu.RUnlock()
 
 	sid, err := id.New()
 	if err != nil {
@@ -275,13 +278,13 @@ func (b *Broker) fnSubscribe(ctx context.Context, topic string, handler interfac
 		ctx:     ctx,
 	}
 
-	b.Lock()
+	b.mu.Lock()
 	b.subscribers[topic] = append(b.subscribers[topic], sub)
-	b.Unlock()
+	b.mu.Unlock()
 
 	go func() {
 		<-sub.exit
-		b.Lock()
+		b.mu.Lock()
 		newSubscribers := make([]*Subscriber, 0, len(b.subscribers)-1)
 		for _, sb := range b.subscribers[topic] {
 			if sb.id == sub.id {
@@ -290,7 +293,7 @@ func (b *Broker) fnSubscribe(ctx context.Context, topic string, handler interfac
 			newSubscribers = append(newSubscribers, sb)
 		}
 		b.subscribers[topic] = newSubscribers
-		b.Unlock()
+		b.mu.Unlock()
 	}()
 
 	return sub, nil

broker/memory/memory_test.go

@@ -49,7 +49,7 @@ func TestMemoryBroker(t *testing.T) {
 				"id", fmt.Sprintf("%d", i),
 			),
 			[]byte(`"hello world"`),
-			broker.PublishContentType("application/octet-stream"),
+			broker.MessageContentType("application/octet-stream"),
 		)
 		if err != nil {
 			t.Fatal(err)

broker/noop.go

@@ -14,16 +14,16 @@ type NoopBroker struct {
 	funcPublish   FuncPublish
 	funcSubscribe FuncSubscribe
 	opts          Options
-	sync.RWMutex
+	mu            sync.RWMutex
 }
 
 func (b *NoopBroker) newCodec(ct string) (codec.Codec, error) {
 	if idx := strings.IndexRune(ct, ';'); idx >= 0 {
 		ct = ct[:idx]
 	}
-	b.RLock()
+	b.mu.RLock()
 	c, ok := b.opts.Codecs[ct]
-	b.RUnlock()
+	b.mu.RUnlock()
 	if ok {
 		return c, nil
 	}
@@ -99,7 +99,7 @@ type noopMessage struct {
 	ctx  context.Context
 	body []byte
 	hdr  metadata.Metadata
-	opts PublishOptions
+	opts MessageOptions
 }
 
 func (m *noopMessage) Ack() error {
@@ -126,8 +126,11 @@ func (m *noopMessage) Unmarshal(dst interface{}, opts ...codec.Option) error {
 	return m.c.Unmarshal(m.body, dst)
 }
 
-func (b *NoopBroker) NewMessage(ctx context.Context, hdr metadata.Metadata, body interface{}, opts ...PublishOption) (Message, error) {
-	options := NewPublishOptions(opts...)
+func (b *NoopBroker) NewMessage(ctx context.Context, hdr metadata.Metadata, body interface{}, opts ...MessageOption) (Message, error) {
+	options := NewMessageOptions(opts...)
+	if options.ContentType == "" {
+		options.ContentType = b.opts.ContentType
+	}
 	m := &noopMessage{ctx: ctx, hdr: hdr, opts: options}
 	c, err := b.newCodec(m.opts.ContentType)
 	if err == nil {

broker/options.go

@@ -45,6 +45,9 @@ type Options struct {
 
 	// GracefulTimeout contains time to wait to finish in flight requests
 	GracefulTimeout time.Duration
+
+	// ContentType will be used if no content-type set when creating message
+	ContentType string
 }
 
 // NewOptions create new Options
@@ -57,14 +60,19 @@ func NewOptions(opts ...Option) Options {
 		Codecs:          make(map[string]codec.Codec),
 		Tracer:          tracer.DefaultTracer,
 		GracefulTimeout: DefaultGracefulTimeout,
+		ContentType:     DefaultContentType,
 	}
 
 	for _, o := range opts {
 		o(&options)
 	}
+
 	return options
 }
 
+// DefaultContentType is the default content-type if not specified
+var DefaultContentType = ""
+
 // Context sets the context option
 func Context(ctx context.Context) Option {
 	return func(o *Options) {
@@ -72,8 +80,15 @@ func Context(ctx context.Context) Option {
 	}
 }
 
-// PublishOptions struct
-type PublishOptions struct {
+// ContentType used by default if not specified
+func ContentType(ct string) Option {
+	return func(o *Options) {
+		o.ContentType = ct
+	}
+}
+
+// MessageOptions struct
+type MessageOptions struct {
 	// ContentType for message body
 	ContentType string
 	// BodyOnly flag says the message contains raw body bytes and don't need
@@ -83,9 +98,9 @@ type PublishOptions struct {
 	Context context.Context
 }
 
-// NewPublishOptions creates PublishOptions struct
-func NewPublishOptions(opts ...PublishOption) PublishOptions {
-	options := PublishOptions{
+// NewMessageOptions creates MessageOptions struct
+func NewMessageOptions(opts ...MessageOption) MessageOptions {
+	options := MessageOptions{
 		Context: context.Background(),
 	}
 	for _, o := range opts {
@@ -113,19 +128,19 @@ type SubscribeOptions struct {
 // Option func
 type Option func(*Options)
 
-// PublishOption func
-type PublishOption func(*PublishOptions)
+// MessageOption func
+type MessageOption func(*MessageOptions)
 
-// PublishContentType sets message content-type that used to Marshal
-func PublishContentType(ct string) PublishOption {
-	return func(o *PublishOptions) {
+// MessageContentType sets message content-type that used to Marshal
+func MessageContentType(ct string) MessageOption {
+	return func(o *MessageOptions) {
 		o.ContentType = ct
 	}
 }
 
-// PublishBodyOnly publish only body of the message
-func PublishBodyOnly(b bool) PublishOption {
-	return func(o *PublishOptions) {
+// MessageBodyOnly publish only body of the message
+func MessageBodyOnly(b bool) MessageOption {
+	return func(o *MessageOptions) {
 		o.BodyOnly = b
 	}
 }

codec/codec.go

@@ -3,8 +3,6 @@ package codec
 
 import (
 	"errors"
-
-	"gopkg.in/yaml.v3"
 )
 
 var (
@@ -68,10 +66,10 @@ func (m *RawMessage) MarshalYAML() ([]byte, error) {
 }
 
 // UnmarshalYAML sets *m to a copy of data.
-func (m *RawMessage) UnmarshalYAML(n *yaml.Node) error {
+func (m *RawMessage) UnmarshalYAML(data []byte) error {
 	if m == nil {
 		return errors.New("RawMessage UnmarshalYAML on nil pointer")
 	}
-	*m = append((*m)[0:0], []byte(n.Value)...)
+	*m = append((*m)[0:0], data...)
 	return nil
 }

codec/frame.go

@@ -1,7 +1,5 @@
 package codec
 
-import "gopkg.in/yaml.v3"
-
 // Frame gives us the ability to define raw data to send over the pipes
 type Frame struct {
 	Data []byte
@@ -28,8 +26,8 @@ func (m *Frame) MarshalYAML() ([]byte, error) {
 }
 
 // UnmarshalYAML set frame data
-func (m *Frame) UnmarshalYAML(n *yaml.Node) error {
-	m.Data = []byte(n.Value)
+func (m *Frame) UnmarshalYAML(data []byte) error {
+	m.Data = append((m.Data)[0:0], data...)
 	return nil
 }
 

go.mod

@@ -6,6 +6,7 @@ require (
 	dario.cat/mergo v1.0.1
 	github.com/DATA-DOG/go-sqlmock v1.5.2
 	github.com/KimMachineGun/automemlimit v0.7.0
+	github.com/goccy/go-yaml v1.17.1
 	github.com/google/uuid v1.6.0
 	github.com/matoous/go-nanoid v1.5.1
 	github.com/patrickmn/go-cache v2.1.0+incompatible
@@ -18,7 +19,6 @@ require (
 	golang.org/x/sync v0.10.0
 	google.golang.org/grpc v1.69.4
 	google.golang.org/protobuf v1.36.3
-	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (
@@ -30,4 +30,5 @@ require (
 	golang.org/x/sys v0.29.0 // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20241216192217-9240e9c98484 // indirect
 	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -8,6 +8,8 @@ github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
 github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
+github.com/goccy/go-yaml v1.17.1 h1:LI34wktB2xEE3ONG/2Ar54+/HJVBriAGJ55PHls4YuY=
+github.com/goccy/go-yaml v1.17.1/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
 github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
 github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=

logger/slog/slog_test.go

@@ -80,7 +80,7 @@ func TestTime(t *testing.T) {
 		WithHandlerFunc(slog.NewTextHandler),
 		logger.WithAddStacktrace(true),
 		logger.WithTimeFunc(func() time.Time {
-			return time.Unix(0, 0)
+			return time.Unix(0, 0).UTC()
 		}),
 	)
 	if err := l.Init(logger.WithFields("key1", "val1")); err != nil {
@@ -89,8 +89,7 @@ func TestTime(t *testing.T) {
 
 	l.Error(ctx, "msg1", errors.New("err"))
 
-	if !bytes.Contains(buf.Bytes(), []byte(`timestamp=1970-01-01T03:00:00.000000000+03:00`)) &&
-		!bytes.Contains(buf.Bytes(), []byte(`timestamp=1970-01-01T00:00:00.000000000Z`)) {
+	if !bytes.Contains(buf.Bytes(), []byte(`timestamp=1970-01-01T00:00:00.000000000Z`)) {
 		t.Fatalf("logger error not works, buf contains: %s", buf.Bytes())
 	}
 }

meter/meter.go

@@ -4,8 +4,8 @@ package meter
 import (
 	"io"
 	"sort"
-	"strconv"
 	"strings"
+	"sync"
 	"time"
 )
 
@@ -117,6 +117,39 @@ func BuildLabels(labels ...string) []string {
 	return labels
 }
 
+var spool = newStringsPool(500)
+
+type stringsPool struct {
+	p *sync.Pool
+	c int
+}
+
+func newStringsPool(size int) *stringsPool {
+	p := &stringsPool{c: size}
+	p.p = &sync.Pool{
+		New: func() interface{} {
+			return &strings.Builder{}
+		},
+	}
+	return p
+}
+
+func (p *stringsPool) Cap() int {
+	return p.c
+}
+
+func (p *stringsPool) Get() *strings.Builder {
+	return p.p.Get().(*strings.Builder)
+}
+
+func (p *stringsPool) Put(b *strings.Builder) {
+	if b.Cap() > p.c {
+		return
+	}
+	b.Reset()
+	p.p.Put(b)
+}
+
 // BuildName used to combine metric with labels.
 // If labels count is odd, drop last element
 func BuildName(name string, labels ...string) string {
@@ -125,8 +158,6 @@ func BuildName(name string, labels ...string) string {
 	}
 
 	if len(labels) > 2 {
-		sort.Sort(byKey(labels))
-
 		idx := 0
 		for {
 			if labels[idx] == labels[idx+2] {
@@ -141,7 +172,9 @@ func BuildName(name string, labels ...string) string {
 		}
 	}
 
-	var b strings.Builder
+	b := spool.Get()
+	defer spool.Put(b)
+
 	_, _ = b.WriteString(name)
 	_, _ = b.WriteRune('{')
 	for idx := 0; idx < len(labels); idx += 2 {
@@ -149,8 +182,9 @@ func BuildName(name string, labels ...string) string {
 			_, _ = b.WriteRune(',')
 		}
 		_, _ = b.WriteString(labels[idx])
-		_, _ = b.WriteString(`=`)
-		_, _ = b.WriteString(strconv.Quote(labels[idx+1]))
+		_, _ = b.WriteString(`="`)
+		_, _ = b.WriteString(labels[idx+1])
+		_, _ = b.WriteRune('"')
 	}
 	_, _ = b.WriteRune('}')
 

meter/meter_test.go

@@ -50,11 +50,12 @@ func TestBuildName(t *testing.T) {
 	data := map[string][]string{
 		`my_metric{firstlabel="value2",zerolabel="value3"}`: {
 			"my_metric",
-			"zerolabel", "value3", "firstlabel", "value2",
+			"firstlabel", "value2",
+			"zerolabel", "value3",
 		},
 		`my_metric{broker="broker2",register="mdns",server="tcp"}`: {
 			"my_metric",
-			"broker", "broker1", "broker", "broker2", "server", "http", "server", "tcp", "register", "mdns",
+			"broker", "broker1", "broker", "broker2", "register", "mdns", "server", "http", "server", "tcp",
 		},
 		`my_metric{aaa="aaa"}`: {
 			"my_metric",

micro_test.go

@@ -91,7 +91,7 @@ func (p *bro) Connect(_ context.Context) error { return nil }
 func (p *bro) Disconnect(_ context.Context) error { return nil }
 
 // NewMessage creates new message
-func (p *bro) NewMessage(_ context.Context, _ metadata.Metadata, _ interface{}, _ ...broker.PublishOption) (broker.Message, error) {
+func (p *bro) NewMessage(_ context.Context, _ metadata.Metadata, _ interface{}, _ ...broker.MessageOption) (broker.Message, error) {
 	return nil, nil
 }
 

profiler/http/http.go

@@ -11,8 +11,8 @@ import (
 )
 
 type httpProfile struct {
-	server *http.Server
-	sync.Mutex
+	server  *http.Server
+	mu      sync.Mutex
 	running bool
 }
 
@@ -21,8 +21,8 @@ var DefaultAddress = ":6060"
 
 // Start the profiler
 func (h *httpProfile) Start() error {
-	h.Lock()
-	defer h.Unlock()
+	h.mu.Lock()
+	defer h.mu.Unlock()
 
 	if h.running {
 		return nil
@@ -30,9 +30,9 @@ func (h *httpProfile) Start() error {
 
 	go func() {
 		if err := h.server.ListenAndServe(); err != nil {
-			h.Lock()
+			h.mu.Lock()
 			h.running = false
-			h.Unlock()
+			h.mu.Unlock()
 		}
 	}()
 
@@ -43,8 +43,8 @@ func (h *httpProfile) Start() error {
 
 // Stop the profiler
 func (h *httpProfile) Stop() error {
-	h.Lock()
-	defer h.Unlock()
+	h.mu.Lock()
+	defer h.mu.Unlock()
 
 	if !h.running {
 		return nil

profiler/pprof/pprof.go

@@ -17,7 +17,7 @@ type profiler struct {
 	cpuFile *os.File
 	memFile *os.File
 	opts    profile.Options
-	sync.Mutex
+	mu      sync.Mutex
 	running bool
 }
 
@@ -39,8 +39,8 @@ func (p *profiler) writeHeap(f *os.File) {
 }
 
 func (p *profiler) Start() error {
-	p.Lock()
-	defer p.Unlock()
+	p.mu.Lock()
+	defer p.mu.Unlock()
 
 	if p.running {
 		return nil
@@ -86,8 +86,8 @@ func (p *profiler) Start() error {
 }
 
 func (p *profiler) Stop() error {
-	p.Lock()
-	defer p.Unlock()
+	p.mu.Lock()
+	defer p.mu.Unlock()
 
 	select {
 	case <-p.exit:

register/memory/memory.go

@@ -33,7 +33,7 @@ type memory struct {
 	records  map[string]services
 	watchers map[string]*watcher
 	opts     register.Options
-	sync.RWMutex
+	mu       sync.RWMutex
 }
 
 // services is a KV map with service name as the key and a map of records as the value
@@ -57,7 +57,7 @@ func (m *memory) ttlPrune() {
 	defer prune.Stop()
 
 	for range prune.C {
-		m.Lock()
+		m.mu.Lock()
 		for namespace, services := range m.records {
 			for service, versions := range services {
 				for version, record := range versions {
@@ -72,24 +72,24 @@ func (m *memory) ttlPrune() {
 				}
 			}
 		}
-		m.Unlock()
+		m.mu.Unlock()
 	}
 }
 
 func (m *memory) sendEvent(r *register.Result) {
-	m.RLock()
+	m.mu.RLock()
 	watchers := make([]*watcher, 0, len(m.watchers))
 	for _, w := range m.watchers {
 		watchers = append(watchers, w)
 	}
-	m.RUnlock()
+	m.mu.RUnlock()
 
 	for _, w := range watchers {
 		select {
 		case <-w.exit:
-			m.Lock()
+			m.mu.Lock()
 			delete(m.watchers, w.id)
-			m.Unlock()
+			m.mu.Unlock()
 		default:
 			select {
 			case w.res <- r:
@@ -113,8 +113,8 @@ func (m *memory) Init(opts ...register.Option) error {
 	}
 
 	// add services
-	m.Lock()
-	defer m.Unlock()
+	m.mu.Lock()
+	defer m.mu.Unlock()
 
 	return nil
 }
@@ -124,8 +124,8 @@ func (m *memory) Options() register.Options {
 }
 
 func (m *memory) Register(_ context.Context, s *register.Service, opts ...register.RegisterOption) error {
-	m.Lock()
-	defer m.Unlock()
+	m.mu.Lock()
+	defer m.mu.Unlock()
 
 	options := register.NewRegisterOptions(opts...)
 
@@ -197,8 +197,8 @@ func (m *memory) Register(_ context.Context, s *register.Service, opts ...regist
 }
 
 func (m *memory) Deregister(ctx context.Context, s *register.Service, opts ...register.DeregisterOption) error {
-	m.Lock()
-	defer m.Unlock()
+	m.mu.Lock()
+	defer m.mu.Unlock()
 
 	options := register.NewDeregisterOptions(opts...)
 
@@ -264,9 +264,9 @@ func (m *memory) LookupService(ctx context.Context, name string, opts ...registe
 
 	// if it's a wildcard domain, return from all domains
 	if options.Namespace == register.WildcardNamespace {
-		m.RLock()
+		m.mu.RLock()
 		recs := m.records
-		m.RUnlock()
+		m.mu.RUnlock()
 
 		var services []*register.Service
 
@@ -286,8 +286,8 @@ func (m *memory) LookupService(ctx context.Context, name string, opts ...registe
 		return services, nil
 	}
 
-	m.RLock()
-	defer m.RUnlock()
+	m.mu.RLock()
+	defer m.mu.RUnlock()
 
 	// check the domain exists
 	services, ok := m.records[options.Namespace]
@@ -319,9 +319,9 @@ func (m *memory) ListServices(ctx context.Context, opts ...register.ListOption)
 
 	// if it's a wildcard domain, list from all domains
 	if options.Namespace == register.WildcardNamespace {
-		m.RLock()
+		m.mu.RLock()
 		recs := m.records
-		m.RUnlock()
+		m.mu.RUnlock()
 
 		var services []*register.Service
 
@@ -336,8 +336,8 @@ func (m *memory) ListServices(ctx context.Context, opts ...register.ListOption)
 		return services, nil
 	}
 
-	m.RLock()
-	defer m.RUnlock()
+	m.mu.RLock()
+	defer m.mu.RUnlock()
 
 	// ensure the domain exists
 	services, ok := m.records[options.Namespace]
@@ -371,9 +371,9 @@ func (m *memory) Watch(ctx context.Context, opts ...register.WatchOption) (regis
 		wo:   wo,
 	}
 
-	m.Lock()
+	m.mu.Lock()
 	m.watchers[w.id] = w
-	m.Unlock()
+	m.mu.Unlock()
 
 	return w, nil
 }

server/noop.go

@@ -51,13 +51,13 @@ func (r *rpcHandler) Options() HandlerOptions {
 }
 
 type noopServer struct {
-	h        Handler
-	wg       *sync.WaitGroup
-	rsvc     *register.Service
-	handlers map[string]Handler
-	exit     chan chan error
-	opts     Options
-	sync.RWMutex
+	h          Handler
+	wg         *sync.WaitGroup
+	rsvc       *register.Service
+	handlers   map[string]Handler
+	exit       chan chan error
+	opts       Options
+	mu         sync.RWMutex
 	registered bool
 	started    bool
 }
@@ -125,10 +125,10 @@ func (n *noopServer) String() string {
 
 //nolint:gocyclo
 func (n *noopServer) Register() error {
-	n.RLock()
+	n.mu.RLock()
 	rsvc := n.rsvc
 	config := n.opts
-	n.RUnlock()
+	n.mu.RUnlock()
 
 	// if service already filled, reuse it and return early
 	if rsvc != nil {
@@ -144,9 +144,9 @@ func (n *noopServer) Register() error {
 		return err
 	}
 
-	n.RLock()
+	n.mu.RLock()
 	registered := n.registered
-	n.RUnlock()
+	n.mu.RUnlock()
 
 	if !registered {
 		if config.Logger.V(logger.InfoLevel) {
@@ -164,8 +164,8 @@ func (n *noopServer) Register() error {
 		return nil
 	}
 
-	n.Lock()
-	defer n.Unlock()
+	n.mu.Lock()
+	defer n.mu.Unlock()
 
 	n.registered = true
 	if cacheService {
@@ -178,9 +178,9 @@ func (n *noopServer) Register() error {
 func (n *noopServer) Deregister() error {
 	var err error
 
-	n.RLock()
+	n.mu.RLock()
 	config := n.opts
-	n.RUnlock()
+	n.mu.RUnlock()
 
 	service, err := NewRegisterService(n)
 	if err != nil {
@@ -195,29 +195,29 @@ func (n *noopServer) Deregister() error {
 		return err
 	}
 
-	n.Lock()
+	n.mu.Lock()
 	n.rsvc = nil
 
 	if !n.registered {
-		n.Unlock()
+		n.mu.Unlock()
 		return nil
 	}
 
 	n.registered = false
 
-	n.Unlock()
+	n.mu.Unlock()
 	return nil
 }
 
 //nolint:gocyclo
 func (n *noopServer) Start() error {
-	n.RLock()
+	n.mu.RLock()
 	if n.started {
-		n.RUnlock()
+		n.mu.RUnlock()
 		return nil
 	}
 	config := n.Options()
-	n.RUnlock()
+	n.mu.RUnlock()
 
 	// use 127.0.0.1 to avoid scan of all network interfaces
 	addr, err := maddr.Extract("127.0.0.1")
@@ -235,11 +235,11 @@ func (n *noopServer) Start() error {
 		config.Logger.Info(n.opts.Context, "server [noop] Listening on "+config.Address)
 	}
 
-	n.Lock()
+	n.mu.Lock()
 	if len(config.Advertise) == 0 {
 		config.Advertise = config.Address
 	}
-	n.Unlock()
+	n.mu.Unlock()
 
 	// use RegisterCheck func before register
 	// nolint: nestif
@@ -273,9 +273,9 @@ func (n *noopServer) Start() error {
 			select {
 			// register self on interval
 			case <-t.C:
-				n.RLock()
+				n.mu.RLock()
 				registered := n.registered
-				n.RUnlock()
+				n.mu.RUnlock()
 				rerr := config.RegisterCheck(config.Context)
 				// nolint: nestif
 				if rerr != nil && registered {
@@ -332,29 +332,29 @@ func (n *noopServer) Start() error {
 	}()
 
 	// mark the server as started
-	n.Lock()
+	n.mu.Lock()
 	n.started = true
-	n.Unlock()
+	n.mu.Unlock()
 
 	return nil
 }
 
 func (n *noopServer) Stop() error {
-	n.RLock()
+	n.mu.RLock()
 	if !n.started {
-		n.RUnlock()
+		n.mu.RUnlock()
 		return nil
 	}
-	n.RUnlock()
+	n.mu.RUnlock()
 
 	ch := make(chan error)
 	n.exit <- ch
 
 	err := <-ch
-	n.Lock()
+	n.mu.Lock()
 	n.rsvc = nil
 	n.started = false
-	n.Unlock()
+	n.mu.Unlock()
 
 	return err
 }

service.go

@@ -96,9 +96,9 @@ func RegisterHandler(s server.Server, h interface{}, opts ...server.HandlerOptio
 }
 
 type service struct {
-	done chan struct{}
-	opts Options
-	sync.RWMutex
+	done    chan struct{}
+	opts    Options
+	mu      sync.RWMutex
 	stopped bool
 }
 
@@ -321,9 +321,9 @@ func (s *service) Health() bool {
 func (s *service) Start() error {
 	var err error
 
-	s.RLock()
+	s.mu.RLock()
 	config := s.opts
-	s.RUnlock()
+	s.mu.RUnlock()
 
 	for _, cfg := range s.opts.Configs {
 		if cfg.Options().Struct == nil {
@@ -380,9 +380,9 @@ func (s *service) Start() error {
 }
 
 func (s *service) Stop() error {
-	s.RLock()
+	s.mu.RLock()
 	config := s.opts
-	s.RUnlock()
+	s.mu.RUnlock()
 
 	if config.Loggers[0].V(logger.InfoLevel) {
 		config.Loggers[0].Info(s.opts.Context, fmt.Sprintf("stoppping [service] %s", s.Name()))
@@ -457,13 +457,13 @@ func (s *service) Run() error {
 // notifyShutdown marks the service as stopped and closes the done channel.
 // It ensures the channel is closed only once, preventing multiple closures.
 func (s *service) notifyShutdown() {
-	s.Lock()
+	s.mu.Lock()
 	if s.stopped {
-		s.Unlock()
+		s.mu.Unlock()
 		return
 	}
 	s.stopped = true
-	s.Unlock()
+	s.mu.Unlock()
 
 	close(s.done)
 }

store/noop.go

@@ -139,7 +139,7 @@ func (n *noopStore) fnExists(ctx context.Context, _ string, _ ...ExistsOption) e
 		return ctx.Err()
 	default:
 	}
-	return nil
+	return ErrNotFound
 }
 
 func (n *noopStore) Write(ctx context.Context, key string, val interface{}, opts ...WriteOption) error {

store/noop_test.go

@@ -2,6 +2,7 @@ package store
 
 import (
 	"context"
+	"errors"
 	"testing"
 )
 
@@ -25,7 +26,8 @@ func TestHook(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if err := s.Exists(context.TODO(), "test"); err != nil {
+	err := s.Exists(context.TODO(), "test")
+	if !errors.Is(err, ErrNotFound) {
 		t.Fatal(err)
 	}
 

sync/memory.go

@@ -9,7 +9,7 @@ type memorySync struct {
 	locks   map[string]*memoryLock
 	options Options
 
-	mtx gosync.RWMutex
+	mu gosync.RWMutex
 }
 
 type memoryLock struct {
@@ -74,7 +74,7 @@ func (m *memorySync) Options() Options {
 
 func (m *memorySync) Lock(id string, opts ...LockOption) error {
 	// lock our access
-	m.mtx.Lock()
+	m.mu.Lock()
 
 	var options LockOptions
 	for _, o := range opts {
@@ -90,11 +90,11 @@ func (m *memorySync) Lock(id string, opts ...LockOption) error {
 			release: make(chan bool),
 		}
 		// unlock
-		m.mtx.Unlock()
+		m.mu.Unlock()
 		return nil
 	}
 
-	m.mtx.Unlock()
+	m.mu.Unlock()
 
 	// set wait time
 	var wait <-chan time.Time
@@ -124,12 +124,12 @@ lockLoop:
 		// wait for the lock to be released
 		select {
 		case <-lk.release:
-			m.mtx.Lock()
+			m.mu.Lock()
 
 			// someone locked before us
 			lk, ok = m.locks[id]
 			if ok {
-				m.mtx.Unlock()
+				m.mu.Unlock()
 				continue
 			}
 
@@ -141,7 +141,7 @@ lockLoop:
 				release: make(chan bool),
 			}
 
-			m.mtx.Unlock()
+			m.mu.Unlock()
 
 			break lockLoop
 		case <-ttl:
@@ -160,8 +160,8 @@ lockLoop:
 }
 
 func (m *memorySync) Unlock(id string) error {
-	m.mtx.Lock()
-	defer m.mtx.Unlock()
+	m.mu.Lock()
+	defer m.mu.Unlock()
 
 	lk, ok := m.locks[id]
 	// no lock exists

tracer/memory/memory.go

@@ -46,6 +46,10 @@ func (s memoryStringer) String() string {
 	return s.s
 }
 
+func (t *Tracer) Enabled() bool {
+	return t.opts.Enabled
+}
+
 func (t *Tracer) Flush(_ context.Context) error {
 	return nil
 }

tracer/noop.go

@@ -20,6 +20,10 @@ func (t *noopTracer) Spans() []Span {
 
 var uuidNil = uuid.Nil.String()
 
+func (t *noopTracer) Enabled() bool {
+	return t.opts.Enabled
+}
+
 func (t *noopTracer) Start(ctx context.Context, name string, opts ...SpanOption) (context.Context, Span) {
 	options := NewSpanOptions(opts...)
 	span := &noopSpan{

tracer/options.go

@@ -142,6 +142,8 @@ type Options struct {
 	Name string
 	// ContextAttrFuncs contains funcs that provides tracing
 	ContextAttrFuncs []ContextAttrFunc
+	// Enabled specify trace status
+	Enabled bool
 }
 
 // Option func signature
@@ -181,6 +183,7 @@ func NewOptions(opts ...Option) Options {
 		Logger:           logger.DefaultLogger,
 		Context:          context.Background(),
 		ContextAttrFuncs: DefaultContextAttrFuncs,
+		Enabled:          true,
 	}
 	for _, o := range opts {
 		o(&options)
@@ -194,3 +197,10 @@ func Name(n string) Option {
 		o.Name = n
 	}
 }
+
+// Disabled disable tracer
+func Disabled(b bool) Option {
+	return func(o *Options) {
+		o.Enabled = !b
+	}
+}

tracer/tracer.go

@@ -29,10 +29,10 @@ type ContextAttrFunc func(ctx context.Context) []interface{}
 func init() {
 	logger.DefaultContextAttrFuncs = append(logger.DefaultContextAttrFuncs,
 		func(ctx context.Context) []interface{} {
-			if span, ok := SpanFromContext(ctx); ok {
+			if sp, ok := SpanFromContext(ctx); ok && sp != nil && sp.IsRecording() {
 				return []interface{}{
-					TraceIDKey, span.TraceID(),
-					SpanIDKey, span.SpanID(),
+					TraceIDKey, sp.TraceID(),
+					SpanIDKey, sp.SpanID(),
 				}
 			}
 			return nil
@@ -51,6 +51,8 @@ type Tracer interface {
 	// Extract(ctx context.Context)
 	// Flush flushes spans
 	Flush(ctx context.Context) error
+	// Enabled returns tracer status
+	Enabled() bool
 }
 
 type Span interface {

util/buffer/seeker_buffer.go

@@ -1,13 +1,16 @@
 package buffer
 
-import "io"
+import (
+	"fmt"
+	"io"
+)
 
 var _ interface {
 	io.ReadCloser
 	io.ReadSeeker
 } = (*SeekerBuffer)(nil)
 
-// Buffer is a ReadWriteCloser that supports seeking. It's intended to
+// SeekerBuffer is a ReadWriteCloser that supports seeking. It's intended to
 // replicate the functionality of bytes.Buffer that I use in my projects.
 //
 // Note that the seeking is limited to the read marker; all writes are
@@ -23,6 +26,7 @@ func NewSeekerBuffer(data []byte) *SeekerBuffer {
 	}
 }
 
+// Read reads up to len(p) bytes into p from the current read position.
 func (b *SeekerBuffer) Read(p []byte) (int, error) {
 	if b.pos >= int64(len(b.data)) {
 		return 0, io.EOF
@@ -30,29 +34,51 @@ func (b *SeekerBuffer) Read(p []byte) (int, error) {
 
 	n := copy(p, b.data[b.pos:])
 	b.pos += int64(n)
+
 	return n, nil
 }
 
+// Write appends the contents of p to the end of the buffer. It does not affect the read position.
 func (b *SeekerBuffer) Write(p []byte) (int, error) {
+	if len(p) == 0 {
+		return 0, nil
+	}
+
 	b.data = append(b.data, p...)
+
 	return len(p), nil
 }
 
-// Seek sets the read pointer to pos.
+// Seek sets the offset for the next Read operation.
+// The offset is interpreted according to whence:
+// - io.SeekStart: relative to the beginning of the buffer
+// - io.SeekCurrent: relative to the current position
+// - io.SeekEnd: relative to the end of the buffer
+//
+// Returns an error if the resulting position is negative or if whence is invalid.
 func (b *SeekerBuffer) Seek(offset int64, whence int) (int64, error) {
+	var newPos int64
+
 	switch whence {
 	case io.SeekStart:
-		b.pos = offset
+		newPos = offset
 	case io.SeekEnd:
-		b.pos = int64(len(b.data)) + offset
+		newPos = int64(len(b.data)) + offset
 	case io.SeekCurrent:
-		b.pos += offset
+		newPos = b.pos + offset
+	default:
+		return 0, fmt.Errorf("invalid whence: %d", whence)
 	}
 
+	if newPos < 0 {
+		return 0, fmt.Errorf("invalid seek: resulting position %d is negative", newPos)
+	}
+
+	b.pos = newPos
 	return b.pos, nil
 }
 
-// Rewind resets the read pointer to 0.
+// Rewind resets the read position to 0.
 func (b *SeekerBuffer) Rewind() error {
 	if _, err := b.Seek(0, io.SeekStart); err != nil {
 		return err
@@ -67,12 +93,24 @@ func (b *SeekerBuffer) Close() error {
 	return nil
 }
 
+// Reset clears all the data out of the buffer and sets the read position to 0.
+func (b *SeekerBuffer) Reset() {
+	b.data = nil
+	b.pos = 0
+}
+
 // Len returns the length of data remaining to be read.
 func (b *SeekerBuffer) Len() int {
+	if b.pos >= int64(len(b.data)) {
+		return 0
+	}
 	return len(b.data[b.pos:])
 }
 
 // Bytes returns the underlying bytes from the current position.
 func (b *SeekerBuffer) Bytes() []byte {
+	if b.pos >= int64(len(b.data)) {
+		return []byte{}
+	}
 	return b.data[b.pos:]
 }

util/buffer/seeker_buffer_test.go

@@ -2,54 +2,384 @@ package buffer
 
 import (
 	"fmt"
-	"strings"
+	"io"
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
-func noErrorT(t *testing.T, err error) {
-	if nil != err {
-		t.Fatalf("%s", err)
+func TestNewSeekerBuffer(t *testing.T) {
+	input := []byte{'a', 'b', 'c', 'd', 'e'}
+	expected := &SeekerBuffer{data: []byte{'a', 'b', 'c', 'd', 'e'}, pos: 0}
+	require.Equal(t, expected, NewSeekerBuffer(input))
+}
+
+func TestSeekerBuffer_Read(t *testing.T) {
+	tests := []struct {
+		name         string
+		data         []byte
+		initPos      int64
+		readBuf      []byte
+		expectedN    int
+		expectedData []byte
+		expectedErr  error
+		expectedPos  int64
+	}{
+		{
+			name:         "read with empty buffer",
+			data:         []byte("hello"),
+			initPos:      0,
+			readBuf:      []byte{},
+			expectedN:    0,
+			expectedData: []byte{},
+			expectedErr:  nil,
+			expectedPos:  0,
+		},
+		{
+			name:         "read with nil buffer",
+			data:         []byte("hello"),
+			initPos:      0,
+			readBuf:      nil,
+			expectedN:    0,
+			expectedData: nil,
+			expectedErr:  nil,
+			expectedPos:  0,
+		},
+		{
+			name:         "read full buffer",
+			data:         []byte("hello"),
+			initPos:      0,
+			readBuf:      make([]byte, 5),
+			expectedN:    5,
+			expectedData: []byte("hello"),
+			expectedErr:  nil,
+			expectedPos:  5,
+		},
+		{
+			name:         "read partial buffer",
+			data:         []byte("hello"),
+			initPos:      2,
+			readBuf:      make([]byte, 2),
+			expectedN:    2,
+			expectedData: []byte("ll"),
+			expectedErr:  nil,
+			expectedPos:  4,
+		},
+		{
+			name:         "read after end",
+			data:         []byte("hello"),
+			initPos:      5,
+			readBuf:      make([]byte, 5),
+			expectedN:    0,
+			expectedData: make([]byte, 5),
+			expectedErr:  io.EOF,
+			expectedPos:  5,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sb := NewSeekerBuffer(tt.data)
+			sb.pos = tt.initPos
+
+			n, err := sb.Read(tt.readBuf)
+
+			if tt.expectedErr != nil {
+				require.Equal(t, err, tt.expectedErr)
+			} else {
+				require.NoError(t, err)
+			}
+
+			require.Equal(t, tt.expectedN, n)
+			require.Equal(t, tt.expectedData, tt.readBuf)
+			require.Equal(t, tt.expectedPos, sb.pos)
+		})
 	}
 }
 
-func boolT(t *testing.T, cond bool, s ...string) {
-	if !cond {
-		what := strings.Join(s, ", ")
-		if len(what) > 0 {
-			what = ": " + what
-		}
-		t.Fatalf("assert.Bool failed%s", what)
+func TestSeekerBuffer_Write(t *testing.T) {
+	tests := []struct {
+		name         string
+		initialData  []byte
+		initialPos   int64
+		writeData    []byte
+		expectedData []byte
+		expectedN    int
+	}{
+		{
+			name:         "write empty slice",
+			initialData:  []byte("data"),
+			initialPos:   0,
+			writeData:    []byte{},
+			expectedData: []byte("data"),
+			expectedN:    0,
+		},
+		{
+			name:         "write nil slice",
+			initialData:  []byte("data"),
+			initialPos:   0,
+			writeData:    nil,
+			expectedData: []byte("data"),
+			expectedN:    0,
+		},
+		{
+			name:         "write to empty buffer",
+			initialData:  nil,
+			initialPos:   0,
+			writeData:    []byte("abc"),
+			expectedData: []byte("abc"),
+			expectedN:    3,
+		},
+		{
+			name:         "write to existing buffer",
+			initialData:  []byte("hello"),
+			initialPos:   0,
+			writeData:    []byte(" world"),
+			expectedData: []byte("hello world"),
+			expectedN:    6,
+		},
+		{
+			name:         "write after read",
+			initialData:  []byte("abc"),
+			initialPos:   2,
+			writeData:    []byte("XYZ"),
+			expectedData: []byte("abcXYZ"),
+			expectedN:    3,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sb := NewSeekerBuffer(tt.initialData)
+			sb.pos = tt.initialPos
+
+			n, err := sb.Write(tt.writeData)
+			require.NoError(t, err)
+			require.Equal(t, tt.expectedN, n)
+			require.Equal(t, tt.expectedData, sb.data)
+			require.Equal(t, tt.initialPos, sb.pos)
+		})
 	}
 }
 
-func TestSeeking(t *testing.T) {
-	partA := []byte("hello, ")
-	partB := []byte("world!")
+func TestSeekerBuffer_Seek(t *testing.T) {
+	tests := []struct {
+		name        string
+		initialData []byte
+		initialPos  int64
+		offset      int64
+		whence      int
+		expectedPos int64
+		expectedErr error
+	}{
+		{
+			name:        "seek with invalid whence",
+			initialData: []byte("abcdef"),
+			initialPos:  0,
+			offset:      1,
+			whence:      12345,
+			expectedPos: 0,
+			expectedErr: fmt.Errorf("invalid whence: %d", 12345),
+		},
+		{
+			name:        "seek negative from start",
+			initialData: []byte("abcdef"),
+			initialPos:  0,
+			offset:      -1,
+			whence:      io.SeekStart,
+			expectedPos: 0,
+			expectedErr: fmt.Errorf("invalid seek: resulting position %d is negative", -1),
+		},
+		{
+			name:        "seek from start to 0",
+			initialData: []byte("abcdef"),
+			initialPos:  0,
+			offset:      0,
+			whence:      io.SeekStart,
+			expectedPos: 0,
+			expectedErr: nil,
+		},
+		{
+			name:        "seek from start to 3",
+			initialData: []byte("abcdef"),
+			initialPos:  0,
+			offset:      3,
+			whence:      io.SeekStart,
+			expectedPos: 3,
+			expectedErr: nil,
+		},
+		{
+			name:        "seek from end to -1 (last byte)",
+			initialData: []byte("abcdef"),
+			initialPos:  0,
+			offset:      -1,
+			whence:      io.SeekEnd,
+			expectedPos: 5,
+			expectedErr: nil,
+		},
+		{
+			name:        "seek from current forward",
+			initialData: []byte("abcdef"),
+			initialPos:  2,
+			offset:      2,
+			whence:      io.SeekCurrent,
+			expectedPos: 4,
+			expectedErr: nil,
+		},
+		{
+			name:        "seek from current backward",
+			initialData: []byte("abcdef"),
+			initialPos:  4,
+			offset:      -2,
+			whence:      io.SeekCurrent,
+			expectedPos: 2,
+			expectedErr: nil,
+		},
+		{
+			name:        "seek to end exactly",
+			initialData: []byte("abcdef"),
+			initialPos:  0,
+			offset:      0,
+			whence:      io.SeekEnd,
+			expectedPos: 6,
+			expectedErr: nil,
+		},
+		{
+			name:        "seek to out of range",
+			initialData: []byte("abcdef"),
+			initialPos:  0,
+			offset:      2,
+			whence:      io.SeekEnd,
+			expectedPos: 8,
+			expectedErr: nil,
+		},
+	}
 
-	buf := NewSeekerBuffer(partA)
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sb := NewSeekerBuffer(tt.initialData)
+			sb.pos = tt.initialPos
 
-	boolT(t, buf.Len() == len(partA), fmt.Sprintf("on init: have length %d, want length %d", buf.Len(), len(partA)))
+			newPos, err := sb.Seek(tt.offset, tt.whence)
 
-	b := make([]byte, 32)
-
-	n, err := buf.Read(b)
-	noErrorT(t, err)
-	boolT(t, buf.Len() == 0, fmt.Sprintf("after reading 1: have length %d, want length 0", buf.Len()))
-	boolT(t, n == len(partA), fmt.Sprintf("after reading 2: have length %d, want length %d", n, len(partA)))
-
-	n, err = buf.Write(partB)
-	noErrorT(t, err)
-	boolT(t, n == len(partB), fmt.Sprintf("after writing: have length %d, want length %d", n, len(partB)))
-
-	n, err = buf.Read(b)
-	noErrorT(t, err)
-	boolT(t, buf.Len() == 0, fmt.Sprintf("after rereading 1: have length %d, want length 0", buf.Len()))
-	boolT(t, n == len(partB), fmt.Sprintf("after rereading 2: have length %d, want length %d", n, len(partB)))
-
-	partsLen := len(partA) + len(partB)
-	_ = buf.Rewind()
-	boolT(t, buf.Len() == partsLen, fmt.Sprintf("after rewinding: have length %d, want length %d", buf.Len(), partsLen))
-
-	buf.Close()
-	boolT(t, buf.Len() == 0, fmt.Sprintf("after closing, have length %d, want length 0", buf.Len()))
+			if tt.expectedErr != nil {
+				require.Equal(t, tt.expectedErr, err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tt.expectedPos, newPos)
+				require.Equal(t, tt.expectedPos, sb.pos)
+			}
+		})
+	}
+}
+
+func TestSeekerBuffer_Rewind(t *testing.T) {
+	buf := NewSeekerBuffer([]byte("hello world"))
+	buf.pos = 4
+
+	require.NoError(t, buf.Rewind())
+	require.Equal(t, []byte("hello world"), buf.data)
+	require.Equal(t, int64(0), buf.pos)
+}
+
+func TestSeekerBuffer_Close(t *testing.T) {
+	buf := NewSeekerBuffer([]byte("hello world"))
+	buf.pos = 2
+
+	require.NoError(t, buf.Close())
+	require.Nil(t, buf.data)
+	require.Equal(t, int64(0), buf.pos)
+}
+
+func TestSeekerBuffer_Reset(t *testing.T) {
+	buf := NewSeekerBuffer([]byte("hello world"))
+	buf.pos = 2
+
+	buf.Reset()
+	require.Nil(t, buf.data)
+	require.Equal(t, int64(0), buf.pos)
+}
+
+func TestSeekerBuffer_Len(t *testing.T) {
+	tests := []struct {
+		name     string
+		data     []byte
+		pos      int64
+		expected int
+	}{
+		{
+			name:     "full buffer",
+			data:     []byte("abcde"),
+			pos:      0,
+			expected: 5,
+		},
+		{
+			name:     "partial read",
+			data:     []byte("abcde"),
+			pos:      2,
+			expected: 3,
+		},
+		{
+			name:     "fully read",
+			data:     []byte("abcde"),
+			pos:      5,
+			expected: 0,
+		},
+		{
+			name:     "pos > len",
+			data:     []byte("abcde"),
+			pos:      10,
+			expected: 0,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			buf := NewSeekerBuffer(tt.data)
+			buf.pos = tt.pos
+			require.Equal(t, tt.expected, buf.Len())
+		})
+	}
+}
+
+func TestSeekerBuffer_Bytes(t *testing.T) {
+	tests := []struct {
+		name     string
+		data     []byte
+		pos      int64
+		expected []byte
+	}{
+		{
+			name:     "start of buffer",
+			data:     []byte("abcde"),
+			pos:      0,
+			expected: []byte("abcde"),
+		},
+		{
+			name:     "middle of buffer",
+			data:     []byte("abcde"),
+			pos:      2,
+			expected: []byte("cde"),
+		},
+		{
+			name:     "end of buffer",
+			data:     []byte("abcde"),
+			pos:      5,
+			expected: []byte{},
+		},
+		{
+			name:     "pos beyond end",
+			data:     []byte("abcde"),
+			pos:      10,
+			expected: []byte{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			buf := NewSeekerBuffer(tt.data)
+			buf.pos = tt.pos
+			require.Equal(t, tt.expected, buf.Bytes())
+		})
+	}
 }

util/dns/cache.go

@@ -137,7 +137,7 @@ type cache struct {
 
 	opts Options
 
-	sync.RWMutex
+	mu sync.RWMutex
 }
 
 type cacheEntry struct {
@@ -171,7 +171,7 @@ func (c *cache) put(req string, res string) {
 		ttl = c.opts.MaxCacheTTL
 	}
 
-	c.Lock()
+	c.mu.Lock()
 	if c.entries == nil {
 		c.entries = make(map[string]cacheEntry)
 	}
@@ -207,7 +207,7 @@ func (c *cache) put(req string, res string) {
 	}
 
 	c.opts.Meter.Counter(semconv.CacheItemsTotal, "type", "dns").Inc()
-	c.Unlock()
+	c.mu.Unlock()
 }
 
 func (c *cache) get(req string) (res string) {
@@ -219,8 +219,8 @@ func (c *cache) get(req string) (res string) {
 		return ""
 	}
 
-	c.RLock()
-	defer c.RUnlock()
+	c.mu.RLock()
+	defer c.mu.RUnlock()
 
 	if c.entries == nil {
 		return ""

util/dns/conn.go

@@ -20,7 +20,7 @@ type dnsConn struct {
 	ibuf bytes.Buffer
 	obuf bytes.Buffer
 
-	sync.Mutex
+	mu sync.Mutex
 }
 
 type roundTripper func(ctx context.Context, req string) (res string, err error)
@@ -42,15 +42,15 @@ func (c *dnsConn) Read(b []byte) (n int, err error) {
 }
 
 func (c *dnsConn) Write(b []byte) (n int, err error) {
-	c.Lock()
-	defer c.Unlock()
+	c.mu.Lock()
+	defer c.mu.Unlock()
 	return c.ibuf.Write(b)
 }
 
 func (c *dnsConn) Close() error {
-	c.Lock()
+	c.mu.Lock()
 	cancel := c.cancel
-	c.Unlock()
+	c.mu.Unlock()
 
 	if cancel != nil {
 		cancel()
@@ -78,9 +78,9 @@ func (c *dnsConn) SetDeadline(t time.Time) error {
 }
 
 func (c *dnsConn) SetReadDeadline(t time.Time) error {
-	c.Lock()
+	c.mu.Lock()
 	c.deadline = t
-	c.Unlock()
+	c.mu.Unlock()
 	return nil
 }
 
@@ -90,8 +90,8 @@ func (c *dnsConn) SetWriteDeadline(_ time.Time) error {
 }
 
 func (c *dnsConn) drainBuffers(b []byte) (string, int, error) {
-	c.Lock()
-	defer c.Unlock()
+	c.mu.Lock()
+	defer c.mu.Unlock()
 
 	// drain the output buffer
 	if c.obuf.Len() > 0 {
@@ -119,8 +119,8 @@ func (c *dnsConn) drainBuffers(b []byte) (string, int, error) {
 }
 
 func (c *dnsConn) fillBuffer(b []byte, str string) (int, error) {
-	c.Lock()
-	defer c.Unlock()
+	c.mu.Lock()
+	defer c.mu.Unlock()
 	c.obuf.WriteByte(byte(len(str) >> 8))
 	c.obuf.WriteByte(byte(len(str)))
 	c.obuf.WriteString(str)
@@ -128,8 +128,8 @@ func (c *dnsConn) fillBuffer(b []byte, str string) (int, error) {
 }
 
 func (c *dnsConn) childContext() (context.Context, context.CancelFunc) {
-	c.Lock()
-	defer c.Unlock()
+	c.mu.Lock()
+	defer c.mu.Unlock()
 	if c.ctx == nil {
 		c.ctx, c.cancel = context.WithCancel(context.Background())
 	}

util/http/clienttracer.go

@@ -52,7 +52,7 @@ type clientTracer struct {
 	tr          tracer.Tracer
 	activeHooks map[string]context.Context
 	root        tracer.Span
-	mtx         sync.Mutex
+	mu          sync.Mutex
 }
 
 func NewClientTrace(ctx context.Context, tr tracer.Tracer) *httptrace.ClientTrace {
@@ -83,8 +83,8 @@ func NewClientTrace(ctx context.Context, tr tracer.Tracer) *httptrace.ClientTrac
 }
 
 func (ct *clientTracer) start(hook, spanName string, attrs ...interface{}) {
-	ct.mtx.Lock()
-	defer ct.mtx.Unlock()
+	ct.mu.Lock()
+	defer ct.mu.Unlock()
 
 	if hookCtx, found := ct.activeHooks[hook]; !found {
 		var sp tracer.Span
@@ -104,8 +104,8 @@ func (ct *clientTracer) start(hook, spanName string, attrs ...interface{}) {
 }
 
 func (ct *clientTracer) end(hook string, err error, attrs ...interface{}) {
-	ct.mtx.Lock()
-	defer ct.mtx.Unlock()
+	ct.mu.Lock()
+	defer ct.mu.Unlock()
 	if ctx, ok := ct.activeHooks[hook]; ok { // nolint:nestif
 		if span, ok := tracer.SpanFromContext(ctx); ok {
 			if err != nil {
@@ -136,8 +136,8 @@ func (ct *clientTracer) getParentContext(hook string) context.Context {
 }
 
 func (ct *clientTracer) span(hook string) (tracer.Span, bool) {
-	ct.mtx.Lock()
-	defer ct.mtx.Unlock()
+	ct.mu.Lock()
+	defer ct.mu.Unlock()
 	if ctx, ok := ct.activeHooks[hook]; ok {
 		return tracer.SpanFromContext(ctx)
 	}

util/ring/buffer.go

@@ -14,7 +14,7 @@ type Buffer struct {
 	vals    []*Entry
 	size    int
 
-	sync.RWMutex
+	mu sync.RWMutex
 }
 
 // Entry is ring buffer data entry
@@ -35,8 +35,8 @@ type Stream struct {
 
 // Put adds a new value to ring buffer
 func (b *Buffer) Put(v interface{}) {
-	b.Lock()
-	defer b.Unlock()
+	b.mu.Lock()
+	defer b.mu.Unlock()
 
 	// append to values
 	entry := &Entry{
@@ -63,8 +63,8 @@ func (b *Buffer) Put(v interface{}) {
 
 // Get returns the last n entries
 func (b *Buffer) Get(n int) []*Entry {
-	b.RLock()
-	defer b.RUnlock()
+	b.mu.RLock()
+	defer b.mu.RUnlock()
 
 	// reset any invalid values
 	if n > len(b.vals) || n < 0 {
@@ -80,8 +80,8 @@ func (b *Buffer) Get(n int) []*Entry {
 
 // Since returns the entries since a specific time
 func (b *Buffer) Since(t time.Time) []*Entry {
-	b.RLock()
-	defer b.RUnlock()
+	b.mu.RLock()
+	defer b.mu.RUnlock()
 
 	// return all the values
 	if t.IsZero() {
@@ -109,8 +109,8 @@ func (b *Buffer) Since(t time.Time) []*Entry {
 // Stream logs from the buffer
 // Close the channel when you want to stop
 func (b *Buffer) Stream() (<-chan *Entry, chan bool) {
-	b.Lock()
-	defer b.Unlock()
+	b.mu.Lock()
+	defer b.mu.Unlock()
 
 	entries := make(chan *Entry, 128)
 	id := id.MustNew()

util/stream/stream.go

@@ -24,7 +24,7 @@ type stream struct {
 	err     error
 	request *request
 
-	sync.RWMutex
+	mu sync.RWMutex
 }
 
 type request struct {
@@ -57,9 +57,9 @@ func (s *stream) Request() server.Request {
 func (s *stream) Send(v interface{}) error {
 	err := s.Stream.SendMsg(v)
 	if err != nil {
-		s.Lock()
+		s.mu.Lock()
 		s.err = err
-		s.Unlock()
+		s.mu.Unlock()
 	}
 	return err
 }
@@ -68,17 +68,17 @@ func (s *stream) Send(v interface{}) error {
 func (s *stream) Recv(v interface{}) error {
 	err := s.Stream.RecvMsg(v)
 	if err != nil {
-		s.Lock()
+		s.mu.Lock()
 		s.err = err
-		s.Unlock()
+		s.mu.Unlock()
 	}
 	return err
 }
 
 // Error returns error that stream holds
 func (s *stream) Error() error {
-	s.RLock()
-	defer s.RUnlock()
+	s.mu.RLock()
+	defer s.mu.RUnlock()
 	return s.err
 }
 

util/time/duration.go

@@ -6,7 +6,7 @@ import (
 	"strconv"
 	"time"
 
-	"gopkg.in/yaml.v3"
+	"github.com/goccy/go-yaml"
 )
 
 type Duration int64
@@ -58,9 +58,9 @@ func (d Duration) MarshalYAML() (interface{}, error) {
 	return time.Duration(d).String(), nil
 }
 
-func (d *Duration) UnmarshalYAML(n *yaml.Node) error {
+func (d *Duration) UnmarshalYAML(data []byte) error {
 	var v interface{}
-	if err := yaml.Unmarshal([]byte(n.Value), &v); err != nil {
+	if err := yaml.Unmarshal(data, &v); err != nil {
 		return err
 	}
 	switch value := v.(type) {

util/time/duration_test.go

@@ -6,7 +6,7 @@ import (
 	"testing"
 	"time"
 
-	"gopkg.in/yaml.v3"
+	"github.com/goccy/go-yaml"
 )
 
 func TestMarshalYAML(t *testing.T) {