tests: Pass logger to backend

etcdutl/etcdutl/backup_command.go

@@ -308,7 +308,7 @@ func saveDB(lg *zap.Logger, destDB, srcDB string, idx uint64, term uint64, desir
 		}
 	}
 
-	be := backend.NewDefaultBackend(destDB)
+	be := backend.NewDefaultBackend(lg, destDB)
 	defer be.Close()
 	ms := schema.NewMembershipBackend(lg, be)
 	if err := ms.TrimClusterFromBackend(); err != nil {

etcdutl/etcdutl/defrag_command.go

@@ -57,7 +57,7 @@ func DefragData(dataDir string) error {
 	dbDir := datadir.ToBackendFileName(dataDir)
 	go func() {
 		defer close(bch)
-		cfg := backend.DefaultBackendConfig()
+		cfg := backend.DefaultBackendConfig(lg)
 		cfg.Logger = lg
 		cfg.Path = dbDir
 		be = backend.New(cfg)

etcdutl/etcdutl/migrate_command.go

@@ -75,6 +75,7 @@ func (o *migrateOptions) AddFlags(cmd *cobra.Command) {
 func (o *migrateOptions) Config() (*migrateConfig, error) {
 	c := &migrateConfig{
 		force: o.force,
+		lg:    GetLogger(),
 	}
 	var err error
 	dotCount := strings.Count(o.targetVersion, ".")
@@ -90,10 +91,10 @@ func (o *migrateOptions) Config() (*migrateConfig, error) {
 	}
 
 	dbPath := datadir.ToBackendFileName(o.dataDir)
-	c.be = backend.NewDefaultBackend(dbPath)
+	c.be = backend.NewDefaultBackend(GetLogger(), dbPath)
 
 	walPath := datadir.ToWalDir(o.dataDir)
-	w, err := wal.OpenForRead(GetLogger(), walPath, walpb.Snapshot{})
+	w, err := wal.OpenForRead(c.lg, walPath, walpb.Snapshot{})
 	if err != nil {
 		return nil, fmt.Errorf(`failed to open wal: %v`, err)
 	}
@@ -107,6 +108,7 @@ func (o *migrateOptions) Config() (*migrateConfig, error) {
 }
 
 type migrateConfig struct {
+	lg            *zap.Logger
 	be            backend.Backend
 	targetVersion *semver.Version
 	walVersion    schema.WALVersion
@@ -115,24 +117,23 @@ type migrateConfig struct {
 
 func migrateCommandFunc(c *migrateConfig) error {
 	defer c.be.Close()
-	lg := GetLogger()
 	tx := c.be.BatchTx()
-	current, err := schema.DetectSchemaVersion(lg, tx)
+	current, err := schema.DetectSchemaVersion(c.lg, tx)
 	if err != nil {
-		lg.Error("failed to detect storage version. Please make sure you are using data dir from etcd v3.5 and older")
+		c.lg.Error("failed to detect storage version. Please make sure you are using data dir from etcd v3.5 and older")
 		return err
 	}
 	if current == *c.targetVersion {
-		lg.Info("storage version up-to-date", zap.String("storage-version", storageVersionToString(&current)))
+		c.lg.Info("storage version up-to-date", zap.String("storage-version", storageVersionToString(&current)))
 		return nil
 	}
-	err = schema.Migrate(lg, tx, c.walVersion, *c.targetVersion)
+	err = schema.Migrate(c.lg, tx, c.walVersion, *c.targetVersion)
 	if err != nil {
 		if !c.force {
 			return err
 		}
-		lg.Info("normal migrate failed, trying with force", zap.Error(err))
+		c.lg.Info("normal migrate failed, trying with force", zap.Error(err))
-		migrateForce(lg, tx, c.targetVersion)
+		migrateForce(c.lg, tx, c.targetVersion)
 	}
 	c.be.ForceCommit()
 	return nil

etcdutl/snapshot/v3_snapshot.go

@@ -299,7 +299,7 @@ func (s *v3Manager) saveDB() error {
 		return err
 	}
 
-	be := backend.NewDefaultBackend(s.outDbPath())
+	be := backend.NewDefaultBackend(s.lg, s.outDbPath())
 	defer be.Close()
 
 	err = schema.NewMembershipBackend(s.lg, be).TrimMembershipFromBackend()
@@ -397,7 +397,7 @@ func (s *v3Manager) saveWALAndSnap() (*raftpb.HardState, error) {
 	// add members again to persist them to the store we create.
 	st := v2store.New(etcdserver.StoreClusterPrefix, etcdserver.StoreKeysPrefix)
 	s.cl.SetStore(st)
-	be := backend.NewDefaultBackend(s.outDbPath())
+	be := backend.NewDefaultBackend(s.lg, s.outDbPath())
 	defer be.Close()
 	s.cl.SetBackend(schema.NewMembershipBackend(s.lg, be))
 	for _, m := range s.cl.Members() {
@@ -480,7 +480,7 @@ func (s *v3Manager) saveWALAndSnap() (*raftpb.HardState, error) {
 }
 
 func (s *v3Manager) updateCIndex(commit uint64, term uint64) error {
-	be := backend.NewDefaultBackend(s.outDbPath())
+	be := backend.NewDefaultBackend(s.lg, s.outDbPath())
 	defer be.Close()
 
 	cindex.UpdateConsistentIndex(be.BatchTx(), commit, term, false)

server/etcdserver/cindex/cindex_test.go

@@ -23,6 +23,7 @@ import (
 	"go.etcd.io/etcd/server/v3/storage/backend"
 	betesting "go.etcd.io/etcd/server/v3/storage/backend/testing"
 	"go.etcd.io/etcd/server/v3/storage/schema"
+	"go.uber.org/zap/zaptest"
 )
 
 // TestConsistentIndex ensures that LoadConsistentIndex/Save/ConsistentIndex and backend.BatchTx can work well together.
@@ -53,7 +54,7 @@ func TestConsistentIndex(t *testing.T) {
 	be.ForceCommit()
 	be.Close()
 
-	b := backend.NewDefaultBackend(tmpPath)
+	b := backend.NewDefaultBackend(zaptest.NewLogger(t), tmpPath)
 	defer b.Close()
 	ci.SetBackend(b)
 	index = ci.ConsistentIndex()

server/lease/lessor_test.go

@@ -31,6 +31,7 @@ import (
 	"go.etcd.io/etcd/server/v3/storage/backend"
 	"go.etcd.io/etcd/server/v3/storage/schema"
 	"go.uber.org/zap"
+	"go.uber.org/zap/zaptest"
 )
 
 const (
@@ -310,7 +311,7 @@ func TestLessorRenewExtendPileup(t *testing.T) {
 	// simulate stop and recovery
 	le.Stop()
 	be.Close()
-	bcfg := backend.DefaultBackendConfig()
+	bcfg := backend.DefaultBackendConfig(lg)
 	bcfg.Path = filepath.Join(dir, "be")
 	be = backend.New(bcfg)
 	defer be.Close()
@@ -669,8 +670,9 @@ func (fd *fakeDeleter) DeleteRange(key, end []byte) (int64, int64) {
 }
 
 func NewTestBackend(t *testing.T) (string, backend.Backend) {
+	lg := zaptest.NewLogger(t)
 	tmpPath := t.TempDir()
-	bcfg := backend.DefaultBackendConfig()
+	bcfg := backend.DefaultBackendConfig(lg)
 	bcfg.Path = filepath.Join(tmpPath, "be")
 	return tmpPath, backend.New(bcfg)
 }

server/storage/backend.go

@@ -29,7 +29,7 @@ import (
 )
 
 func newBackend(cfg config.ServerConfig, hooks backend.Hooks) backend.Backend {
-	bcfg := backend.DefaultBackendConfig()
+	bcfg := backend.DefaultBackendConfig(cfg.Logger)
 	bcfg.Path = cfg.BackendPath()
 	bcfg.UnsafeNoFsync = cfg.UnsafeNoFsync
 	if cfg.BackendBatchLimit != 0 {

server/storage/backend/backend.go

@@ -144,11 +144,12 @@ type BackendConfig struct {
 	Hooks Hooks
 }
 
-func DefaultBackendConfig() BackendConfig {
+func DefaultBackendConfig(lg *zap.Logger) BackendConfig {
 	return BackendConfig{
 		BatchInterval: defaultBatchInterval,
 		BatchLimit:    defaultBatchLimit,
 		MmapSize:      initialMmapSize,
+		Logger:        lg,
 	}
 }
 
@@ -156,17 +157,13 @@ func New(bcfg BackendConfig) Backend {
 	return newBackend(bcfg)
 }
 
-func NewDefaultBackend(path string) Backend {
+func NewDefaultBackend(lg *zap.Logger, path string) Backend {
-	bcfg := DefaultBackendConfig()
+	bcfg := DefaultBackendConfig(lg)
 	bcfg.Path = path
 	return newBackend(bcfg)
 }
 
 func newBackend(bcfg BackendConfig) *backend {
-	if bcfg.Logger == nil {
-		bcfg.Logger = zap.NewNop()
-	}
-
 	bopts := &bolt.Options{}
 	if boltOpenOptions != nil {
 		*bopts = *boltOpenOptions

server/storage/backend/backend_test.go

@@ -26,6 +26,7 @@ import (
 	"go.etcd.io/etcd/server/v3/storage/backend"
 	betesting "go.etcd.io/etcd/server/v3/storage/backend/testing"
 	"go.etcd.io/etcd/server/v3/storage/schema"
+	"go.uber.org/zap/zaptest"
 )
 
 func TestBackendClose(t *testing.T) {
@@ -71,7 +72,7 @@ func TestBackendSnapshot(t *testing.T) {
 	assert.NoError(t, f.Close())
 
 	// bootstrap new backend from the snapshot
-	bcfg := backend.DefaultBackendConfig()
+	bcfg := backend.DefaultBackendConfig(zaptest.NewLogger(t))
 	bcfg.Path, bcfg.BatchInterval, bcfg.BatchLimit = f.Name(), time.Hour, 10000
 	nb := backend.New(bcfg)
 	defer betesting.Close(t, nb)
@@ -122,7 +123,7 @@ func TestBackendBatchIntervalCommit(t *testing.T) {
 }
 
 func TestBackendDefrag(t *testing.T) {
-	bcfg := backend.DefaultBackendConfig()
+	bcfg := backend.DefaultBackendConfig(zaptest.NewLogger(t))
 	// Make sure we change BackendFreelistType
 	// The goal is to verify that we restore config option after defrag.
 	if bcfg.BackendFreelistType == bolt.FreelistMapType {

server/storage/backend/hooks_test.go

@@ -23,6 +23,7 @@ import (
 	"go.etcd.io/etcd/server/v3/storage/backend"
 	betesting "go.etcd.io/etcd/server/v3/storage/backend/testing"
 	"go.etcd.io/etcd/server/v3/storage/schema"
+	"go.uber.org/zap/zaptest"
 )
 
 var (
@@ -31,7 +32,7 @@ var (
 )
 
 func TestBackendPreCommitHook(t *testing.T) {
-	be := newTestHooksBackend(t, backend.DefaultBackendConfig())
+	be := newTestHooksBackend(t, backend.DefaultBackendConfig(zaptest.NewLogger(t)))
 
 	tx := be.BatchTx()
 	prepareBuckenAndKey(tx)
@@ -48,7 +49,7 @@ func TestBackendPreCommitHook(t *testing.T) {
 }
 
 func TestBackendAutoCommitLimitHook(t *testing.T) {
-	cfg := backend.DefaultBackendConfig()
+	cfg := backend.DefaultBackendConfig(zaptest.NewLogger(t))
 	cfg.BatchLimit = 3
 	be := newTestHooksBackend(t, cfg)
 
@@ -72,7 +73,7 @@ func TestBackendAutoCommitBatchIntervalHook(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
 	defer cancel()
 
-	cfg := backend.DefaultBackendConfig()
+	cfg := backend.DefaultBackendConfig(zaptest.NewLogger(t))
 	cfg.BatchInterval = 10 * time.Millisecond
 	be := newTestHooksBackend(t, cfg)
 	tx := be.BatchTx()

server/storage/backend/testing/betesting.go

@@ -38,13 +38,13 @@ func NewTmpBackendFromCfg(t testing.TB, bcfg backend.BackendConfig) (backend.Bac
 
 // NewTmpBackend creates a backend implementation for testing.
 func NewTmpBackend(t testing.TB, batchInterval time.Duration, batchLimit int) (backend.Backend, string) {
-	bcfg := backend.DefaultBackendConfig()
+	bcfg := backend.DefaultBackendConfig(zaptest.NewLogger(t))
 	bcfg.BatchInterval, bcfg.BatchLimit = batchInterval, batchLimit
 	return NewTmpBackendFromCfg(t, bcfg)
 }
 
 func NewDefaultTmpBackend(t testing.TB) (backend.Backend, string) {
-	return NewTmpBackendFromCfg(t, backend.DefaultBackendConfig())
+	return NewTmpBackendFromCfg(t, backend.DefaultBackendConfig(zaptest.NewLogger(t)))
 }
 
 func Close(t testing.TB, b backend.Backend) {

server/storage/mvcc/store_test.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"go.uber.org/zap/zaptest"
 
 	"go.etcd.io/etcd/server/v3/storage/backend"
 	betesting "go.etcd.io/etcd/server/v3/storage/backend/testing"
@@ -33,6 +34,7 @@ func TestScheduledCompact(t *testing.T) {
 	}
 	for _, tc := range tcs {
 		t.Run(fmt.Sprint(tc.value), func(t *testing.T) {
+			lg := zaptest.NewLogger(t)
 			be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10)
 			tx := be.BatchTx()
 			if tx == nil {
@@ -45,7 +47,7 @@ func TestScheduledCompact(t *testing.T) {
 			be.ForceCommit()
 			be.Close()
 
-			b := backend.NewDefaultBackend(tmpPath)
+			b := backend.NewDefaultBackend(lg, tmpPath)
 			defer b.Close()
 			v, found := UnsafeReadScheduledCompact(b.BatchTx())
 			assert.Equal(t, true, found)
@@ -74,6 +76,7 @@ func TestFinishedCompact(t *testing.T) {
 	}
 	for _, tc := range tcs {
 		t.Run(fmt.Sprint(tc.value), func(t *testing.T) {
+			lg := zaptest.NewLogger(t)
 			be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10)
 			tx := be.BatchTx()
 			if tx == nil {
@@ -86,7 +89,7 @@ func TestFinishedCompact(t *testing.T) {
 			be.ForceCommit()
 			be.Close()
 
-			b := backend.NewDefaultBackend(tmpPath)
+			b := backend.NewDefaultBackend(lg, tmpPath)
 			defer b.Close()
 			v, found := UnsafeReadFinishedCompact(b.BatchTx())
 			assert.Equal(t, true, found)

server/storage/schema/auth_roles_test.go

@@ -109,8 +109,9 @@ func TestGetAllRoles(t *testing.T) {
 	}
 	for _, tc := range tcs {
 		t.Run(tc.name, func(t *testing.T) {
+			lg := zaptest.NewLogger(t)
 			be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10)
-			abe := NewAuthBackend(zaptest.NewLogger(t), be)
+			abe := NewAuthBackend(lg, be)
 			abe.CreateAuthBuckets()
 
 			tx := abe.BatchTx()
@@ -121,9 +122,9 @@ func TestGetAllRoles(t *testing.T) {
 			abe.ForceCommit()
 			be.Close()
 
-			be2 := backend.NewDefaultBackend(tmpPath)
+			be2 := backend.NewDefaultBackend(lg, tmpPath)
 			defer be2.Close()
-			abe2 := NewAuthBackend(zaptest.NewLogger(t), be2)
+			abe2 := NewAuthBackend(lg, be2)
 			users := abe2.GetAllRoles()
 
 			assert.Equal(t, tc.want, users)
@@ -205,8 +206,9 @@ func TestGetRole(t *testing.T) {
 	}
 	for _, tc := range tcs {
 		t.Run(tc.name, func(t *testing.T) {
+			lg := zaptest.NewLogger(t)
 			be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10)
-			abe := NewAuthBackend(zaptest.NewLogger(t), be)
+			abe := NewAuthBackend(lg, be)
 			abe.CreateAuthBuckets()
 
 			tx := abe.BatchTx()
@@ -217,9 +219,9 @@ func TestGetRole(t *testing.T) {
 			abe.ForceCommit()
 			be.Close()
 
-			be2 := backend.NewDefaultBackend(tmpPath)
+			be2 := backend.NewDefaultBackend(lg, tmpPath)
 			defer be2.Close()
-			abe2 := NewAuthBackend(zaptest.NewLogger(t), be2)
+			abe2 := NewAuthBackend(lg, be2)
 			users := abe2.GetRole("role1")
 
 			assert.Equal(t, tc.want, users)

server/storage/schema/auth_test.go

@@ -52,8 +52,9 @@ func TestAuthEnabled(t *testing.T) {
 	}
 	for _, tc := range tcs {
 		t.Run(tc.name, func(t *testing.T) {
+			lg := zaptest.NewLogger(t)
 			be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10)
-			abe := NewAuthBackend(zaptest.NewLogger(t), be)
+			abe := NewAuthBackend(lg, be)
 			tx := abe.BatchTx()
 			abe.CreateAuthBuckets()
 
@@ -65,9 +66,9 @@ func TestAuthEnabled(t *testing.T) {
 			abe.ForceCommit()
 			be.Close()
 
-			be2 := backend.NewDefaultBackend(tmpPath)
+			be2 := backend.NewDefaultBackend(lg, tmpPath)
 			defer be2.Close()
-			abe2 := NewAuthBackend(zaptest.NewLogger(t), be2)
+			abe2 := NewAuthBackend(lg, be2)
 			tx = abe2.BatchTx()
 			tx.Lock()
 			defer tx.Unlock()
@@ -102,8 +103,9 @@ func TestAuthRevision(t *testing.T) {
 	}
 	for _, tc := range tcs {
 		t.Run(tc.name, func(t *testing.T) {
+			lg := zaptest.NewLogger(t)
 			be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10)
-			abe := NewAuthBackend(zaptest.NewLogger(t), be)
+			abe := NewAuthBackend(lg, be)
 			abe.CreateAuthBuckets()
 
 			if tc.setRevision != 0 {
@@ -115,9 +117,9 @@ func TestAuthRevision(t *testing.T) {
 			abe.ForceCommit()
 			be.Close()
 
-			be2 := backend.NewDefaultBackend(tmpPath)
+			be2 := backend.NewDefaultBackend(lg, tmpPath)
 			defer be2.Close()
-			abe2 := NewAuthBackend(zaptest.NewLogger(t), be2)
+			abe2 := NewAuthBackend(lg, be2)
 			tx := abe2.BatchTx()
 			tx.Lock()
 			defer tx.Unlock()

server/storage/schema/auth_users_test.go

@@ -97,8 +97,9 @@ func TestGetAllUsers(t *testing.T) {
 	}
 	for _, tc := range tcs {
 		t.Run(tc.name, func(t *testing.T) {
+			lg := zaptest.NewLogger(t)
 			be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10)
-			abe := NewAuthBackend(zaptest.NewLogger(t), be)
+			abe := NewAuthBackend(lg, be)
 			abe.CreateAuthBuckets()
 
 			tx := abe.BatchTx()
@@ -109,9 +110,9 @@ func TestGetAllUsers(t *testing.T) {
 			abe.ForceCommit()
 			be.Close()
 
-			be2 := backend.NewDefaultBackend(tmpPath)
+			be2 := backend.NewDefaultBackend(lg, tmpPath)
 			defer be2.Close()
-			abe2 := NewAuthBackend(zaptest.NewLogger(t), be2)
+			abe2 := NewAuthBackend(lg, be2)
 			users := abe2.GetAllUsers()
 
 			assert.Equal(t, tc.want, users)
@@ -181,8 +182,9 @@ func TestGetUser(t *testing.T) {
 	}
 	for _, tc := range tcs {
 		t.Run(tc.name, func(t *testing.T) {
+			lg := zaptest.NewLogger(t)
 			be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10)
-			abe := NewAuthBackend(zaptest.NewLogger(t), be)
+			abe := NewAuthBackend(lg, be)
 			abe.CreateAuthBuckets()
 
 			tx := abe.BatchTx()
@@ -193,9 +195,9 @@ func TestGetUser(t *testing.T) {
 			abe.ForceCommit()
 			be.Close()
 
-			be2 := backend.NewDefaultBackend(tmpPath)
+			be2 := backend.NewDefaultBackend(lg, tmpPath)
 			defer be2.Close()
-			abe2 := NewAuthBackend(zaptest.NewLogger(t), be2)
+			abe2 := NewAuthBackend(lg, be2)
 			users := abe2.GetUser("alice")
 
 			assert.Equal(t, tc.want, users)

server/storage/schema/lease_test.go

@@ -23,6 +23,7 @@ import (
 	"go.etcd.io/etcd/server/v3/lease/leasepb"
 	"go.etcd.io/etcd/server/v3/storage/backend"
 	betesting "go.etcd.io/etcd/server/v3/storage/backend/testing"
+	"go.uber.org/zap/zaptest"
 )
 
 func TestLeaseBackend(t *testing.T) {
@@ -86,6 +87,7 @@ func TestLeaseBackend(t *testing.T) {
 
 	for _, tc := range tcs {
 		t.Run(tc.name, func(t *testing.T) {
+			lg := zaptest.NewLogger(t)
 			be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10)
 			tx := be.BatchTx()
 			tx.Lock()
@@ -96,7 +98,7 @@ func TestLeaseBackend(t *testing.T) {
 			be.ForceCommit()
 			be.Close()
 
-			be2 := backend.NewDefaultBackend(tmpPath)
+			be2 := backend.NewDefaultBackend(lg, tmpPath)
 			defer be2.Close()
 			leases := MustUnsafeGetAllLeases(be2.ReadTx())
 

server/storage/schema/schema_test.go

@@ -86,7 +86,7 @@ func TestValidate(t *testing.T) {
 			lg := zap.NewNop()
 			dataPath := setupBackendData(t, tc.version, tc.overrideKeys)
 
-			b := backend.NewDefaultBackend(dataPath)
+			b := backend.NewDefaultBackend(lg, dataPath)
 			defer b.Close()
 			err := Validate(lg, b.BatchTx())
 			if (err != nil) != tc.expectError {
@@ -214,7 +214,7 @@ func TestMigrate(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			b := backend.NewDefaultBackend(dataPath)
+			b := backend.NewDefaultBackend(lg, dataPath)
 			defer b.Close()
 
 			err = Migrate(lg, b.BatchTx(), walVersion, tc.targetVersion)
@@ -258,7 +258,7 @@ func TestMigrateIsReversible(t *testing.T) {
 			lg := zap.NewNop()
 			dataPath := setupBackendData(t, tc.initialVersion, nil)
 
-			be := backend.NewDefaultBackend(dataPath)
+			be := backend.NewDefaultBackend(lg, dataPath)
 			defer be.Close()
 			tx := be.BatchTx()
 			tx.Lock()

server/storage/schema/version_test.go

@@ -21,6 +21,7 @@ import (
 	"github.com/coreos/go-semver/semver"
 	"github.com/stretchr/testify/assert"
 	"go.etcd.io/bbolt"
+	"go.uber.org/zap/zaptest"
 
 	"go.etcd.io/etcd/server/v3/storage/backend"
 	"go.etcd.io/etcd/server/v3/storage/backend/testing"
@@ -55,6 +56,7 @@ func TestVersion(t *testing.T) {
 	}
 	for _, tc := range tcs {
 		t.Run(tc.version, func(t *testing.T) {
+			lg := zaptest.NewLogger(t)
 			be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10)
 			tx := be.BatchTx()
 			if tx == nil {
@@ -67,7 +69,7 @@ func TestVersion(t *testing.T) {
 			be.ForceCommit()
 			be.Close()
 
-			b := backend.NewDefaultBackend(tmpPath)
+			b := backend.NewDefaultBackend(lg, tmpPath)
 			defer b.Close()
 			v := UnsafeReadStorageVersion(b.BatchTx())
 

server/verify/verify.go

@@ -69,7 +69,7 @@ func Verify(cfg Config) error {
 		}
 	}()
 
-	beConfig := backend.DefaultBackendConfig()
+	beConfig := backend.DefaultBackendConfig(lg)
 	beConfig.Path = datadir.ToBackendFileName(cfg.DataDir)
 	beConfig.Logger = cfg.Logger
 

tests/e2e/utl_migrate_test.go

@@ -26,6 +26,7 @@ import (
 	"go.etcd.io/etcd/server/v3/storage/backend"
 	"go.etcd.io/etcd/server/v3/storage/schema"
 	"go.etcd.io/etcd/tests/v3/framework/e2e"
+	"go.uber.org/zap/zaptest"
 )
 
 func TestEtctlutlMigrate(t *testing.T) {
@@ -105,6 +106,7 @@ func TestEtctlutlMigrate(t *testing.T) {
 	for _, tc := range tcs {
 		t.Run(tc.name, func(t *testing.T) {
 			e2e.BeforeTest(t)
+			lg := zaptest.NewLogger(t)
 			if tc.binary != "" && !fileutil.Exist(tc.binary) {
 				t.Skipf("%q does not exist", lastReleaseBinary)
 			}
@@ -154,7 +156,7 @@ func TestEtctlutlMigrate(t *testing.T) {
 			}
 
 			t.Log("etcdutl migrate...")
-			be := backend.NewDefaultBackend(dataDirPath + "/member/snap/db")
+			be := backend.NewDefaultBackend(lg, dataDirPath+"/member/snap/db")
 			defer be.Close()
 
 			ver := schema.ReadStorageVersion(be.ReadTx())

tests/integration/clientv3/maintenance_test.go

@@ -190,6 +190,7 @@ func TestMaintenanceSnapshotErrorInflight(t *testing.T) {
 // will fail to read with corresponding context errors on inflight context cancel timeout.
 func testMaintenanceSnapshotErrorInflight(t *testing.T, snapshot func(context.Context, *clientv3.Client) (io.ReadCloser, error)) {
 	integration2.BeforeTest(t)
+	lg := zaptest.NewLogger(t)
 
 	clus := integration2.NewCluster(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
 	defer clus.Terminate(t)
@@ -197,8 +198,8 @@ func testMaintenanceSnapshotErrorInflight(t *testing.T, snapshot func(context.Co
 	// take about 1-second to read snapshot
 	clus.Members[0].Stop(t)
 	dpath := filepath.Join(clus.Members[0].DataDir, "member", "snap", "db")
-	b := backend.NewDefaultBackend(dpath)
+	b := backend.NewDefaultBackend(lg, dpath)
-	s := mvcc.NewStore(zaptest.NewLogger(t), b, &lease.FakeLessor{}, mvcc.StoreConfig{CompactionBatchLimit: math.MaxInt32})
+	s := mvcc.NewStore(lg, b, &lease.FakeLessor{}, mvcc.StoreConfig{CompactionBatchLimit: math.MaxInt32})
 	rev := 100000
 	for i := 2; i <= rev; i++ {
 		s.Put([]byte(fmt.Sprintf("%10d", i)), bytes.Repeat([]byte("a"), 1024), lease.NoLease)

tests/integration/v3_alarm_test.go

@@ -174,6 +174,7 @@ func TestV3AlarmDeactivate(t *testing.T) {
 
 func TestV3CorruptAlarm(t *testing.T) {
 	integration.BeforeTest(t)
+	lg := zaptest.NewLogger(t)
 	clus := integration.NewCluster(t, &integration.ClusterConfig{Size: 3, UseBridge: true})
 	defer clus.Terminate(t)
 
@@ -192,8 +193,8 @@ func TestV3CorruptAlarm(t *testing.T) {
 	// Corrupt member 0 by modifying backend offline.
 	clus.Members[0].Stop(t)
 	fp := filepath.Join(clus.Members[0].DataDir, "member", "snap", "db")
-	be := backend.NewDefaultBackend(fp)
+	be := backend.NewDefaultBackend(lg, fp)
-	s := mvcc.NewStore(zaptest.NewLogger(t), be, nil, mvcc.StoreConfig{})
+	s := mvcc.NewStore(lg, be, nil, mvcc.StoreConfig{})
 	// NOTE: cluster_proxy mode with namespacing won't set 'k', but namespace/'k'.
 	s.Put([]byte("abc"), []byte("def"), 0)
 	s.Put([]byte("xyz"), []byte("123"), 0)
@@ -258,6 +259,7 @@ func TestV3CorruptAlarm(t *testing.T) {
 
 func TestV3CorruptAlarmWithLeaseCorrupted(t *testing.T) {
 	integration.BeforeTest(t)
+	lg := zaptest.NewLogger(t)
 	clus := integration.NewCluster(t, &integration.ClusterConfig{
 		CorruptCheckTime:       time.Second,
 		Size:                   3,
@@ -299,9 +301,8 @@ func TestV3CorruptAlarmWithLeaseCorrupted(t *testing.T) {
 	// Corrupt member 2 by modifying backend lease bucket offline.
 	clus.Members[2].Stop(t)
 	fp := filepath.Join(clus.Members[2].DataDir, "member", "snap", "db")
-	bcfg := backend.DefaultBackendConfig()
+	bcfg := backend.DefaultBackendConfig(lg)
 	bcfg.Path = fp
-	bcfg.Logger = zaptest.NewLogger(t)
 	be := backend.New(bcfg)
 
 	olpb := leasepb.Lease{ID: int64(1), TTL: 60}

tools/benchmark/cmd/mvcc.go

@@ -35,7 +35,7 @@ var (
 )
 
 func initMVCC() {
-	bcfg := backend.DefaultBackendConfig()
+	bcfg := backend.DefaultBackendConfig(zap.NewNop())
 	bcfg.Path, bcfg.BatchInterval, bcfg.BatchLimit = "mvcc-bench", time.Duration(batchInterval)*time.Millisecond, batchLimit
 	be := backend.New(bcfg)
 	s = mvcc.NewStore(zap.NewExample(), be, &lease.FakeLessor{}, mvcc.StoreConfig{})

tools/etcd-dump-db/backend.go

@@ -21,6 +21,7 @@ import (
 
 	"go.etcd.io/etcd/api/v3/authpb"
 	"go.etcd.io/etcd/server/v3/storage/schema"
+	"go.uber.org/zap"
 
 	"go.etcd.io/etcd/api/v3/mvccpb"
 	"go.etcd.io/etcd/server/v3/lease/leasepb"
@@ -176,7 +177,7 @@ func iterateBucket(dbPath, bucket string, limit uint64, decode bool) (err error)
 }
 
 func getHash(dbPath string) (hash uint32, err error) {
-	b := backend.NewDefaultBackend(dbPath)
+	b := backend.NewDefaultBackend(zap.NewNop(), dbPath)
 	return b.Hash(schema.DefaultIgnores)
 }