*: update the error dependency and do the corresponding changes

client/base_client.go

@@ -20,9 +20,9 @@ import (
 	"sync"
 	"time"
 
+	"github.com/pingcap/errors"
 	"github.com/pingcap/kvproto/pkg/pdpb"
 	"github.com/pingcap/log"
-	"github.com/pkg/errors"
 	"github.com/tikv/pd/pkg/errs"
 	"github.com/tikv/pd/pkg/grpcutil"
 	"go.uber.org/zap"
@@ -138,7 +138,7 @@ func (c *baseClient) leaderLoop() {
 		}
 
 		if err := c.updateLeader(); err != nil {
-			log.Error("[pd] failed updateLeader", zap.Error(errs.ErrUpdateLeader.FastGenByArgs()), zap.NamedError("cause", err))
+			log.Error("[pd] failed updateLeader", errs.ZapError(errs.ErrUpdateLeader, err))
 		}
 	}
 }
@@ -178,7 +178,7 @@ func (c *baseClient) initClusterID() error {
 		members, err := c.getMembers(timeoutCtx, u)
 		timeoutCancel()
 		if err != nil || members.GetHeader() == nil {
-			log.Warn("[pd] failed to get cluster id", zap.String("url", u), zap.Error(errs.ErrGetClusterID.FastGenByArgs()), zap.NamedError("cause", err))
+			log.Warn("[pd] failed to get cluster id", zap.String("url", u), errs.ZapError(errs.ErrGetClusterID, err))
 			continue
 		}
 		c.clusterID = members.GetHeader().GetClusterId()
@@ -192,7 +192,7 @@ func (c *baseClient) updateLeader() error {
 		ctx, cancel := context.WithTimeout(c.ctx, updateLeaderTimeout)
 		members, err := c.getMembers(ctx, u)
 		if err != nil {
-			log.Warn("[pd] cannot update leader", zap.String("address", u), zap.Error(errs.ErrUpdateLeader.FastGenByArgs()), zap.NamedError("cause", err))
+			log.Warn("[pd] cannot update leader", zap.String("address", u), errs.ZapError(errs.ErrUpdateLeader, err))
 		}
 		cancel()
 		if err != nil || members.GetLeader() == nil || len(members.GetLeader().GetClientUrls()) == 0 {

client/client.go

@@ -235,7 +235,7 @@ func (c *client) tsLoop() {
 					return
 				default:
 				}
-				log.Error("[pd] create tso stream error", zap.Error(errs.ErrCreateTSOStream.FastGenByArgs()), zap.NamedError("cause", err))
+				log.Error("[pd] create tso stream error", errs.ZapError(errs.ErrCreateTSOStream, err))
 				c.ScheduleCheckLeader()
 				cancel()
 				c.revokeTSORequest(errors.WithStack(err))
@@ -282,7 +282,7 @@ func (c *client) tsLoop() {
 				return
 			default:
 			}
-			log.Error("[pd] getTS error", zap.Error(errs.ErrGetTSO.FastGenByArgs()), zap.NamedError("cause", err))
+			log.Error("[pd] getTS error", errs.ZapError(errs.ErrGetTSO, err))
 			c.ScheduleCheckLeader()
 			cancel()
 			stream, cancel = nil, nil
@@ -379,7 +379,7 @@ func (c *client) Close() {
 	defer c.connMu.Unlock()
 	for _, cc := range c.connMu.clientConns {
 		if err := cc.Close(); err != nil {
-			log.Error("[pd] failed to close gRPC clientConn", zap.Error(errs.ErrCloseGRPCConn.FastGenByArgs()), zap.NamedError("cause", err))
+			log.Error("[pd] failed to close gRPC clientConn", errs.ZapError(errs.ErrCloseGRPCConn, err))
 		}
 	}
 }

go.mod

@@ -54,3 +54,5 @@ require (
 )
 
 replace go.etcd.io/bbolt => go.etcd.io/bbolt v1.3.5
+
+replace github.com/pingcap/errors => github.com/pingcap/errors v0.11.5-0.20200812093836-57ec461934ff

go.sum

@@ -284,10 +284,8 @@ github.com/pingcap/check v0.0.0-20191216031241-8a5a85928f12 h1:rfD9v3+ppLPzoQBgZ
 github.com/pingcap/check v0.0.0-20191216031241-8a5a85928f12/go.mod h1:PYMCGwN0JHjoqGr3HrZoD+b8Tgx8bKnArhSq8YVzUMc=
 github.com/pingcap/errcode v0.0.0-20180921232412-a1a7271709d9 h1:KH4f4Si9XK6/IW50HtoaiLIFHGkapOM6w83za47UYik=
 github.com/pingcap/errcode v0.0.0-20180921232412-a1a7271709d9/go.mod h1:4b2X8xSqxIroj/IZ9MX/VGZhAwc11wB9wRIzHvz6SeM=
-github.com/pingcap/errors v0.11.0/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8=
-github.com/pingcap/errors v0.11.5-0.20190809092503-95897b64e011/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8=
-github.com/pingcap/errors v0.11.5-0.20200729012136-4e113ddee29e h1:/EGWHNOyEgizEBuAujWsb9vXrPZtt1b7ooDPyjEkjDw=
-github.com/pingcap/errors v0.11.5-0.20200729012136-4e113ddee29e/go.mod h1:g4vx//d6VakjJ0mk7iLBlKA8LFavV/sAVINT/1PFxeQ=
+github.com/pingcap/errors v0.11.5-0.20200812093836-57ec461934ff h1:5MCSOM1ydTR9tXY2IrdWODUrnDdSjb1yluNHDO1sVN4=
+github.com/pingcap/errors v0.11.5-0.20200812093836-57ec461934ff/go.mod h1:g4vx//d6VakjJ0mk7iLBlKA8LFavV/sAVINT/1PFxeQ=
 github.com/pingcap/failpoint v0.0.0-20191029060244-12f4ac2fd11d h1:F8vp38kTAckN+v8Jlc98uMBvKIzr1a+UhnLyVYn8Q5Q=
 github.com/pingcap/failpoint v0.0.0-20191029060244-12f4ac2fd11d/go.mod h1:DNS3Qg7bEDhU6EXNHF+XSv/PGznQaMJ5FWvctpm6pQI=
 github.com/pingcap/kvproto v0.0.0-20191211054548-3c6b38ea5107/go.mod h1:WWLmULLO7l8IOcQG+t+ItJ3fEcrL5FxF0Wu+HrMy26w=

pkg/dashboard/adapter/manager.go

@@ -196,7 +196,7 @@ func (m *Manager) startService() {
 		return
 	}
 	if err := m.service.Start(m.ctx); err != nil {
-		log.Error("Can not start dashboard server", zap.Error(errs.ErrStartDashboard.FastGenByArgs()), zap.NamedError("cause", err))
+		log.Error("Can not start dashboard server", errs.ZapError(errs.ErrStartDashboard, err))
 	} else {
 		log.Info("Dashboard server is started")
 	}
@@ -207,7 +207,7 @@ func (m *Manager) stopService() {
 		return
 	}
 	if err := m.service.Stop(context.Background()); err != nil {
-		log.Error("Stop dashboard server error", zap.Error(errs.ErrStopDashboard.FastGenByArgs()), zap.NamedError("cause", err))
+		log.Error("Stop dashboard server error", errs.ZapError(errs.ErrStopDashboard, err))
 	} else {
 		log.Info("Dashboard server is stopped")
 	}

pkg/errs/errno.go

@@ -0,0 +1,64 @@
+// Copyright 2020 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package errs
+
+import "github.com/pingcap/errors"
+
+// tso errors
+var (
+	ErrInvalidTimestamp    = errors.Normalize("invalid timestamp", errors.RFCCodeText("PD:tso:ErrInvalidTimestamp"))
+	ErrLogicOverflow       = errors.Normalize("logic part overflow", errors.RFCCodeText("PD:tso:ErrLogicOverflow"))
+	ErrIncorrectSystemTime = errors.Normalize("incorrect system time", errors.RFCCodeText("PD:tso:ErrIncorrectSystemTime"))
+)
+
+// adapter errors
+var (
+	ErrStartDashboard = errors.Normalize("start dashboard failed", errors.RFCCodeText("PD:adapter:ErrStartDashboard"))
+	ErrStopDashboard  = errors.Normalize("stop dashboard failed", errors.RFCCodeText("PD:adapter:ErrStopDashboard"))
+)
+
+// member errors
+var (
+	ErretcdLeaderNotFound     = errors.Normalize("etcd leader not found", errors.RFCCodeText("PD:member:ErretcdLeaderNotFound"))
+	ErrGetLeader              = errors.Normalize("get leader failed", errors.RFCCodeText("PD:member:ErrGetLeader"))
+	ErrDeleteLeaderKey        = errors.Normalize("delete leader key failed", errors.RFCCodeText("PD:member:ErrDeleteLeaderKey"))
+	ErrLoadLeaderPriority     = errors.Normalize("load leader priority failed", errors.RFCCodeText("PD:member:ErrLoadLeaderPriority"))
+	ErrLoadetcdLeaderPriority = errors.Normalize("load etcd leader priority failed", errors.RFCCodeText("PD:member:ErrLoadetcdLeaderPriority"))
+	ErrTransferetcdLeader     = errors.Normalize("transfer etcd leader failed", errors.RFCCodeText("PD:member:ErrTransferetcdLeader"))
+	ErrWatcherCancel          = errors.Normalize("watcher canceled", errors.RFCCodeText("PD:member:ErrWatcherCancel"))
+	ErrMarshalLeader          = errors.Normalize("marshal leader failed", errors.RFCCodeText("PD:member:ErrMarshalLeader"))
+)
+
+// client errors
+var (
+	ErrCloseGRPCConn   = errors.Normalize("close gRPC connection failed", errors.RFCCodeText("PD:client:ErrCloseGRPCConn"))
+	ErrUpdateLeader    = errors.Normalize("update leader failed", errors.RFCCodeText("PD:client:ErrUpdateLeader"))
+	ErrCreateTSOStream = errors.Normalize("create TSO stream failed", errors.RFCCodeText("PD:client:ErrCreateTSOStream"))
+	ErrGetTSO          = errors.Normalize("get TSO failed", errors.RFCCodeText("PD:client:ErrGetTSO"))
+	ErrGetClusterID    = errors.Normalize("get cluster ID failed", errors.RFCCodeText("PD:client:ErrGetClusterID"))
+)
+
+// placement errors
+var (
+	ErrRuleContent   = errors.Normalize("invalid rule content, %s", errors.RFCCodeText("PD:placement:ErrRuleContent"))
+	ErrLoadRule      = errors.Normalize("load rule failed", errors.RFCCodeText("PD:placement:ErrLoadRule"))
+	ErrLoadRuleGroup = errors.Normalize("load rule group failed", errors.RFCCodeText("PD:placement:ErrLoadRuleGroup"))
+	ErrBuildRuleList = errors.Normalize("build rule list failed, %s", errors.RFCCodeText("PD:placement:ErrBuildRuleList"))
+)
+
+// kv errors
+var (
+	ErrEtcdKVSave   = errors.Normalize("etcd KV save failed", errors.RFCCodeText("PD:kv:ErrEtcdKVSave"))
+	ErrEtcdKVRemove = errors.Normalize("etcd KV remove failed", errors.RFCCodeText("PD:kv:ErrEtcdKVRemove"))
+)

pkg/errs/errs.go

@@ -13,68 +13,14 @@
 
 package errs
 
-import "github.com/pingcap/errors"
-
-var (
-	reg = errors.NewRegistry("PD")
-	// ClassTSO defines tso error class
-	ClassTSO = reg.RegisterErrorClass(1, "tso")
-	// ClassAdaptor defines adapter error class
-	ClassAdaptor = reg.RegisterErrorClass(2, "adapter")
-	// ClassMember defines member error class
-	ClassMember = reg.RegisterErrorClass(3, "member")
-	// ClassClient defines client error class
-	ClassClient = reg.RegisterErrorClass(4, "client")
-	// ClassPlacement defines placement error class
-	ClassPlacement = reg.RegisterErrorClass(5, "placement")
-	// ClassKV defines KV error class
-	ClassKV = reg.RegisterErrorClass(6, "kv")
-)
-
-// tso errors
-var (
-	ErrInvalidTimestamp    = ClassTSO.DefineError().TextualCode("ErrInvalidTimestamp").MessageTemplate("invalid timestamp").Build()
-	ErrLogicOverflow       = ClassTSO.DefineError().TextualCode("ErrLogicOverflow").MessageTemplate("logic part overflow").Build()
-	ErrIncorrectSystemTime = ClassTSO.DefineError().TextualCode("ErrIncorrectSystemTime").MessageTemplate("incorrect system time").Build()
-)
-
-// adapter errors
-var (
-	ErrStartDashboard = ClassAdaptor.DefineError().TextualCode("ErrStartDashboard").MessageTemplate("fail to start dashboard").Build()
-	ErrStopDashboard  = ClassAdaptor.DefineError().TextualCode("ErrStopDashboard").MessageTemplate("fail to stop dashboard").Build()
-)
-
-// member errors
-var (
-	ErretcdLeaderNotFound     = ClassMember.DefineError().TextualCode("ErretcdLeaderNotFound").MessageTemplate("etcd leader not found").Build()
-	ErrGetLeader              = ClassMember.DefineError().TextualCode("ErrGetLeader").MessageTemplate("fail to get leader").Build()
-	ErrDeleteLeaderKey        = ClassMember.DefineError().TextualCode("ErrDeleteLeaderKey").MessageTemplate("fail to delete leader key").Build()
-	ErrLoadLeaderPriority     = ClassMember.DefineError().TextualCode("ErrLoadLeaderPriority").MessageTemplate("fail to load leader priority").Build()
-	ErrLoadetcdLeaderPriority = ClassMember.DefineError().TextualCode("ErrLoadetcdLeaderPriority").MessageTemplate("fail to load etcd leader priority").Build()
-	ErrTransferetcdLeader     = ClassMember.DefineError().TextualCode("ErrTransferetcdLeader").MessageTemplate("fail to transfer etcd leader").Build()
-	ErrWatcherCancel          = ClassMember.DefineError().TextualCode("ErrWatcherCancel").MessageTemplate("watcher canceled").Build()
-	ErrMarshalLeader          = ClassMember.DefineError().TextualCode("ErrMarshalLeader").MessageTemplate("fail to marshal leader").Build()
-)
-
-// client errors
-var (
-	ErrCloseGRPCConn   = ClassClient.DefineError().TextualCode("ErrCloseGRPCConn").MessageTemplate("fail to close gRPC connection").Build()
-	ErrUpdateLeader    = ClassClient.DefineError().TextualCode("ErrUpdateLeader").MessageTemplate("fail to update leader").Build()
-	ErrCreateTSOStream = ClassClient.DefineError().TextualCode("ErrCreateTSOStream").MessageTemplate("fail to create TSO stream").Build()
-	ErrGetTSO          = ClassClient.DefineError().TextualCode("ErrGetTSO").MessageTemplate("fail to get TSO").Build()
-	ErrGetClusterID    = ClassClient.DefineError().TextualCode("ErrGetClusterID").MessageTemplate("fail to get cluster id").Build()
+import (
+	"github.com/pingcap/errors"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
 )
 
-// placement errors
-var (
-	ErrRuleContent   = ClassPlacement.DefineError().TextualCode("ErrRuleContent").MessageTemplate("invalid rule content, %s").Build()
-	ErrLoadRule      = ClassPlacement.DefineError().TextualCode("ErrLoadRule").MessageTemplate("fail to load rule").Build()
-	ErrLoadRuleGroup = ClassPlacement.DefineError().TextualCode("ErrLoadRuleGroup").MessageTemplate("fail to load rule group").Build()
-	ErrBuildRuleList = ClassPlacement.DefineError().TextualCode("ErrBuildRuleList").MessageTemplate("fail to build rule list, %s").Build()
-)
-
-// kv errors
-var (
-	ErrEtcdKvSave   = ClassKV.DefineError().TextualCode("ErrEtcdKvSave").MessageTemplate("etcd kv save error, key is %s, value is %s").Build()
-	ErrEtcdKvRemove = ClassKV.DefineError().TextualCode("ErrEtcdKvRemove").MessageTemplate("etcd kv remove error, key is %s").Build()
-)
+// ZapError is used to make the log output eaiser.
+func ZapError(err *errors.Error, causeError error) zap.Field {
+	e := err.Wrap(causeError).FastGenWithCause()
+	return zap.Field{Key: "error", Type: zapcore.ErrorType, Interface: e}
+}

pkg/errs/errs_test.go

@@ -15,11 +15,12 @@ package errs
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"strings"
 	"testing"
 
+	. "github.com/pingcap/check"
+	"github.com/pingcap/errors"
 	"github.com/pingcap/log"
 	"go.uber.org/zap"
 )
@@ -50,12 +51,11 @@ type verifyLogger struct {
 	w *testingWriter
 }
 
-func (logger *verifyLogger) Contain(t *testing.T, s string) {
+func (logger *verifyLogger) Message() string {
 	if logger.w.messages == nil {
-		t.Error()
+		return ""
 	}
-	msg := logger.w.messages[len(logger.w.messages)-1]
-	IsContain(t, msg, s)
+	return logger.w.messages[len(logger.w.messages)-1]
 }
 
 func newZapTestLogger(cfg *log.Config, opts ...zap.Option) verifyLogger {
@@ -70,22 +70,25 @@ func newZapTestLogger(cfg *log.Config, opts ...zap.Option) verifyLogger {
 	}
 }
 
-func IsContain(t *testing.T, s1 string, s2 string) {
-	if !strings.Contains(s1, s2) {
-		t.Error()
-	}
+func Test(t *testing.T) {
+	TestingT(t)
 }
 
-func TestError(t *testing.T) {
+var _ = Suite(&testErrorSuite{})
+
+type testErrorSuite struct{}
+
+func (s *testErrorSuite) TestError(c *C) {
 	conf := &log.Config{Level: "debug", File: log.FileLogConfig{}, DisableTimestamp: true}
 	lg := newZapTestLogger(conf)
 	log.ReplaceGlobals(lg.Logger, nil)
 
 	rfc := `[error="[PD:tso:ErrInvalidTimestamp] invalid timestamp"]`
 	log.Error("test", zap.Error(ErrInvalidTimestamp.FastGenByArgs()))
-	lg.Contain(t, rfc)
-	cause := `[cause="test err"]`
-	log.Error("test", zap.Error(ErrInvalidTimestamp.FastGenByArgs()), zap.NamedError("cause", errors.New("test err")))
-	lg.Contain(t, rfc)
-	lg.Contain(t, cause)
+	c.Assert(strings.Contains(lg.Message(), rfc), IsTrue)
+	err := errors.New("test error")
+	log.Error("test", ZapError(ErrInvalidTimestamp, err))
+	rfc = `[error="[PD:tso:ErrInvalidTimestamp] test error"]`
+	fmt.Println(lg.Message())
+	c.Assert(strings.Contains(lg.Message(), rfc), IsTrue)
 }

pkg/etcdutil/etcdutil_test.go

@@ -35,8 +35,7 @@ func Test(t *testing.T) {
 
 var _ = Suite(&testEtcdutilSuite{})
 
-type testEtcdutilSuite struct {
-}
+type testEtcdutilSuite struct{}
 
 func newTestSingleConfig() *embed.Config {
 	cfg := embed.NewConfig()

server/kv/etcd_kv.go

@@ -93,7 +93,7 @@ func (kv *etcdKVBase) Save(key, value string) error {
 	txn := NewSlowLogTxn(kv.client)
 	resp, err := txn.Then(clientv3.OpPut(key, value)).Commit()
 	if err != nil {
-		log.Error("save to etcd meet error", zap.Error(errs.ErrEtcdKvSave.FastGenByArgs(key, value)), zap.NamedError("cause", err))
+		log.Error("save to etcd meet error", zap.String("key", key), zap.String("value", value), errs.ZapError(errs.ErrEtcdKVSave, err))
 		return errors.WithStack(err)
 	}
 	if !resp.Succeeded {
@@ -108,7 +108,7 @@ func (kv *etcdKVBase) Remove(key string) error {
 	txn := NewSlowLogTxn(kv.client)
 	resp, err := txn.Then(clientv3.OpDelete(key)).Commit()
 	if err != nil {
-		log.Error("remove from etcd meet error", zap.Error(errs.ErrEtcdKvRemove.FastGenByArgs(key)), zap.NamedError("cause", err))
+		log.Error("remove from etcd meet error", zap.String("key", key), errs.ZapError(errs.ErrEtcdKVRemove, err))
 		return errors.WithStack(err)
 	}
 	if !resp.Succeeded {

server/member/member.go

@@ -140,7 +140,7 @@ func (m *Member) CheckLeader(name string) (*pdpb.Member, int64, bool) {
 
 	leader, rev, err := election.GetLeader(m.client, m.GetLeaderPath())
 	if err != nil {
-		log.Error("getting pd leader meets error", zap.Error(errs.ErrGetLeader.FastGenByArgs()), zap.NamedError("cause", err))
+		log.Error("getting pd leader meets error", errs.ZapError(errs.ErrGetLeader, err))
 		time.Sleep(200 * time.Millisecond)
 		return nil, 0, true
 	}
@@ -149,9 +149,8 @@ func (m *Member) CheckLeader(name string) (*pdpb.Member, int64, bool) {
 			// oh, we are already a PD leader, which indicates we may meet something wrong
 			// in previous CampaignLeader. We should delete the leadership and campaign again.
 			log.Warn("the pd leader has not changed, delete and campaign again", zap.Stringer("old-pd-leader", leader))
-			log.Info("current pd leadership", zap.Any("leadership", m.Leadership))
 			if err = m.Leadership.DeleteLeader(); err != nil {
-				log.Error("deleting pd leader key meets error", zap.Error(errs.ErrDeleteLeaderKey.FastGenByArgs()), zap.NamedError("cause", err))
+				log.Error("deleting pd leader key meets error", errs.ZapError(errs.ErrDeleteLeaderKey, err))
 				time.Sleep(200 * time.Millisecond)
 				return nil, 0, true
 			}
@@ -168,18 +167,18 @@ func (m *Member) CheckPriority(ctx context.Context) {
 	}
 	myPriority, err := m.GetMemberLeaderPriority(m.ID())
 	if err != nil {
-		log.Error("failed to load etcd leader priority", zap.Error(errs.ErrLoadLeaderPriority.FastGenByArgs()), zap.NamedError("cause", err))
+		log.Error("failed to load etcd leader priority", errs.ZapError(errs.ErrLoadLeaderPriority, err))
 		return
 	}
 	leaderPriority, err := m.GetMemberLeaderPriority(etcdLeader)
 	if err != nil {
-		log.Error("failed to load etcd leader priority", zap.Error(errs.ErrLoadetcdLeaderPriority.FastGenByArgs()), zap.NamedError("cause", err))
+		log.Error("failed to load etcd leader priority", errs.ZapError(errs.ErrLoadetcdLeaderPriority, err))
 		return
 	}
 	if myPriority > leaderPriority {
 		err := m.MoveEtcdLeader(ctx, etcdLeader, m.ID())
 		if err != nil {
-			log.Error("failed to transfer etcd leader", zap.Error(errs.ErrTransferetcdLeader.FastGenByArgs()), zap.NamedError("cause", err))
+			log.Error("failed to transfer etcd leader", errs.ZapError(errs.ErrTransferetcdLeader, err))
 		} else {
 			log.Info("transfer etcd leader",
 				zap.Uint64("from", etcdLeader),
@@ -217,7 +216,7 @@ func (m *Member) MemberInfo(cfg *config.Config, name string, rootPath string) {
 	data, err := leader.Marshal()
 	if err != nil {
 		// can't fail, so panic here.
-		log.Fatal("marshal pd leader meet error", zap.Stringer("pd-leader", leader), zap.Error(errs.ErrMarshalLeader.FastGenByArgs()), zap.NamedError("cause", err))
+		log.Fatal("marshal pd leader meet error", zap.Stringer("pd-leader", leader), errs.ZapError(errs.ErrMarshalLeader, err))
 	}
 	m.member = leader
 	m.memberValue = string(data)
@@ -418,7 +417,7 @@ func (m *Member) WatchLeader(serverCtx context.Context, leader *pdpb.Member, rev
 				break
 			}
 			if wresp.Canceled {
-				log.Error("pd leader watcher is canceled with", zap.Int64("revision", revision), zap.Error(errs.ErrWatcherCancel.FastGenByArgs()), zap.NamedError("cause", wresp.Err()))
+				log.Error("pd leader watcher is canceled with", zap.Int64("revision", revision), errs.ZapError(errs.ErrWatcherCancel, wresp.Err()))
 				return
 			}