diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index e6ee064202f..75a267acea0 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -31,6 +31,6 @@ jobs:
       - name: Lint
         uses: golangci/golangci-lint-action@v6
         with:
-          version: v1.54.2
+          version: v1.60.3
           working-directory: ${{ matrix.workdir }}
           skip-pkg-cache: true
diff --git a/.golangci.yml b/.golangci.yml
index 556fcfbc4aa..57b20dd7612 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -17,7 +17,7 @@ linters:
     - gofumpt
     - goconst
     - goimports
-    - gomnd
+    - mnd
     - gocyclo
     - ineffassign
     - lll
@@ -54,9 +54,9 @@ linters-settings:
     multi-func: true
   lll:
     line-length: 160
-  gomnd:
+  mnd:
     # don't include the "operation", "argument" and "assign"
-    checks: 
+    checks:
       - case
       - condition
       - return
diff --git a/app.go b/app.go
index 1fa23132e87..86a6cb5bf91 100644
--- a/app.go
+++ b/app.go
@@ -9,12 +9,12 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/google/uuid"
+	"golang.org/x/sync/errgroup"
+
 	"github.com/go-kratos/kratos/v2/log"
 	"github.com/go-kratos/kratos/v2/registry"
 	"github.com/go-kratos/kratos/v2/transport"
-
-	"github.com/google/uuid"
-	"golang.org/x/sync/errgroup"
 )
 
 // AppInfo is application context value.
