diff --git a/.gitea/workflows/lint.yml b/.gitea/workflows/lint.yml
deleted file mode 100644
index 1cc293dc..00000000
--- a/.gitea/workflows/lint.yml
+++ /dev/null
@@ -1,24 +0,0 @@
-name: lint
-on:
-  pull_request:
-    branches:
-    - master
-    - v3
-jobs:
-  lint:
-    name: lint
-    runs-on: ubuntu-latest
-    steps:
-    - name: setup-go
-      uses: actions/setup-go@v3
-      with:
-        go-version: 1.21
-    - name: checkout
-      uses: actions/checkout@v3
-    - name: deps
-      run: go get -v -d ./...
-    - name: lint
-      uses: https://github.com/golangci/golangci-lint-action@v3.4.0
-      continue-on-error: true
-      with:
-        version: v1.52
diff --git a/.gitea/workflows/pipeline.yml b/.gitea/workflows/pipeline.yml
new file mode 100644
index 00000000..31f97f3b
--- /dev/null
+++ b/.gitea/workflows/pipeline.yml
@@ -0,0 +1,40 @@
+name: pipeline
+on:
+  pull_request:
+    branches:
+    - master
+    - v3
+    - v4
+jobs:
+  lint:
+    name: lint
+    runs-on: ubuntu-latest
+    steps:
+    - name: setup-go
+      uses: actions/setup-go@v5
+      with:
+        go-version: 'stable'
+    - name: checkout
+      uses: actions/checkout@v3
+    - name: deps
+      run: go get -v -d ./...
+    - name: lint
+      uses: https://github.com/golangci/golangci-lint-action@v6
+      with:
+        version: v1.62.2
+  test:
+    name: test
+    runs-on: ubuntu-latest
+    steps:
+    - name: setup-go
+      uses: actions/setup-go@v5
+      with:
+        go-version: 'stable'
+    - name: checkout
+      uses: actions/checkout@v3
+    - name: deps
+      run: go get -v -d ./...
+    - name: test
+      env:
+        INTEGRATION_TESTS: yes
+      run: go test -mod readonly -v ./...
diff --git a/.gitea/workflows/pr.yml b/.gitea/workflows/pr.yml
deleted file mode 100644
index b3e67b06..00000000
--- a/.gitea/workflows/pr.yml
+++ /dev/null
@@ -1,23 +0,0 @@
-name: pr
-on:
-  pull_request:
-    branches:
-    - master
-    - v3
-jobs:
-  test:
-    name: test
-    runs-on: ubuntu-latest
-    steps:
-    - name: checkout
-      uses: actions/checkout@v3
-    - name: setup-go
-      uses: actions/setup-go@v3
-      with:
-        go-version: 1.21
-    - name: deps
-      run: go get -v -t -d ./...
-    - name: test
-      env:
-        INTEGRATION_TESTS: yes
-      run: go test -mod readonly -v ./...
diff --git a/.golangci.yml b/.golangci.yml
index 524fc7f8..2bb1c300 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -1,44 +1,5 @@
 run:
-  concurrency: 4
+  concurrency: 8
   deadline: 5m
   issues-exit-code: 1
   tests: true
