Merge pull request #13886 from serathius/backend-logger

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))
-		migrateForce(lg, tx, c.targetVersion)
+		c.lg.Info("normal migrate failed, trying with force", zap.Error(err))
+		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,29 +144,26 @@ type BackendConfig struct {
 	Hooks Hooks
 }
 
-func DefaultBackendConfig() BackendConfig {
+func DefaultBackendConfig(lg *zap.Logger) BackendConfig {
 	return BackendConfig{
 		BatchInterval: defaultBatchInterval,
 		BatchLimit:    defaultBatchLimit,
 		MmapSize:      initialMmapSize,
+		Logger:        lg,
 	}
 }
 
 func New(bcfg BackendConfig) Backend {
 	return newBackend(bcfg)
 }
 
-func NewDefaultBackend(path string) Backend {
-	bcfg := DefaultBackendConfig()
+func NewDefaultBackend(lg *zap.Logger, path string) Backend {
+	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)