diff --git a/cmd/kratos/internal/proto/client/client.go b/cmd/kratos/internal/proto/client/client.go
index cb3f4a76d56..07e4b490941 100644
--- a/cmd/kratos/internal/proto/client/client.go
+++ b/cmd/kratos/internal/proto/client/client.go
@@ -72,7 +72,7 @@ func walk(dir string, args []string) error {
 	if dir == "" {
 		dir = "."
 	}
-	return filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
+	return filepath.Walk(dir, func(path string, _ os.FileInfo, _ error) error {
 		if ext := filepath.Ext(path); ext != ".proto" || strings.HasPrefix(path, "third_party") {
 			return nil
 		}
diff --git a/cmd/kratos/internal/run/run.go b/cmd/kratos/internal/run/run.go
index 2def97a1f99..3137016fcf1 100644
--- a/cmd/kratos/internal/run/run.go
+++ b/cmd/kratos/internal/run/run.go
@@ -98,7 +98,7 @@ func findCMD(base string) (map[string]string, error) {
 	var root bool
 	next := func(dir string) (map[string]string, error) {
 		cmdPath := make(map[string]string)
-		err := filepath.Walk(dir, func(walkPath string, info os.FileInfo, err error) error {
+		err := filepath.Walk(dir, func(walkPath string, info os.FileInfo, _ error) error {
 			// multi level directory is not allowed under the cmdPath directory, so it is judged that the path ends with cmdPath.
 			if strings.HasSuffix(walkPath, "cmd") {
 				paths, err := os.ReadDir(walkPath)
diff --git a/config/config_test.go b/config/config_test.go
index ab234dd4863..ec7fc9f7f76 100644
--- a/config/config_test.go
+++ b/config/config_test.go
@@ -154,8 +154,7 @@ func TestConfig(t *testing.T) {
 		t.Fatal("databaseDriver is not equal to val")
 	}
 
-	err = cf.Watch("endpoints", func(key string, value Value) {
-	})
+	err = cf.Watch("endpoints", func(string, Value) {})
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/config/env/env.go b/config/env/env.go
index cdd30e1b70e..ecd5c6ffa8d 100644
--- a/config/env/env.go
+++ b/config/env/env.go
@@ -23,7 +23,7 @@ func (e *env) load(envs []string) []*config.KeyValue {
 	var kv []*config.KeyValue
 	for _, env := range envs {
 		var k, v string
-		subs := strings.SplitN(env, "=", 2) //nolint:gomnd
+		subs := strings.SplitN(env, "=", 2) //nolint:mnd
 		k = subs[0]
 		if len(subs) > 1 {
 			v = subs[1]
diff --git a/config/options.go b/config/options.go
index 95d6f6d31d9..7395660d5ba 100644
--- a/config/options.go
+++ b/config/options.go
@@ -137,7 +137,7 @@ func resolver(input map[string]interface{}, mapper func(name string) string, toT
 
 func mapper(input map[string]interface{}) func(name string) string {
 	mapper := func(name string) string {
-		args := strings.SplitN(strings.TrimSpace(name), ":", 2) //nolint:gomnd
+		args := strings.SplitN(strings.TrimSpace(name), ":", 2) //nolint:mnd
 		if v, has := readValue(input, args[0]); has {
 			s, _ := v.String()
 			return s
@@ -183,7 +183,7 @@ func expand(s string, mapping func(string) string, toType bool) interface{} {
 	re := r.FindAllStringSubmatch(s, -1)
 	var ct interface{}
 	for _, i := range re {
-		if len(i) == 2 { //nolint:gomnd
+		if len(i) == 2 { //nolint:mnd
 			m := mapping(i[1])
 			if toType {
 				ct = convertToType(m)
diff --git a/config/options_test.go b/config/options_test.go
index 83f62b85901..348471d3f70 100644
--- a/config/options_test.go
+++ b/config/options_test.go
@@ -387,7 +387,7 @@ func TestExpand(t *testing.T) {
 
 func TestWithMergeFunc(t *testing.T) {
 	c := &options{}
-	a := func(dst, src interface{}) error {
+	a := func(any, any) error {
 		return nil
 	}
 	WithMergeFunc(a)(c)
diff --git a/contrib/config/nacos/config_test.go b/contrib/config/nacos/config_test.go
index 2d290803795..1667e99dfcc 100644
--- a/contrib/config/nacos/config_test.go
+++ b/contrib/config/nacos/config_test.go
@@ -166,13 +166,13 @@ func TestConfig_Watch(t *testing.T) {
 				source: source,
 			},
 			wantErr: false,
-			processFunc: func(t *testing.T, w config.Watcher) {
+			processFunc: func(t *testing.T, _ config.Watcher) {
 				_, pErr := client.PublishConfig(vo.ConfigParam{DataId: "test.yaml", Group: "test", Content: "test: test"})
 				if pErr != nil {
 					t.Error(pErr)
 				}
 			},
-			deferFunc: func(t *testing.T, w config.Watcher) {
+			deferFunc: func(t *testing.T, _ config.Watcher) {
 				_, dErr := client.DeleteConfig(vo.ConfigParam{DataId: "test.yaml", Group: "test"})
 				if dErr != nil {
 					t.Error(dErr)
diff --git a/contrib/opensergo/opensergo_test.go b/contrib/opensergo/opensergo_test.go
index 0a2165fb602..322c2c7e36c 100644
--- a/contrib/opensergo/opensergo_test.go
+++ b/contrib/opensergo/opensergo_test.go
@@ -309,7 +309,7 @@ func TestOpenSergo(t *testing.T) {
 			args: args{
 				opts: []Option{},
 			},
-			preFunc: func(t *testing.T) {
+			preFunc: func(_ *testing.T) {
 				err := os.Setenv("OPENSERGO_ENDPOINT", "127.0.0.1:9090")
 				if err != nil {
 					panic(err)
@@ -322,7 +322,7 @@ func TestOpenSergo(t *testing.T) {
 			args: args{
 				opts: []Option{},
 			},
-			preFunc: func(t *testing.T) {
+			preFunc: func(_ *testing.T) {
 				err := os.Setenv("OPENSERGO_BOOTSTRAP", `{"endpoint": "127.0.0.1:9090"}`)
 				if err != nil {
 					panic(err)
diff --git a/contrib/polaris/router.go b/contrib/polaris/router.go
index 2478b58b823..93202eb5dad 100644
--- a/contrib/polaris/router.go
+++ b/contrib/polaris/router.go
@@ -139,7 +139,7 @@ func buildPolarisInstance(namespace string, nodes []selector.Node) *pb.ServiceIn
 		Service:   &v1.Service{Name: wrapperspb.String(nodes[0].ServiceName()), Namespace: wrapperspb.String("default")},
 		Instances: ins,
 	}
-	return pb.NewServiceInstancesInProto(d, func(s string) local.InstanceLocalValue {
+	return pb.NewServiceInstancesInProto(d, func(string) local.InstanceLocalValue {
 		return local.NewInstanceLocalValue()
 	}, &pb.SvcPluginValues{Routers: nil, Loadbalancer: nil}, nil)
 }
diff --git a/contrib/registry/consul/registry_test.go b/contrib/registry/consul/registry_test.go
index d6799b693ce..9adc89ecaee 100644
--- a/contrib/registry/consul/registry_test.go
+++ b/contrib/registry/consul/registry_test.go
@@ -329,8 +329,7 @@ func TestRegistry_Watch(t *testing.T) {
 			},
 			want:    []*registry.ServiceInstance{instance1},
 			wantErr: false,
-			preFunc: func(t *testing.T) {
-			},
+			preFunc: func(*testing.T) {},
 		},
 		{
 			name: "ctx has been canceled",
@@ -344,8 +343,7 @@ func TestRegistry_Watch(t *testing.T) {
 			},
 			want:    nil,
 			wantErr: true,
-			preFunc: func(t *testing.T) {
-			},
+			preFunc: func(*testing.T) {},
 		},
 		{
 			name: "register with healthCheck",
diff --git a/contrib/registry/etcd/registry.go b/contrib/registry/etcd/registry.go
index 476436e2ee6..1a931153fe9 100644
--- a/contrib/registry/etcd/registry.go
+++ b/contrib/registry/etcd/registry.go
@@ -162,7 +162,7 @@ func (r *Registry) heartBeat(ctx context.Context, leaseID clientv3.LeaseID, key
 	if err != nil {
 		curLeaseID = 0
 	}
-	rand.Seed(time.Now().Unix())
+	randSource := rand.New(rand.NewSource(time.Now().Unix()))
 
 	for {
 		if curLeaseID == 0 {
@@ -200,7 +200,7 @@ func (r *Registry) heartBeat(ctx context.Context, leaseID clientv3.LeaseID, key
 					break
 				}
 				retreat = append(retreat, 1<<retryCnt)
-				time.Sleep(time.Duration(retreat[rand.Intn(len(retreat))]) * time.Second)
+				time.Sleep(time.Duration(retreat[randSource.Intn(len(retreat))]) * time.Second)
 			}
 			if _, ok := <-kac; !ok {
 				// retry failed
diff --git a/contrib/registry/eureka/client.go b/contrib/registry/eureka/client.go
index 3b985c5b189..0c19cd3f19f 100644
--- a/contrib/registry/eureka/client.go
+++ b/contrib/registry/eureka/client.go
@@ -292,10 +292,10 @@ func (e *Client) pickServer(currentTimes int) string {
 }
 
 func (e *Client) shuffle() {
-	rand.Seed(time.Now().UnixNano())
-	rand.Shuffle(len(e.urls), func(i, j int) {
-		e.urls[i], e.urls[j] = e.urls[j], e.urls[i]
-	})
+	rand.New(rand.NewSource(time.Now().UnixNano())).
+		Shuffle(len(e.urls), func(i, j int) {
+			e.urls[i], e.urls[j] = e.urls[j], e.urls[i]
+		})
 }
 
 func (e *Client) buildAPI(currentTimes int, params ...string) string {
diff --git a/contrib/registry/kubernetes/registry.go b/contrib/registry/kubernetes/registry.go
index 21562dc557e..7379abf389b 100644
--- a/contrib/registry/kubernetes/registry.go
+++ b/contrib/registry/kubernetes/registry.go
@@ -205,13 +205,13 @@ func (s *Registry) Watch(ctx context.Context, name string) (registry.Watcher, er
 			}
 		},
 		Handler: cache.ResourceEventHandlerFuncs{
-			AddFunc: func(obj interface{}) {
+			AddFunc: func(interface{}) {
 				s.sendLatestInstances(ctx, name, announcement)
 			},
-			UpdateFunc: func(oldObj, newObj interface{}) {
+			UpdateFunc: func(interface{}, interface{}) {
 				s.sendLatestInstances(ctx, name, announcement)
 			},
-			DeleteFunc: func(obj interface{}) {
+			DeleteFunc: func(interface{}) {
 				s.sendLatestInstances(ctx, name, announcement)
 			},
 		},
diff --git a/contrib/registry/kubernetes/registry_test.go b/contrib/registry/kubernetes/registry_test.go
index 2363b1c3a5e..6f9761a455d 100644
--- a/contrib/registry/kubernetes/registry_test.go
+++ b/contrib/registry/kubernetes/registry_test.go
@@ -110,7 +110,6 @@ func TestRegistry(t *testing.T) {
 		Endpoints: []string{"http://127.0.0.1:80"},
 	}
 	_, err = clientSet.AppsV1().Deployments(namespace).Create(context.Background(), &deployment, metav1.CreateOptions{})
-
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/contrib/registry/nacos/registry_test.go b/contrib/registry/nacos/registry_test.go
index 1910a68d813..95768eea84e 100644
--- a/contrib/registry/nacos/registry_test.go
+++ b/contrib/registry/nacos/registry_test.go
@@ -530,7 +530,7 @@ func TestRegistry_Watch(t *testing.T) {
 			},
 			wantErr: true,
 			want:    nil,
-			processFunc: func(t *testing.T) {
+			processFunc: func(*testing.T) {
 				cancel()
 			},
 		},
diff --git a/contrib/registry/nacos/watcher.go b/contrib/registry/nacos/watcher.go
index 7f1dc84663a..16cec4ab30d 100644
--- a/contrib/registry/nacos/watcher.go
+++ b/contrib/registry/nacos/watcher.go
@@ -40,7 +40,7 @@ func newWatcher(ctx context.Context, cli naming_client.INamingClient, serviceNam
 		ServiceName: serviceName,
 		Clusters:    clusters,
 		GroupName:   groupName,
-		SubscribeCallback: func(services []model.SubscribeService, err error) {
+		SubscribeCallback: func([]model.SubscribeService, error) {
 			select {
 			case w.watchChan <- struct{}{}:
 			default:
diff --git a/contrib/registry/zookeeper/register_test.go b/contrib/registry/zookeeper/register_test.go
index a6f4515e57f..8ac9feec473 100644
--- a/contrib/registry/zookeeper/register_test.go
+++ b/contrib/registry/zookeeper/register_test.go
@@ -80,7 +80,7 @@ func TestRegistry_GetService(t *testing.T) {
 		},
 		{
 			name: "conn close",
-			preFunc: func(t *testing.T) {
+			preFunc: func(*testing.T) {
 				conn.Close()
 			},
 			fields: fields{
@@ -339,7 +339,7 @@ func TestRegistry_Watch(t *testing.T) {
 					t.Error(err)
 				}
 			},
-			processFunc: func(t *testing.T, w registry.Watcher) {
+			processFunc: func(t *testing.T, _ registry.Watcher) {
 				err = r.Register(context.Background(), svrHello)
 				if err != nil {
 					t.Error(err)
@@ -357,7 +357,7 @@ func TestRegistry_Watch(t *testing.T) {
 			},
 			wantErr: true,
 			want:    nil,
-			processFunc: func(t *testing.T, w registry.Watcher) {
+			processFunc: func(*testing.T, registry.Watcher) {
 				cancel()
 			},
 		},
@@ -372,7 +372,7 @@ func TestRegistry_Watch(t *testing.T) {
 			},
 			wantErr: true,
 			want:    nil,
-			processFunc: func(t *testing.T, w registry.Watcher) {
+			processFunc: func(*testing.T, registry.Watcher) {
 				closeConn.Close()
 			},
 		},
diff --git a/encoding/encoding_test.go b/encoding/encoding_test.go
index 9746788ab07..98640ff4600 100644
--- a/encoding/encoding_test.go
+++ b/encoding/encoding_test.go
@@ -2,7 +2,6 @@ package encoding
 
 import (
 	"encoding/xml"
-	"fmt"
 	"runtime/debug"
 	"testing"
 )
@@ -40,7 +39,7 @@ func TestRegisterCodec(t *testing.T) {
 	f := func() { RegisterCodec(nil) }
 	funcDidPanic, panicValue, _ := didPanic(f)
 	if !funcDidPanic {
-		t.Fatalf(fmt.Sprintf("func should panic\n\tPanic value:\t%#v", panicValue))
+		t.Fatalf("func should panic\n\tPanic value:\t%#v", panicValue)
 	}
 	if panicValue != "cannot register a nil Codec" {
 		t.Fatalf("panic error got %s want cannot register a nil Codec", panicValue)
@@ -50,7 +49,7 @@ func TestRegisterCodec(t *testing.T) {
 	}
 	funcDidPanic, panicValue, _ = didPanic(f)
 	if !funcDidPanic {
-		t.Fatalf(fmt.Sprintf("func should panic\n\tPanic value:\t%#v", panicValue))
+		t.Fatalf("func should panic\n\tPanic value:\t%#v", panicValue)
 	}
 	if panicValue != "cannot register Codec with empty string result for Name()" {
 		t.Fatalf("panic error got %s want cannot register Codec with empty string result for Name()", panicValue)
diff --git a/encoding/form/proto_decode.go b/encoding/form/proto_decode.go
index 5b68b92e164..cdd93108308 100644
--- a/encoding/form/proto_decode.go
+++ b/encoding/form/proto_decode.go
@@ -172,7 +172,7 @@ func parseField(fd protoreflect.FieldDescriptor, value string) (protoreflect.Val
 		}
 		v := enum.Descriptor().Values().ByName(protoreflect.Name(value))
 		if v == nil {
-			i, err := strconv.ParseInt(value, 10, 32) //nolint:gomnd
+			i, err := strconv.ParseInt(value, 10, 32) //nolint:mnd
 			if err != nil {
 				return protoreflect.Value{}, fmt.Errorf("%q is not a valid value", value)
 			}
@@ -183,37 +183,37 @@ func parseField(fd protoreflect.FieldDescriptor, value string) (protoreflect.Val
 		}
 		return protoreflect.ValueOfEnum(v.Number()), nil
 	case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
-		v, err := strconv.ParseInt(value, 10, 32) //nolint:gomnd
+		v, err := strconv.ParseInt(value, 10, 32) //nolint:mnd
 		if err != nil {
 			return protoreflect.Value{}, err
 		}
 		return protoreflect.ValueOfInt32(int32(v)), nil
 	case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
-		v, err := strconv.ParseInt(value, 10, 64) //nolint:gomnd
+		v, err := strconv.ParseInt(value, 10, 64) //nolint:mnd
 		if err != nil {
 			return protoreflect.Value{}, err
 		}
 		return protoreflect.ValueOfInt64(v), nil
 	case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
-		v, err := strconv.ParseUint(value, 10, 32) //nolint:gomnd
+		v, err := strconv.ParseUint(value, 10, 32) //nolint:mnd
 		if err != nil {
 			return protoreflect.Value{}, err
 		}
 		return protoreflect.ValueOfUint32(uint32(v)), nil
 	case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
-		v, err := strconv.ParseUint(value, 10, 64) //nolint:gomnd
+		v, err := strconv.ParseUint(value, 10, 64) //nolint:mnd
 		if err != nil {
 			return protoreflect.Value{}, err
 		}
 		return protoreflect.ValueOfUint64(v), nil
 	case protoreflect.FloatKind:
-		v, err := strconv.ParseFloat(value, 32) //nolint:gomnd
+		v, err := strconv.ParseFloat(value, 32) //nolint:mnd
 		if err != nil {
 			return protoreflect.Value{}, err
 		}
 		return protoreflect.ValueOfFloat32(float32(v)), nil
 	case protoreflect.DoubleKind:
-		v, err := strconv.ParseFloat(value, 64) //nolint:gomnd
+		v, err := strconv.ParseFloat(value, 64) //nolint:mnd
 		if err != nil {
 			return protoreflect.Value{}, err
 		}
@@ -255,37 +255,37 @@ func parseMessage(md protoreflect.MessageDescriptor, value string) (protoreflect
 		}
 		msg = durationpb.New(d)
 	case "google.protobuf.DoubleValue":
-		v, err := strconv.ParseFloat(value, 64) //nolint:gomnd
+		v, err := strconv.ParseFloat(value, 64) //nolint:mnd
 		if err != nil {
 			return protoreflect.Value{}, err
 		}
 		msg = wrapperspb.Double(v)
 	case "google.protobuf.FloatValue":
-		v, err := strconv.ParseFloat(value, 32) //nolint:gomnd
+		v, err := strconv.ParseFloat(value, 32) //nolint:mnd
 		if err != nil {
 			return protoreflect.Value{}, err
 		}
 		msg = wrapperspb.Float(float32(v))
 	case "google.protobuf.Int64Value":
-		v, err := strconv.ParseInt(value, 10, 64) //nolint:gomnd
+		v, err := strconv.ParseInt(value, 10, 64) //nolint:mnd
 		if err != nil {
 			return protoreflect.Value{}, err
 		}
 		msg = wrapperspb.Int64(v)
 	case "google.protobuf.Int32Value":
-		v, err := strconv.ParseInt(value, 10, 32) //nolint:gomnd
+		v, err := strconv.ParseInt(value, 10, 32) //nolint:mnd
 		if err != nil {
 			return protoreflect.Value{}, err
 		}
 		msg = wrapperspb.Int32(int32(v))
 	case "google.protobuf.UInt64Value":
-		v, err := strconv.ParseUint(value, 10, 64) //nolint:gomnd
+		v, err := strconv.ParseUint(value, 10, 64) //nolint:mnd
 		if err != nil {
 			return protoreflect.Value{}, err
 		}
 		msg = wrapperspb.UInt64(v)
 	case "google.protobuf.UInt32Value":
-		v, err := strconv.ParseUint(value, 10, 32) //nolint:gomnd
+		v, err := strconv.ParseUint(value, 10, 32) //nolint:mnd
 		if err != nil {
 			return protoreflect.Value{}, err
 		}
@@ -358,9 +358,9 @@ func parseURLQueryMapKey(key string) (string, string, error) {
 		endIndex   = strings.IndexByte(key, ']')
 	)
 	if startIndex < 0 {
-		//nolint:gomnd
+		//nolint:mnd
 		values := strings.Split(key, fieldSeparater)
-		//nolint:gomnd
+		//nolint:mnd
 		if len(values) != 2 {
 			return "", "", errInvalidFormatMapKey
 		}
diff --git a/errors/errors.go b/errors/errors.go
index caf31cd3eca..ae0764f8fdc 100644
--- a/errors/errors.go
+++ b/errors/errors.go
@@ -89,7 +89,7 @@ func Errorf(code int, reason, format string, a ...interface{}) error {
 // It supports wrapped errors.
 func Code(err error) int {
 	if err == nil {
-		return 200 //nolint:gomnd
+		return 200 //nolint:mnd
 	}
 	return int(FromError(err).Code)
 }
diff --git a/errors/types.go b/errors/types.go
index 6a57f32afe0..fbd2cb1f4f6 100644
--- a/errors/types.go
+++ b/errors/types.go
@@ -1,4 +1,4 @@
-// nolint:gomnd
+// nolint:mnd
 package errors
 
 // BadRequest new BadRequest error that is mapped to a 400 response.
diff --git a/internal/host/host.go b/internal/host/host.go
index 774f7ae3726..5a6caba09d1 100644
--- a/internal/host/host.go
+++ b/internal/host/host.go
@@ -13,7 +13,7 @@ func ExtractHostPort(addr string) (host string, port uint64, err error) {
 	if err != nil {
 		return
 	}
-	port, err = strconv.ParseUint(ports, 10, 16) //nolint:gomnd
+	port, err = strconv.ParseUint(ports, 10, 16) //nolint:mnd
 	return
 }
 
diff --git a/internal/matcher/middleware_test.go b/internal/matcher/middleware_test.go
index 9c948aebca4..20575768d1f 100644
--- a/internal/matcher/middleware_test.go
+++ b/internal/matcher/middleware_test.go
@@ -8,8 +8,8 @@ import (
 )
 
 func logging(module string) middleware.Middleware {
-	return func(handler middleware.Handler) middleware.Handler {
-		return func(ctx context.Context, req interface{}) (reply interface{}, err error) {
+	return func(middleware.Handler) middleware.Handler {
+		return func(context.Context, interface{}) (reply interface{}, err error) {
 			return module, nil
 		}
 	}
diff --git a/log/filter_test.go b/log/filter_test.go
index 8463a47235d..f95f49769e1 100644
--- a/log/filter_test.go
+++ b/log/filter_test.go
@@ -146,7 +146,10 @@ func testFilterFuncWithLoggerPrefix(level Level, keyvals ...interface{}) bool {
 }
 
 func TestFilterWithContext(t *testing.T) {
-	ctxKey := struct{}{}
+	type CtxKey struct {
+		Key string
+	}
+	ctxKey := CtxKey{Key: "context"}
 	ctxValue := "filter test value"
 
 	v1 := func() Valuer {
diff --git a/log/value_test.go b/log/value_test.go
index fd9167a6979..defbbf74f62 100644
--- a/log/value_test.go
+++ b/log/value_test.go
@@ -19,7 +19,7 @@ func TestValue(t *testing.T) {
 	if got != v1 {
 		t.Errorf("Value() = %v, want %v", got, v1)
 	}
-	var v2 Valuer = func(ctx context.Context) interface{} {
+	var v2 Valuer = func(context.Context) interface{} {
 		return 3
 	}
 	got = Value(context.Background(), v2)
diff --git a/metadata/metadata_test.go b/metadata/metadata_test.go
index 9aa1c620bb6..33f1b1a25ea 100644
--- a/metadata/metadata_test.go
+++ b/metadata/metadata_test.go
@@ -349,7 +349,7 @@ func TestMetadata_Range(t *testing.T) {
 		t.Errorf("metadata = %v, want %v", tmp, Metadata{"https://go-kratos.dev/": {"https://go-kratos.dev/"}, "kratos": {"kratos"}})
 	}
 	tmp = Metadata{}
-	md.Range(func(k string, v []string) bool {
+	md.Range(func(string, []string) bool {
 		return false
 	})
 	if !reflect.DeepEqual(tmp, Metadata{}) {
diff --git a/middleware/auth/jwt/jwt_test.go b/middleware/auth/jwt/jwt_test.go
index 5f2a3ba5ec4..84a558e234e 100644
--- a/middleware/auth/jwt/jwt_test.go
+++ b/middleware/auth/jwt/jwt_test.go
@@ -129,7 +129,7 @@ func TestJWTServerParse(t *testing.T) {
 		},
 	}
 
-	next := func(ctx context.Context, req interface{}) (interface{}, error) {
+	next := func(ctx context.Context, _ interface{}) (interface{}, error) {
 		testToken, _ := FromContext(ctx)
 		var name string
 		if customerClaims, ok := testToken.(*CustomerClaims); ok {
@@ -154,7 +154,7 @@ func TestJWTServerParse(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			server := Server(
-				func(token *jwt.Token) (interface{}, error) { return []byte(testKey), nil },
+				func(*jwt.Token) (interface{}, error) { return []byte(testKey), nil },
 				WithClaims(test.claims),
 			)(next)
 			wg := sync.WaitGroup{}
@@ -247,11 +247,11 @@ func TestServer(t *testing.T) {
 			}
 			var server middleware.Handler
 			if test.signingMethod != nil {
-				server = Server(func(token *jwt.Token) (interface{}, error) {
+				server = Server(func(*jwt.Token) (interface{}, error) {
 					return []byte(test.key), nil
 				}, WithSigningMethod(test.signingMethod))(next)
 			} else {
-				server = Server(func(token *jwt.Token) (interface{}, error) {
+				server = Server(func(*jwt.Token) (interface{}, error) {
 					return []byte(test.key), nil
 				})(next)
 			}
@@ -301,7 +301,7 @@ func TestClient(t *testing.T) {
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			next := func(ctx context.Context, req interface{}) (interface{}, error) {
+			next := func(context.Context, any) (interface{}, error) {
 				return "reply", nil
 			}
 			handler := Client(test.tokenProvider)(next)
@@ -330,12 +330,12 @@ func TestTokenExpire(t *testing.T) {
 	}
 	token = fmt.Sprintf(bearerFormat, token)
 	time.Sleep(time.Second)
-	next := func(ctx context.Context, req interface{}) (interface{}, error) {
+	next := func(_ context.Context, req interface{}) (interface{}, error) {
 		t.Log(req)
 		return "reply", nil
 	}
 	ctx := transport.NewServerContext(context.Background(), &Transport{reqHeader: newTokenHeader(authorizationKey, token)})
-	server := Server(func(token *jwt.Token) (interface{}, error) {
+	server := Server(func(*jwt.Token) (interface{}, error) {
 		return []byte(testKey), nil
 	}, WithSigningMethod(jwt.SigningMethodHS256))(next)
 	_, err2 := server(ctx, "test expire token")
@@ -410,7 +410,7 @@ func TestClientWithClaims(t *testing.T) {
 	}
 
 	t.Run(test.name, func(t *testing.T) {
-		next := func(ctx context.Context, req interface{}) (interface{}, error) {
+		next := func(context.Context, interface{}) (interface{}, error) {
 			return "reply", nil
 		}
 		handler := Client(test.tokenProvider, WithClaims(mapClaimsFunc))(next)
@@ -446,7 +446,7 @@ func TestClientWithHeader(t *testing.T) {
 	tProvider := func(*jwt.Token) (interface{}, error) {
 		return []byte(testKey), nil
 	}
-	next := func(ctx context.Context, req interface{}) (interface{}, error) {
+	next := func(context.Context, interface{}) (interface{}, error) {
 		return "reply", nil
 	}
 	handler := Client(tProvider, WithClaims(mapClaimsFunc), WithTokenHeader(tokenHeader))(next)
@@ -484,7 +484,7 @@ func TestClientMissKey(t *testing.T) {
 	}
 
 	t.Run(test.name, func(t *testing.T) {
-		next := func(ctx context.Context, req interface{}) (interface{}, error) {
+		next := func(context.Context, interface{}) (interface{}, error) {
 			return "reply", nil
 		}
 		handler := Client(test.tokenProvider, WithClaims(mapClaimsFunc))(next)
diff --git a/middleware/circuitbreaker/circuitbreaker_test.go b/middleware/circuitbreaker/circuitbreaker_test.go
index 3b27da1a3c8..3daca9f24bf 100644
--- a/middleware/circuitbreaker/circuitbreaker_test.go
+++ b/middleware/circuitbreaker/circuitbreaker_test.go
@@ -58,10 +58,10 @@ func Test_WithGroup(t *testing.T) {
 }
 
 func TestServer(_ *testing.T) {
-	nextValid := func(ctx context.Context, req interface{}) (interface{}, error) {
+	nextValid := func(context.Context, interface{}) (interface{}, error) {
 		return "Hello valid", nil
 	}
-	nextInvalid := func(ctx context.Context, req interface{}) (interface{}, error) {
+	nextInvalid := func(context.Context, interface{}) (interface{}, error) {
 		return nil, kratoserrors.InternalServer("", "")
 	}
 
diff --git a/middleware/logging/logging_test.go b/middleware/logging/logging_test.go
index 1e9495188b6..87e3959ab51 100644
--- a/middleware/logging/logging_test.go
+++ b/middleware/logging/logging_test.go
@@ -87,7 +87,7 @@ func TestHTTP(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			bf.Reset()
-			next := func(ctx context.Context, req interface{}) (interface{}, error) {
+			next := func(context.Context, interface{}) (interface{}, error) {
 				return "reply", test.err
 			}
 			next = test.kind(logger)(next)
diff --git a/middleware/metrics/metrics.go b/middleware/metrics/metrics.go
index 4459cdeefb1..becc31fa840 100644
--- a/middleware/metrics/metrics.go
+++ b/middleware/metrics/metrics.go
@@ -76,7 +76,7 @@ func DefaultSecondsHistogramView(histogramName string) metricsdk.View {
 					Boundaries: []float64{0.005, 0.01, 0.025, 0.05, 0.1, 0.250, 0.5, 1},
 					NoMinMax:   true,
 				},
-				AttributeFilter: func(value attribute.KeyValue) bool {
+				AttributeFilter: func(attribute.KeyValue) bool {
 					return true
 				},
 			}, true
diff --git a/middleware/metrics/metrics_test.go b/middleware/metrics/metrics_test.go
index 3f30ac1aaac..348fdaeee75 100644
--- a/middleware/metrics/metrics_test.go
+++ b/middleware/metrics/metrics_test.go
@@ -77,7 +77,7 @@ func init() {
 				Name:        instrument.Name,
 				Description: instrument.Description,
 				Unit:        instrument.Unit,
-				AttributeFilter: func(value attribute.KeyValue) bool {
+				AttributeFilter: func(attribute.KeyValue) bool {
 					return true
 				},
 			}, true
@@ -139,10 +139,10 @@ func TestServer(t *testing.T) {
 	defer span.End()
 
 	e := errors.New("got an error")
-	nextError := func(ctx context.Context, req interface{}) (interface{}, error) {
+	nextError := func(context.Context, interface{}) (interface{}, error) {
 		return nil, e
 	}
-	nextValid := func(ctx context.Context, req interface{}) (interface{}, error) {
+	nextValid := func(context.Context, interface{}) (interface{}, error) {
 		time.Sleep(time.Millisecond * time.Duration(rand.Int31n(100)))
 		return "Hello valid", nil
 	}
@@ -201,10 +201,10 @@ func TestClient(t *testing.T) {
 	defer span.End()
 
 	e := errors.New("got an error")
-	nextError := func(ctx context.Context, req interface{}) (interface{}, error) {
+	nextError := func(context.Context, interface{}) (interface{}, error) {
 		return nil, e
 	}
-	nextValid := func(ctx context.Context, req interface{}) (interface{}, error) {
+	nextValid := func(context.Context, interface{}) (interface{}, error) {
 		return "Hello valid", nil
 	}
 
diff --git a/middleware/middleware_test.go b/middleware/middleware_test.go
index 11986b0afd9..4714ff9782c 100644
--- a/middleware/middleware_test.go
+++ b/middleware/middleware_test.go
@@ -10,8 +10,10 @@ import (
 var i int
 
 func TestChain(t *testing.T) {
-	next := func(ctx context.Context, req interface{}) (interface{}, error) {
-		t.Log(req)
+	next := func(_ context.Context, req interface{}) (interface{}, error) {
+		if req != "hello kratos!" {
+			t.Errorf("expect %v, got %v", "hello kratos!", req)
+		}
 		i += 10
 		return "reply", nil
 	}
diff --git a/middleware/ratelimit/ratelimit_test.go b/middleware/ratelimit/ratelimit_test.go
index b1422347e9c..20cf9934d5d 100644
--- a/middleware/ratelimit/ratelimit_test.go
+++ b/middleware/ratelimit/ratelimit_test.go
@@ -41,7 +41,7 @@ func Test_WithLimiter(t *testing.T) {
 }
 
 func TestServer(t *testing.T) {
-	nextValid := func(ctx context.Context, req interface{}) (interface{}, error) {
+	nextValid := func(context.Context, interface{}) (interface{}, error) {
 		return "Hello valid", nil
 	}
 
diff --git a/middleware/recovery/recovery.go b/middleware/recovery/recovery.go
index 53e67f81bd4..4c02820e4f5 100644
--- a/middleware/recovery/recovery.go
+++ b/middleware/recovery/recovery.go
@@ -36,7 +36,7 @@ func WithHandler(h HandlerFunc) Option {
 // Recovery is a server middleware that recovers from any panics.
 func Recovery(opts ...Option) middleware.Middleware {
 	op := options{
-		handler: func(ctx context.Context, req, err interface{}) error {
+		handler: func(context.Context, any, any) error {
 			return ErrUnknownRequest
 		},
 	}
@@ -48,7 +48,7 @@ func Recovery(opts ...Option) middleware.Middleware {
 			startTime := time.Now()
 			defer func() {
 				if rerr := recover(); rerr != nil {
-					buf := make([]byte, 64<<10) //nolint:gomnd
+					buf := make([]byte, 64<<10) //nolint:mnd
 					n := runtime.Stack(buf, false)
 					buf = buf[:n]
 					log.Context(ctx).Errorf("%v: %+v\n%s\n", rerr, req, buf)
diff --git a/middleware/recovery/recovery_test.go b/middleware/recovery/recovery_test.go
index b20b5652ce3..915861a206d 100644
--- a/middleware/recovery/recovery_test.go
+++ b/middleware/recovery/recovery_test.go
@@ -15,7 +15,7 @@ func TestOnce(t *testing.T) {
 		}
 	}()
 
-	next := func(ctx context.Context, req interface{}) (interface{}, error) {
+	next := func(context.Context, interface{}) (interface{}, error) {
 		panic("panic reason")
 	}
 	_, e := Recovery(WithHandler(func(ctx context.Context, _, err interface{}) error {
@@ -29,11 +29,11 @@ func TestOnce(t *testing.T) {
 }
 
 func TestNotPanic(t *testing.T) {
-	next := func(ctx context.Context, req interface{}) (interface{}, error) {
+	next := func(_ context.Context, req interface{}) (interface{}, error) {
 		return req.(string) + "https://go-kratos.dev", nil
 	}
 
-	_, e := Recovery(WithHandler(func(ctx context.Context, req, err interface{}) error {
+	_, e := Recovery(WithHandler(func(_ context.Context, _ any, err any) error {
 		return errors.InternalServer("RECOVERY", fmt.Sprintf("panic triggered: %v", err))
 	}))(next)(context.Background(), "notPanic")
 	if e != nil {
diff --git a/middleware/selector/selector_test.go b/middleware/selector/selector_test.go
index 0835ef84414..1769f7c0f68 100644
--- a/middleware/selector/selector_test.go
+++ b/middleware/selector/selector_test.go
@@ -96,7 +96,7 @@ func TestMatch(t *testing.T) {
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			next := func(ctx context.Context, req interface{}) (interface{}, error) {
+			next := func(_ context.Context, req interface{}) (interface{}, error) {
 				t.Log(req)
 				return "reply", nil
 			}
@@ -132,7 +132,7 @@ func TestMatchClient(t *testing.T) {
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			next := func(ctx context.Context, req interface{}) (interface{}, error) {
+			next := func(_ context.Context, req interface{}) (interface{}, error) {
 				t.Log(req)
 				return "reply", nil
 			}
@@ -167,11 +167,11 @@ func TestFunc(t *testing.T) {
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			next := func(ctx context.Context, req interface{}) (interface{}, error) {
+			next := func(_ context.Context, req interface{}) (interface{}, error) {
 				t.Log(req)
 				return "reply", nil
 			}
-			next = Server(testMiddleware).Match(func(ctx context.Context, operation string) bool {
+			next = Server(testMiddleware).Match(func(_ context.Context, operation string) bool {
 				if strings.HasPrefix(operation, "/go-kratos.dev") || strings.HasSuffix(operation, "world") {
 					return true
 				}
@@ -224,11 +224,11 @@ func TestHeaderFunc(t *testing.T) {
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			next := func(ctx context.Context, req interface{}) (interface{}, error) {
+			next := func(_ context.Context, req interface{}) (interface{}, error) {
 				t.Log(req)
 				return "reply", nil
 			}
-			next = Server(testMiddleware).Match(func(ctx context.Context, operation string) bool {
+			next = Server(testMiddleware).Match(func(ctx context.Context, _ string) bool {
 				tr, ok := transport.FromServerContext(ctx)
 				if !ok {
 					return false
diff --git a/middleware/tracing/span.go b/middleware/tracing/span.go
index a0a9d462df5..1fa241ec37a 100644
--- a/middleware/tracing/span.go
+++ b/middleware/tracing/span.go
@@ -104,7 +104,7 @@ func setServerSpan(ctx context.Context, span trace.Span, m interface{}) {
 func parseFullMethod(fullMethod string) (string, []attribute.KeyValue) {
 	name := strings.TrimLeft(fullMethod, "/")
 	parts := strings.SplitN(name, "/", 2)
-	if len(parts) != 2 { //nolint:gomnd
+	if len(parts) != 2 { //nolint:mnd
 		// Invalid format, does not follow `/package.service/method`.
 		return name, []attribute.KeyValue{attribute.Key("rpc.operation").String(fullMethod)}
 	}
diff --git a/middleware/tracing/tracing_test.go b/middleware/tracing/tracing_test.go
index 72740bafa24..fe902802862 100644
--- a/middleware/tracing/tracing_test.go
+++ b/middleware/tracing/tracing_test.go
@@ -166,7 +166,6 @@ func TestServer(t *testing.T) {
 		WithTracerProvider(tracesdk.NewTracerProvider()),
 		WithPropagator(propagation.NewCompositeTextMapPropagator(propagation.Baggage{}, propagation.TraceContext{})),
 	)(next)(context.Background(), "test server: ")
-
 	if err != nil {
 		t.Errorf("expected error, got nil")
 	}
diff --git a/middleware/validate/validate_test.go b/middleware/validate/validate_test.go
index 34fc3349709..34bea301411 100644
--- a/middleware/validate/validate_test.go
+++ b/middleware/validate/validate_test.go
@@ -24,7 +24,7 @@ func (v protoVali) Validate() error {
 }
 
 func TestTable(t *testing.T) {
-	var mock middleware.Handler = func(ctx context.Context, req interface{}) (interface{}, error) { return nil, nil }
+	var mock middleware.Handler = func(context.Context, interface{}) (interface{}, error) { return nil, nil }
 
 	tests := []protoVali{
 		{"v1", 365, false},
diff --git a/options_test.go b/options_test.go
index e1b7288bd26..03cf4f512fa 100644
--- a/options_test.go
+++ b/options_test.go
@@ -66,9 +66,11 @@ func TestEndpoint(t *testing.T) {
 }
 
 func TestContext(t *testing.T) {
-	type ctxKey = struct{}
+	type ctxKey struct {
+		Key string
+	}
 	o := &options{}
-	v := context.WithValue(context.TODO(), ctxKey{}, "b")
+	v := context.WithValue(context.TODO(), ctxKey{Key: "context"}, "b")
 	Context(v)(o)
 	if !reflect.DeepEqual(v, o.ctx) {
 		t.Fatalf("o.ctx:%s is not equal to v:%s", o.ctx, v)
diff --git a/selector/node/direct/direct.go b/selector/node/direct/direct.go
index d32fc31480d..eeb6e2190ac 100644
--- a/selector/node/direct/direct.go
+++ b/selector/node/direct/direct.go
@@ -36,7 +36,7 @@ func (*Builder) Build(n selector.Node) selector.WeightedNode {
 func (n *Node) Pick() selector.DoneFunc {
 	now := time.Now().UnixNano()
 	atomic.StoreInt64(&n.lastPick, now)
-	return func(ctx context.Context, di selector.DoneInfo) {}
+	return func(context.Context, selector.DoneInfo) {}
 }
 
 // Weight is node effective weight
diff --git a/selector/node/ewma/node.go b/selector/node/ewma/node.go
index 540a0bb3c1f..b4daeaa6a01 100644
--- a/selector/node/ewma/node.go
+++ b/selector/node/ewma/node.go
@@ -121,7 +121,7 @@ func (n *Node) Pick() selector.DoneFunc {
 	reqs := atomic.AddInt64(&n.reqs, 1)
 	slot := reqs % 200
 	swapped := atomic.CompareAndSwapInt64(&n.inflights[slot], 0, start)
-	return func(ctx context.Context, di selector.DoneInfo) {
+	return func(_ context.Context, di selector.DoneInfo) {
 		if swapped {
 			atomic.CompareAndSwapInt64(&n.inflights[slot], start, 0)
 		}
diff --git a/selector/selector_test.go b/selector/selector_test.go
index b7b963f0c4c..75d3887a6f7 100644
--- a/selector/selector_test.go
+++ b/selector/selector_test.go
@@ -37,7 +37,7 @@ func (n *mockWeightedNode) Weight() float64 {
 func (n *mockWeightedNode) Pick() DoneFunc {
 	now := time.Now().UnixNano()
 	atomic.StoreInt64(&n.lastPick, now)
-	return func(ctx context.Context, di DoneInfo) {}
+	return func(context.Context, DoneInfo) {}
 }
 
 // PickElapsed is time elapsed since the latest pick
diff --git a/transport/grpc/client.go b/transport/grpc/client.go
index edc57d3efef..0f4610e9424 100644
--- a/transport/grpc/client.go
+++ b/transport/grpc/client.go
@@ -114,8 +114,8 @@ func WithHealthCheck(healthCheck bool) ClientOption {
 
 // WithLogger with logger
 // Deprecated: use global logger instead.
-func WithLogger(_ log.Logger) ClientOption {
-	return func(o *clientOptions) {}
+func WithLogger(log.Logger) ClientOption {
+	return func(*clientOptions) {}
 }
 
 func WithPrintDiscoveryDebugLog(p bool) ClientOption {
diff --git a/transport/grpc/client_test.go b/transport/grpc/client_test.go
index 2d88f95a618..cdbee600709 100644
--- a/transport/grpc/client_test.go
+++ b/transport/grpc/client_test.go
@@ -84,7 +84,7 @@ func TestUnaryClientInterceptor(t *testing.T) {
 	resp := &struct{}{}
 
 	err := f(context.TODO(), "hello", req, resp, &grpc.ClientConn{},
-		func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, opts ...grpc.CallOption) error {
+		func(context.Context, string, any, any, *grpc.ClientConn, ...grpc.CallOption) error {
 			return nil
 		})
 	if err != nil {
@@ -95,10 +95,10 @@ func TestUnaryClientInterceptor(t *testing.T) {
 func TestWithUnaryInterceptor(t *testing.T) {
 	o := &clientOptions{}
 	v := []grpc.UnaryClientInterceptor{
-		func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
+		func(context.Context, string, any, any, *grpc.ClientConn, grpc.UnaryInvoker, ...grpc.CallOption) error {
 			return nil
 		},
-		func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
+		func(context.Context, string, any, any, *grpc.ClientConn, grpc.UnaryInvoker, ...grpc.CallOption) error {
 			return nil
 		},
 	}
diff --git a/transport/grpc/server.go b/transport/grpc/server.go
index c8c3f4f3bcc..0c0fb0562b4 100644
--- a/transport/grpc/server.go
+++ b/transport/grpc/server.go
@@ -61,8 +61,8 @@ func Timeout(timeout time.Duration) ServerOption {
 
 // Logger with server logger.
 // Deprecated: use global logger instead.
-func Logger(_ log.Logger) ServerOption {
-	return func(s *Server) {}
+func Logger(log.Logger) ServerOption {
+	return func(*Server) {}
 }
 
 // Middleware with server middleware.
diff --git a/transport/grpc/server_test.go b/transport/grpc/server_test.go
index d9d2c7af376..f45906b5f90 100644
--- a/transport/grpc/server_test.go
+++ b/transport/grpc/server_test.go
@@ -83,7 +83,7 @@ func TestServer(t *testing.T) {
 					return handler(ctx, req)
 				}
 			}),
-		UnaryInterceptor(func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
+		UnaryInterceptor(func(ctx context.Context, req interface{}, _ *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
 			return handler(ctx, req)
 		}),
 		Options(grpc.InitialConnWindowSize(0)),
@@ -212,10 +212,10 @@ func TestTLSConfig(t *testing.T) {
 func TestUnaryInterceptor(t *testing.T) {
 	o := &Server{}
 	v := []grpc.UnaryServerInterceptor{
-		func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
+		func(context.Context, interface{}, *grpc.UnaryServerInfo, grpc.UnaryHandler) (resp interface{}, err error) {
 			return nil, nil
 		},
-		func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
+		func(context.Context, interface{}, *grpc.UnaryServerInfo, grpc.UnaryHandler) (resp interface{}, err error) {
 			return nil, nil
 		},
 	}
@@ -228,10 +228,10 @@ func TestUnaryInterceptor(t *testing.T) {
 func TestStreamInterceptor(t *testing.T) {
 	o := &Server{}
 	v := []grpc.StreamServerInterceptor{
-		func(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
+		func(interface{}, grpc.ServerStream, *grpc.StreamServerInfo, grpc.StreamHandler) error {
 			return nil
 		},
-		func(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
+		func(interface{}, grpc.ServerStream, *grpc.StreamServerInfo, grpc.StreamHandler) error {
 			return nil
 		},
 	}
@@ -269,7 +269,7 @@ func TestServer_unaryServerInterceptor(t *testing.T) {
 	}
 	srv.middleware.Use(EmptyMiddleware())
 	req := &struct{}{}
-	rv, err := srv.unaryServerInterceptor()(context.TODO(), req, &grpc.UnaryServerInfo{}, func(ctx context.Context, req interface{}) (i interface{}, e error) {
+	rv, err := srv.unaryServerInterceptor()(context.TODO(), req, &grpc.UnaryServerInfo{}, func(context.Context, interface{}) (interface{}, error) {
 		return &testResp{Data: "hi"}, nil
 	})
 	if err != nil {
diff --git a/transport/http/binding/encode.go b/transport/http/binding/encode.go
index 5f12cf37071..2c1eda9ce50 100644
--- a/transport/http/binding/encode.go
+++ b/transport/http/binding/encode.go
@@ -20,7 +20,7 @@ func EncodeURL(pathTemplate string, msg interface{}, needQuery bool) string {
 	pathParams := make(map[string]struct{})
 	path := reg.ReplaceAllStringFunc(pathTemplate, func(in string) string {
 		// it's unreachable because the reg means that must have more than one char in {}
-		// if len(in) < 4 { //nolint:gomnd // **  explain the 4 number here :-) **
+		// if len(in) < 4 { //nolint:mnd // **  explain the 4 number here :-) **
 		//	return in
 		// }
 		key := in[1 : len(in)-1]
diff --git a/transport/http/client.go b/transport/http/client.go
index 1d74542d522..d7efbcc8646 100644
--- a/transport/http/client.go
+++ b/transport/http/client.go
@@ -252,7 +252,7 @@ func (client *Client) Invoke(ctx context.Context, method, path string, args inte
 }
 
 func (client *Client) invoke(ctx context.Context, req *http.Request, args interface{}, reply interface{}, c callInfo, opts ...CallOption) error {
-	h := func(ctx context.Context, in interface{}) (interface{}, error) {
+	h := func(ctx context.Context, _ interface{}) (interface{}, error) {
 		res, err := client.do(req.WithContext(ctx))
 		if res != nil {
 			cs := csAttempt{res: res}
diff --git a/transport/http/client_test.go b/transport/http/client_test.go
index 25ae9a8ecf1..eed932318eb 100644
--- a/transport/http/client_test.go
+++ b/transport/http/client_test.go
@@ -118,7 +118,7 @@ func TestWithEndpoint(t *testing.T) {
 
 func TestWithRequestEncoder(t *testing.T) {
 	o := &clientOptions{}
-	v := func(ctx context.Context, contentType string, in interface{}) (body []byte, err error) {
+	v := func(context.Context, string, interface{}) (body []byte, err error) {
 		return nil, nil
 	}
 	WithRequestEncoder(v)(o)
@@ -129,7 +129,7 @@ func TestWithRequestEncoder(t *testing.T) {
 
 func TestWithResponseDecoder(t *testing.T) {
 	o := &clientOptions{}
-	v := func(ctx context.Context, res *http.Response, out interface{}) error { return nil }
+	v := func(context.Context, *http.Response, interface{}) error { return nil }
 	WithResponseDecoder(v)(o)
 	if o.decoder == nil {
 		t.Errorf("expected encoder to be not nil")
@@ -138,7 +138,7 @@ func TestWithResponseDecoder(t *testing.T) {
 
 func TestWithErrorDecoder(t *testing.T) {
 	o := &clientOptions{}
-	v := func(ctx context.Context, res *http.Response) error { return nil }
+	v := func(context.Context, *http.Response) error { return nil }
 	WithErrorDecoder(v)(o)
 	if o.errorDecoder == nil {
 		t.Errorf("expected encoder to be not nil")
@@ -354,7 +354,7 @@ func TestNewClient(t *testing.T) {
 	if err == nil {
 		t.Error("err should be equal to callOption err")
 	}
-	client.opts.encoder = func(ctx context.Context, contentType string, in interface{}) (body []byte, err error) {
+	client.opts.encoder = func(context.Context, string, interface{}) (body []byte, err error) {
 		return nil, errors.New("mock test encoder error")
 	}
 	err = client.Invoke(context.Background(), http.MethodPost, "/go", map[string]string{"name": "kratos"}, nil, EmptyCallOption{})
diff --git a/transport/http/context_test.go b/transport/http/context_test.go
index 8cc79da0c0b..b4949a02f7a 100644
--- a/transport/http/context_test.go
+++ b/transport/http/context_test.go
@@ -102,7 +102,7 @@ func TestContextResponse(t *testing.T) {
 
 func TestResponseUnwrap(t *testing.T) {
 	res := httptest.NewRecorder()
-	f := func(rw http.ResponseWriter, r *http.Request, a interface{}) error {
+	f := func(rw http.ResponseWriter, _ *http.Request, _ interface{}) error {
 		u, ok := rw.(interface {
 			Unwrap() http.ResponseWriter
 		})
diff --git a/transport/http/router_test.go b/transport/http/router_test.go
index e6def62e11e..00b1a7dd1a4 100644
--- a/transport/http/router_test.go
+++ b/transport/http/router_test.go
@@ -75,7 +75,7 @@ func TestRoute(t *testing.T) {
 		if err := ctx.Bind(u); err != nil {
 			return err
 		}
-		h := ctx.Middleware(func(ctx context.Context, in interface{}) (interface{}, error) {
+		h := ctx.Middleware(func(context.Context, interface{}) (interface{}, error) {
 			return u, nil
 		})
 		return ctx.Returns(h(ctx, u))
@@ -184,7 +184,7 @@ func TestRouter_Group(t *testing.T) {
 
 func TestHandle(_ *testing.T) {
 	r := newRouter("/", NewServer())
-	h := func(i Context) error {
+	h := func(Context) error {
 		return nil
 	}
 	r.GET("/get", h)
diff --git a/transport/http/server.go b/transport/http/server.go
index 917b41e1981..457fe724a32 100644
--- a/transport/http/server.go
+++ b/transport/http/server.go
@@ -58,8 +58,8 @@ func Timeout(timeout time.Duration) ServerOption {
 
 // Logger with server logger.
 // Deprecated: use global logger instead.
-func Logger(_ log.Logger) ServerOption {
-	return func(s *Server) {}
+func Logger(log.Logger) ServerOption {
+	return func(*Server) {}
 }
 
 // Middleware with service middleware option.
@@ -214,7 +214,7 @@ func (s *Server) Use(selector string, m ...middleware.Middleware) {
 
 // WalkRoute walks the router and all its sub-routers, calling walkFn for each route in the tree.
 func (s *Server) WalkRoute(fn WalkRouteFunc) error {
-	return s.router.Walk(func(route *mux.Route, router *mux.Router, ancestors []*mux.Route) error {
+	return s.router.Walk(func(route *mux.Route, _ *mux.Router, _ []*mux.Route) error {
 		methods, err := route.GetMethods()
 		if err != nil {
 			return nil // ignore no methods
diff --git a/transport/http/server_test.go b/transport/http/server_test.go
index 4447750483d..5b9c35c8956 100644
--- a/transport/http/server_test.go
+++ b/transport/http/server_test.go
@@ -48,7 +48,7 @@ func TestServeHTTP(t *testing.T) {
 	}
 	mux := NewServer(Listener(ln))
 	mux.HandleFunc("/index", h)
-	mux.Route("/errors").GET("/cause", func(ctx Context) error {
+	mux.Route("/errors").GET("/cause", func(Context) error {
 		return kratoserrors.BadRequest("xxx", "zzz").
 			WithMetadata(map[string]string{"foo": "bar"}).
 			WithCause(errors.New("error cause"))
@@ -86,7 +86,7 @@ func TestServer(t *testing.T) {
 	srv.HandleHeader("content-type", "application/grpc-web+json", func(w http.ResponseWriter, r *http.Request) {
 		_ = json.NewEncoder(w).Encode(testData{Path: r.RequestURI})
 	})
-	srv.Route("/errors").GET("/cause", func(ctx Context) error {
+	srv.Route("/errors").GET("/cause", func(Context) error {
 		return kratoserrors.BadRequest("xxx", "zzz").
 			WithMetadata(map[string]string{"foo": "bar"}).
 			WithCause(errors.New("error cause"))
@@ -153,8 +153,7 @@ func testHeader(t *testing.T, srv *Server) {
 	if err != nil {
 		t.Errorf("expected nil got %v", err)
 	}
-	reqURL := fmt.Sprintf(e.String() + "/index")
-	req, err := http.NewRequest(http.MethodGet, reqURL, nil)
+	req, err := http.NewRequest(http.MethodGet, e.String()+"/index", nil)
 	if err != nil {
 		t.Errorf("expected nil got %v", err)
 	}
@@ -199,7 +198,7 @@ func testClient(t *testing.T, srv *Server) {
 	defer client.Close()
 	for _, test := range tests {
 		var res testData
-		reqURL := fmt.Sprintf(e.String() + test.path)
+		reqURL := e.String() + test.path
 		req, err := http.NewRequest(test.method, reqURL, nil)
 		if err != nil {
 			t.Fatal(err)