-
-linters-settings:
-  govet:
-    check-shadowing: true
-    enable:
-      - fieldalignment
-
-linters:
-  enable:
-    - govet
-    - deadcode
-    - errcheck
-    - govet
-    - ineffassign
-    - staticcheck
-    - structcheck
-    - typecheck
-    - unused
-    - varcheck
-    - bodyclose
-    - gci
-    - goconst
-    - gocritic
-    - gosimple
-    - gofmt
-    - gofumpt
-    - goimports
-    - revive
-    - gosec
-    - makezero
-    - misspell
-    - nakedret
-    - nestif
-    - nilerr
-    - noctx
-    - prealloc
-    - unconvert
-    - unparam
-  disable-all: false
diff --git a/client/noop.go b/client/noop.go
index 5fb8d571..ad0fc2a8 100644
--- a/client/noop.go
+++ b/client/noop.go
@@ -298,7 +298,7 @@ func (n *noopClient) fnCall(ctx context.Context, req Request, rsp interface{}, o
 		// call backoff first. Someone may want an initial start delay
 		t, err := callOpts.Backoff(ctx, req, i)
 		if err != nil {
-			return errors.InternalServerError("go.micro.client", err.Error())
+			return errors.InternalServerError("go.micro.client", "%s", err.Error())
 		}
 
 		// only sleep if greater than 0
@@ -312,7 +312,7 @@ func (n *noopClient) fnCall(ctx context.Context, req Request, rsp interface{}, o
 			// TODO apply any filtering here
 			routes, err = n.opts.Lookup(ctx, req, callOpts)
 			if err != nil {
-				return errors.InternalServerError("go.micro.client", err.Error())
+				return errors.InternalServerError("go.micro.client", "%s", err.Error())
 			}
 
 			// balance the list of nodes
@@ -466,7 +466,7 @@ func (n *noopClient) fnStream(ctx context.Context, req Request, opts ...CallOpti
 		// call backoff first. Someone may want an initial start delay
 		t, cerr := callOpts.Backoff(ctx, req, i)
 		if cerr != nil {
-			return nil, errors.InternalServerError("go.micro.client", cerr.Error())
+			return nil, errors.InternalServerError("go.micro.client", "%s", cerr.Error())
 		}
 
 		// only sleep if greater than 0
@@ -480,7 +480,7 @@ func (n *noopClient) fnStream(ctx context.Context, req Request, opts ...CallOpti
 			// TODO apply any filtering here
 			routes, err = n.opts.Lookup(ctx, req, callOpts)
 			if err != nil {
-				return nil, errors.InternalServerError("go.micro.client", err.Error())
+				return nil, errors.InternalServerError("go.micro.client", "%s", err.Error())
 			}
 
 			// balance the list of nodes
@@ -609,13 +609,13 @@ func (n *noopClient) publish(ctx context.Context, ps []Message, opts ...PublishO
 			// use codec for payload
 			cf, err := n.newCodec(p.ContentType())
 			if err != nil {
-				return errors.InternalServerError("go.micro.client", err.Error())
+				return errors.InternalServerError("go.micro.client", "%s", err.Error())
 			}
 
 			// set the body
 			b, err := cf.Marshal(p.Payload())
 			if err != nil {
-				return errors.InternalServerError("go.micro.client", err.Error())
+				return errors.InternalServerError("go.micro.client", "%s", err.Error())
 			}
 			body = b
 		}
diff --git a/errors/errors_test.go b/errors/errors_test.go
index 03c264c2..dd476637 100644
--- a/errors/errors_test.go
+++ b/errors/errors_test.go
@@ -2,6 +2,7 @@ package errors
 
 import (
 	"encoding/json"
+	"errors"
 	er "errors"
 	"fmt"
 	"net/http"
@@ -26,7 +27,7 @@ func TestMarshalJSON(t *testing.T) {
 func TestEmpty(t *testing.T) {
 	msg := "test"
 	var err *Error
-	err = FromError(fmt.Errorf(msg))
+	err = FromError(errors.New(msg))
 	if err.Detail != msg {
 		t.Fatalf("invalid error %v", err)
 	}
diff --git a/logger/slog/slog.go b/logger/slog/slog.go
index 4d3e8c06..4923e6a5 100644
--- a/logger/slog/slog.go
+++ b/logger/slog/slog.go
@@ -46,11 +46,11 @@ func (h *wrapper) Handle(ctx context.Context, rec slog.Record) error {
 }
 
 func (h *wrapper) WithAttrs(attrs []slog.Attr) slog.Handler {
-	return h.WithAttrs(attrs)
+	return h.h.WithAttrs(attrs)
 }
 
 func (h *wrapper) WithGroup(name string) slog.Handler {
-	return h.WithGroup(name)
+	return h.h.WithGroup(name)
 }
 
 func (s *slogLogger) renameAttr(_ []string, a slog.Attr) slog.Attr {
@@ -89,7 +89,6 @@ func (s *slogLogger) renameAttr(_ []string, a slog.Attr) slog.Attr {
 }
 
 type slogLogger struct {
-	leveler *slog.LevelVar
 	handler *wrapper
 	opts    logger.Options
 	mu      sync.RWMutex
diff --git a/logger/unwrap/unwrap.go b/logger/unwrap/unwrap.go
index 93be44d4..5cfcf167 100644
--- a/logger/unwrap/unwrap.go
+++ b/logger/unwrap/unwrap.go
@@ -36,14 +36,14 @@ var (
 	circularShortBytes = []byte("<shown>")
 	invalidAngleBytes  = []byte("<invalid>")
 	filteredBytes      = []byte("<filtered>")
-	openBracketBytes   = []byte("[")
-	closeBracketBytes  = []byte("]")
-	percentBytes       = []byte("%")
-	precisionBytes     = []byte(".")
-	openAngleBytes     = []byte("<")
-	closeAngleBytes    = []byte(">")
-	openMapBytes       = []byte("{")
-	closeMapBytes      = []byte("}")
+	// openBracketBytes   = []byte("[")
+	// closeBracketBytes  = []byte("]")
+	percentBytes    = []byte("%")
+	precisionBytes  = []byte(".")
+	openAngleBytes  = []byte("<")
+	closeAngleBytes = []byte(">")
+	openMapBytes    = []byte("{")
+	closeMapBytes   = []byte("}")
 )
 
 type protoMessage interface {
diff --git a/logger/unwrap/unwrap_test.go b/logger/unwrap/unwrap_test.go
index 3161c342..af55db0a 100644
--- a/logger/unwrap/unwrap_test.go
+++ b/logger/unwrap/unwrap_test.go
@@ -82,12 +82,12 @@ func TestTagged(t *testing.T) {
 func TestTaggedNested(t *testing.T) {
 	type val struct {
 		key string `logger:"take"`
-		val string `logger:"omit"`
+		// val string `logger:"omit"`
 		unk string
 	}
 	type str struct {
-		key string `logger:"omit"`
-		val *val   `logger:"take"`
+		// key string `logger:"omit"`
+		val *val `logger:"take"`
 	}
 
 	var iface interface{}
diff --git a/metadata/metadata_test.go b/metadata/metadata_test.go
index 28cf93b7..7b6eb885 100644
--- a/metadata/metadata_test.go
+++ b/metadata/metadata_test.go
@@ -83,6 +83,7 @@ func TestPassing(t *testing.T) {
 	if ok {
 		t.Fatalf("create outgoing context")
 	}
+	_ = md
 
 	ctx = NewOutgoingContext(ctx, New(1))
 	testCtx(ctx)
diff --git a/micro.go b/micro.go
index 20295601..e2dc1e62 100644
--- a/micro.go
+++ b/micro.go
@@ -65,6 +65,8 @@ func As(b any, target any) bool {
 			break
 		case targetType.Implements(routerType):
 			break
+		case targetType.Implements(tracerType):
+			break
 		default:
 			return false
 		}
@@ -76,19 +78,21 @@ func As(b any, target any) bool {
 	return false
 }
 
-var brokerType = reflect.TypeOf((*broker.Broker)(nil)).Elem()
-var loggerType = reflect.TypeOf((*logger.Logger)(nil)).Elem()
-var clientType = reflect.TypeOf((*client.Client)(nil)).Elem()
-var serverType = reflect.TypeOf((*server.Server)(nil)).Elem()
-var codecType = reflect.TypeOf((*codec.Codec)(nil)).Elem()
-var flowType = reflect.TypeOf((*flow.Flow)(nil)).Elem()
-var fsmType = reflect.TypeOf((*fsm.FSM)(nil)).Elem()
-var meterType = reflect.TypeOf((*meter.Meter)(nil)).Elem()
-var registerType = reflect.TypeOf((*register.Register)(nil)).Elem()
-var resolverType = reflect.TypeOf((*resolver.Resolver)(nil)).Elem()
-var routerType = reflect.TypeOf((*router.Router)(nil)).Elem()
-var selectorType = reflect.TypeOf((*selector.Selector)(nil)).Elem()
-var storeType = reflect.TypeOf((*store.Store)(nil)).Elem()
-var syncType = reflect.TypeOf((*sync.Sync)(nil)).Elem()
-var tracerType = reflect.TypeOf((*tracer.Tracer)(nil)).Elem()
-var serviceType = reflect.TypeOf((*Service)(nil)).Elem()
+var (
+	brokerType   = reflect.TypeOf((*broker.Broker)(nil)).Elem()
+	loggerType   = reflect.TypeOf((*logger.Logger)(nil)).Elem()
+	clientType   = reflect.TypeOf((*client.Client)(nil)).Elem()
+	serverType   = reflect.TypeOf((*server.Server)(nil)).Elem()
+	codecType    = reflect.TypeOf((*codec.Codec)(nil)).Elem()
+	flowType     = reflect.TypeOf((*flow.Flow)(nil)).Elem()
+	fsmType      = reflect.TypeOf((*fsm.FSM)(nil)).Elem()
+	meterType    = reflect.TypeOf((*meter.Meter)(nil)).Elem()
+	registerType = reflect.TypeOf((*register.Register)(nil)).Elem()
+	resolverType = reflect.TypeOf((*resolver.Resolver)(nil)).Elem()
+	routerType   = reflect.TypeOf((*router.Router)(nil)).Elem()
+	selectorType = reflect.TypeOf((*selector.Selector)(nil)).Elem()
+	storeType    = reflect.TypeOf((*store.Store)(nil)).Elem()
+	syncType     = reflect.TypeOf((*sync.Sync)(nil)).Elem()
+	tracerType   = reflect.TypeOf((*tracer.Tracer)(nil)).Elem()
+	serviceType  = reflect.TypeOf((*Service)(nil)).Elem()
+)
diff --git a/options.go b/options.go
index 97adbf5e..cee1b9bb 100644
--- a/options.go
+++ b/options.go
@@ -269,7 +269,7 @@ func Logger(l logger.Logger, opts ...LoggerOption) Option {
 				}
 			}
 		}
-		
+
 		for _, trc := range o.Tracers {
 			for _, ot := range lopts.tracers {
 				if trc.Name() == ot || all {
@@ -294,8 +294,8 @@ type loggerOptions struct {
 	brokers   []string
 	registers []string
 	stores    []string
-	meters    []string
-	tracers   []string
+	// meters    []string
+	tracers []string
 }
 
 /*
diff --git a/register/memory/memory.go b/register/memory/memory.go
index ed241c4f..1784a53c 100644
--- a/register/memory/memory.go
+++ b/register/memory/memory.go
@@ -469,9 +469,7 @@ func serviceToRecord(s *register.Service, ttl time.Duration) *record {
 	}
 
 	endpoints := make([]*register.Endpoint, len(s.Endpoints))
-	for i, e := range s.Endpoints {
-		endpoints[i] = e
-	}
+	copy(endpoints, s.Endpoints)
 
 	return &record{
 		Name:      s.Name,
diff --git a/register/memory/memory_test.go b/register/memory/memory_test.go
index 2210b3f6..04502460 100644
--- a/register/memory/memory_test.go
+++ b/register/memory/memory_test.go
@@ -290,27 +290,25 @@ func TestWatcher(t *testing.T) {
 
 	ctx := context.TODO()
 	m := NewRegister()
-	m.Init()
-	m.Connect(ctx)
+	_ = m.Init()
+	_ = m.Connect(ctx)
 	wc, err := m.Watch(ctx)
 	if err != nil {
 		t.Fatalf("cant watch: %v", err)
 	}
 	defer wc.Stop()
 
+	cherr := make(chan error, 10)
 	var wg sync.WaitGroup
 	wg.Add(1)
 	go func() {
-		for {
-			_, err := wc.Next()
-			if err != nil {
-				t.Fatal("unexpected err", err)
-			}
-			// t.Logf("changes %#+v", ch.Service)
-			wc.Stop()
-			wg.Done()
-			return
+		_, err := wc.Next()
+		if err != nil {
+			cherr <- fmt.Errorf("unexpected err %v", err)
 		}
+		// t.Logf("changes %#+v", ch.Service)
+		wc.Stop()
+		wg.Done()
 	}()
 
 	if err := m.Register(ctx, testSrv); err != nil {
diff --git a/server/noop.go b/server/noop.go
index 86fcfeb9..8fd15791 100644
--- a/server/noop.go
+++ b/server/noop.go
@@ -171,7 +171,6 @@ type rpcMessage struct {
 	header      metadata.Metadata
 	topic       string
 	contentType string
-	body        []byte
 }
 
 func (r *rpcMessage) ContentType() string {
diff --git a/server/noop_test.go b/server/noop_test.go
index 2bad82e6..8b44a1e0 100644
--- a/server/noop_test.go
+++ b/server/noop_test.go
@@ -38,7 +38,7 @@ func TestNoopSub(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	logger.DefaultLogger.Init(logger.WithLevel(logger.ErrorLevel))
+	_ = logger.DefaultLogger.Init(logger.WithLevel(logger.ErrorLevel))
 	s := server.NewServer(
 		server.Broker(b),
 		server.Codec("application/octet-stream", codec.NewCodec()),
diff --git a/service.go b/service.go
index 3c782035..469e823c 100644
--- a/service.go
+++ b/service.go
@@ -23,8 +23,8 @@ import (
 )
 
 func init() {
-	maxprocs.Set()
-	memlimit.SetGoMemLimitWithOpts(
+	_, _ = maxprocs.Set()
+	_, _ = memlimit.SetGoMemLimitWithOpts(
 		memlimit.WithRatio(0.9),
 		memlimit.WithProvider(
 			memlimit.ApplyFallback(
diff --git a/store/store.go b/store/store.go
index c5b8ac3e..fcd0c987 100644
--- a/store/store.go
+++ b/store/store.go
@@ -105,3 +105,7 @@ func NewWatchOptions(opts ...WatchOption) (WatchOptions, error) {
 
 	return options, err
 }
+
+func Watch(context.Context) (Watcher, error) {
+	return nil, nil
+}
diff --git a/util/dns/conn.go b/util/dns/conn.go
index f6057a96..8d71ad46 100644
--- a/util/dns/conn.go
+++ b/util/dns/conn.go
@@ -66,8 +66,13 @@ func (c *dnsConn) RemoteAddr() net.Addr {
 }
 
 func (c *dnsConn) SetDeadline(t time.Time) error {
-	c.SetReadDeadline(t)
-	c.SetWriteDeadline(t)
+	var err error
+	if err = c.SetReadDeadline(t); err != nil {
+		return err
+	}
+	if err = c.SetWriteDeadline(t); err != nil {
+		return err
+	}
 	return nil
 }
 
diff --git a/util/jitter/ticker.go b/util/jitter/ticker.go
index b8d06ee5..34e9d65f 100644
--- a/util/jitter/ticker.go
+++ b/util/jitter/ticker.go
@@ -16,7 +16,6 @@ type Ticker struct {
 	C    chan time.Time
 	min  int64
 	max  int64
-	exp  int64
 	exit bool
 	rng  rand.Rand
 }
diff --git a/util/reflect/reflect.go b/util/reflect/reflect.go
index 729b4e02..859beb20 100644
--- a/util/reflect/reflect.go
+++ b/util/reflect/reflect.go
@@ -91,7 +91,7 @@ func Merge(dst interface{}, mp map[string]interface{}, opts ...Option) error {
 	}
 
 	if mapper, ok := dst.(map[string]interface{}); ok {
-		dst = mergeMap(mapper, mp, 0)
+		mergeMap(mapper, mp, 0)
 		return nil
 	}
 
diff --git a/util/reflect/reflect_test.go b/util/reflect/reflect_test.go
index c11d7736..2b2a10b0 100644
--- a/util/reflect/reflect_test.go
+++ b/util/reflect/reflect_test.go
@@ -1,9 +1,38 @@
 package reflect
 
 import (
+	"fmt"
 	"testing"
 )
 
+func TestMergeMapStringInterface(t *testing.T) {
+	var dst interface{} //nolint:gosimple
+	dst = map[string]interface{}{
+		"xx": 11,
+	}
+
+	src := map[string]interface{}{
+		"zz": "aa",
+	}
+
+	if err := Merge(dst, src); err != nil {
+		t.Fatal(err)
+	}
+
+	mp, ok := dst.(map[string]interface{})
+	if !ok || mp == nil {
+		t.Fatalf("xxx %#+v\n", dst)
+	}
+
+	if fmt.Sprintf("%v", mp["xx"]) != "11" {
+		t.Fatalf("xxx zzzz %#+v", mp)
+	}
+
+	if fmt.Sprintf("%v", mp["zz"]) != "aa" {
+		t.Fatalf("xxx zzzz %#+v", mp)
+	}
+}
+
 func TestMergeMap(t *testing.T) {
 	src := map[string]interface{}{
 		"skey1": "sval1",
diff --git a/util/structfs/metadata_digitalocean.go b/util/structfs/metadata_digitalocean.go
index 93ced79c..5effe043 100644
--- a/util/structfs/metadata_digitalocean.go
+++ b/util/structfs/metadata_digitalocean.go
@@ -56,7 +56,7 @@ type DigitalOceanMetadata struct {
 func (stfs *DigitalOceanMetadata) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	switch r.URL.Path {
 	case "/metadata/v1.json":
-		json.NewEncoder(w).Encode(stfs.Metadata.V1)
+		_ = json.NewEncoder(w).Encode(stfs.Metadata.V1)
 	default:
 		fs := FileServer(stfs, "json", time.Now())
 		idx := strings.Index(r.URL.Path[1:], "/")
diff --git a/util/structfs/metadata_ec2.go b/util/structfs/metadata_ec2.go
index 6c0f63aa..07be6e42 100644
--- a/util/structfs/metadata_ec2.go
+++ b/util/structfs/metadata_ec2.go
@@ -12,7 +12,7 @@ type EC2Metadata struct {
 			InstanceType       string   `json:"instance-type"`
 			LocalHostname      string   `json:"local-hostname"`
 			LocalIPv4          string   `json:"local-ipv4"`
-			kernelID           int      `json:"kernel-id"`
+			KernelID           int      `json:"kernel-id"`
 			Placement          string   `json:"placement"`
 			AvailabilityZone   string   `json:"availability-zone"`
 			ProductCodes       string   `json:"product-codes"`
diff --git a/util/structfs/structfs.go b/util/structfs/structfs.go
index 755c691c..a26a6bdf 100644
--- a/util/structfs/structfs.go
+++ b/util/structfs/structfs.go
@@ -27,7 +27,7 @@ func (fs *fs) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	f, err := fs.Open(r.URL.Path)
 	if err != nil {
 		w.WriteHeader(http.StatusInternalServerError)
-		w.Write([]byte(err.Error()))
+		_, _ = w.Write([]byte(err.Error()))
 		return
 	}
 	w.Header().Set("Content-Type", "application/octet-stream")
@@ -67,9 +67,9 @@ func (fi *fileInfo) Name() string {
 
 func (fi *fileInfo) Mode() os.FileMode {
 	if strings.HasSuffix(fi.name, "/") {
-		return os.FileMode(0755) | os.ModeDir
+		return os.FileMode(0o755) | os.ModeDir
 	}
-	return os.FileMode(0644)
+	return os.FileMode(0o644)
 }
 
 func (fi *fileInfo) IsDir() bool {
@@ -112,15 +112,14 @@ func (f *file) Readdir(count int) ([]os.FileInfo, error) {
 func (f *file) Seek(offset int64, whence int) (int64, error) {
 	//	log.Printf("seek %d %d %s\n", offset, whence, f.name)
 	switch whence {
-	case os.SEEK_SET:
+	case io.SeekStart:
 		f.offset = offset
-	case os.SEEK_CUR:
+	case io.SeekCurrent:
 		f.offset += offset
-	case os.SEEK_END:
+	case io.SeekEnd:
 		f.offset = int64(len(f.data)) + offset
 	}
 	return f.offset, nil
-
 }
 
 func (f *file) Stat() (os.FileInfo, error) {
@@ -222,6 +221,7 @@ func getValue(name string, iface interface{}, tag string) ([]byte, error) {
 	return nil, fmt.Errorf("failed to find %s in interface %T", name, iface)
 }
 
+/*
 func hasValidType(obj interface{}, types []reflect.Kind) bool {
 	for _, t := range types {
 		if reflect.TypeOf(obj).Kind() == t {
@@ -231,6 +231,7 @@ func hasValidType(obj interface{}, types []reflect.Kind) bool {
 
 	return false
 }
+*/
 
 func reflectValue(obj interface{}) reflect.Value {
 	var val reflect.Value
diff --git a/util/structfs/structfs_test.go b/util/structfs/structfs_test.go
index 7abf8edb..8f84dd9d 100644
--- a/util/structfs/structfs_test.go
+++ b/util/structfs/structfs_test.go
@@ -2,7 +2,7 @@ package structfs
 
 import (
 	"encoding/json"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"reflect"
 	"testing"
@@ -61,7 +61,7 @@ var doOrig = []byte(`{
 }
 `)
 
-func server(t *testing.T) {
+func server(t *testing.T, ch chan error) {
 	stfs := DigitalOceanMetadata{}
 	err := json.Unmarshal(doOrig, &stfs.Metadata.V1)
 	if err != nil {
@@ -71,7 +71,7 @@ func server(t *testing.T) {
 	http.Handle("/metadata/v1/", FileServer(&stfs, "json", time.Now()))
 	http.Handle("/metadata/v1.json", &stfs)
 	go func() {
-		t.Fatal(http.ListenAndServe("127.0.0.1:8080", nil))
+		ch <- http.ListenAndServe("127.0.0.1:8080", nil)
 	}()
 	time.Sleep(2 * time.Second)
 }
@@ -82,13 +82,14 @@ func get(path string) ([]byte, error) {
 		return nil, err
 	}
 	defer res.Body.Close()
-	return ioutil.ReadAll(res.Body)
+	return io.ReadAll(res.Body)
 }
 
 func TestAll(t *testing.T) {
-	server(t)
+	ch := make(chan error)
+	server(t, ch)
 
-	var tests = []struct {
+	tests := []struct {
 		in  string
 		out string
 	}{
@@ -100,34 +101,44 @@ func TestAll(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		buf, err := get(tt.in)
+		select {
+		case err := <-ch:
+			t.Fatal(err)
+		default:
+			buf, err := get(tt.in)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if string(buf) != tt.out {
+				t.Errorf("req %s output %s not match requested %s", tt.in, string(buf), tt.out)
+			}
+		}
+	}
+
+	select {
+	case err := <-ch:
+		t.Fatal(err)
+	default:
+		doTest, err := get("http://127.0.0.1:8080/metadata/v1.json")
 		if err != nil {
 			t.Fatal(err)
 		}
-		if string(buf) != tt.out {
-			t.Errorf("req %s output %s not match requested %s", tt.in, string(buf), tt.out)
+
+		oSt := DigitalOceanMetadata{}
+		err = json.Unmarshal(doOrig, &oSt.Metadata.V1)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		nSt := DigitalOceanMetadata{}
+
+		err = json.Unmarshal(doTest, &nSt.Metadata.V1)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if !reflect.DeepEqual(oSt, nSt) {
+			t.Fatalf("%v not match %v", oSt, nSt)
 		}
 	}
-
-	doTest, err := get("http://127.0.0.1:8080/metadata/v1.json")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	oSt := DigitalOceanMetadata{}
-	err = json.Unmarshal(doOrig, &oSt.Metadata.V1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	nSt := DigitalOceanMetadata{}
-
-	err = json.Unmarshal(doTest, &nSt.Metadata.V1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if !reflect.DeepEqual(oSt, nSt) {
-		t.Fatalf("%v not match %v", oSt, nSt)
-	}
 }
diff --git a/util/time/duration.go b/util/time/duration.go
index 49550e5e..33acb1a9 100644
--- a/util/time/duration.go
+++ b/util/time/duration.go
@@ -14,7 +14,7 @@ type Duration int64
 
 func ParseDuration(s string) (time.Duration, error) {
 	if s == "" {
-		return 0, fmt.Errorf(`time: invalid duration "` + s + `"`)
+		return 0, errors.New(`time: invalid duration "` + s + `"`)
 	}
 
 	var p int
diff --git a/util/xpool/pool.go b/util/xpool/pool.go
index b80cd482..d38b3a08 100644
--- a/util/xpool/pool.go
+++ b/util/xpool/pool.go
@@ -39,19 +39,16 @@ func newStatsMeter() {
 	ticker := time.NewTicker(meter.DefaultMeterStatsInterval)
 	defer ticker.Stop()
 
-	for {
-		select {
-		case <-ticker.C:
-			poolsMu.Lock()
-			for _, st := range pools {
-				stats := st.Stats()
-				meter.DefaultMeter.Counter(semconv.PoolGetTotal, "capacity", strconv.Itoa(st.Cap())).Set(stats.Get)
-				meter.DefaultMeter.Counter(semconv.PoolPutTotal, "capacity", strconv.Itoa(st.Cap())).Set(stats.Put)
-				meter.DefaultMeter.Counter(semconv.PoolMisTotal, "capacity", strconv.Itoa(st.Cap())).Set(stats.Mis)
-				meter.DefaultMeter.Counter(semconv.PoolRetTotal, "capacity", strconv.Itoa(st.Cap())).Set(stats.Ret)
-			}
-			poolsMu.Unlock()
+	for range ticker.C {
+		poolsMu.Lock()
+		for _, st := range pools {
+			stats := st.Stats()
+			meter.DefaultMeter.Counter(semconv.PoolGetTotal, "capacity", strconv.Itoa(st.Cap())).Set(stats.Get)
+			meter.DefaultMeter.Counter(semconv.PoolPutTotal, "capacity", strconv.Itoa(st.Cap())).Set(stats.Put)
+			meter.DefaultMeter.Counter(semconv.PoolMisTotal, "capacity", strconv.Itoa(st.Cap())).Set(stats.Mis)
+			meter.DefaultMeter.Counter(semconv.PoolRetTotal, "capacity", strconv.Itoa(st.Cap())).Set(stats.Ret)
 		}
+		poolsMu.Unlock()
 	}
 }