Migrate logging to uber-go/zap

Author: Manav-Aggarwal

block/aggregation.go

@@ -4,14 +4,16 @@ import (
 	"context"
 	"fmt"
 	"time"
+
+	"go.uber.org/zap"
 )
 
 // AggregationLoop is responsible for aggregating transactions into blocks.
 func (m *Manager) AggregationLoop(ctx context.Context, errCh chan<- error) {
 	initialHeight := m.genesis.InitialHeight //nolint:gosec
 	height, err := m.store.Height(ctx)
 	if err != nil {
-		m.logger.Error("error while getting store height", "error", err)
+		m.logger.Error("error while getting store height", zap.Error(err))
 		return
 	}
 	var delay time.Duration
@@ -24,7 +26,7 @@ func (m *Manager) AggregationLoop(ctx context.Context, errCh chan<- error) {
 	}
 
 	if delay > 0 {
-		m.logger.Info("waiting to produce block, delay:", delay)
+		m.logger.Info("waiting to produce block", zap.Duration("delay", delay))
 		time.Sleep(delay)
 	}
 
@@ -74,7 +76,7 @@ func (m *Manager) lazyAggregationLoop(ctx context.Context, blockTimer *time.Time
 				m.txsAvailable = false
 			} else {
 				// Ensure we keep ticking even when there are no txs
-				blockTimer.Reset(m.config.Node.BlockTime.Duration)
+				blockTimer.Reset(getRemainingSleep(time.Now(), m.config.Node.BlockTime.Duration))
 			}
 		case <-m.txNotifyCh:
 			m.txsAvailable = true
@@ -91,7 +93,7 @@ func (m *Manager) produceBlock(ctx context.Context, mode string, lazyTimer, bloc
 		return fmt.Errorf("error while publishing block: %w", err)
 	}
 
-	m.logger.Debug("Successfully published block", "mode", mode)
+	m.logger.Debug("Successfully published block", zap.String("mode", mode))
 
 	// Reset both timers for the next aggregation window
 	lazyTimer.Reset(getRemainingSleep(start, m.config.Node.LazyBlockInterval.Duration))

block/aggregation_test.go

@@ -8,10 +8,10 @@ import (
 	"testing"
 	"time"
 
-	logging "github.com/ipfs/go-log/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
 
 	"github.com/evstack/ev-node/pkg/cache"
 	"github.com/evstack/ev-node/pkg/config"
@@ -36,7 +36,7 @@ func TestAggregationLoop_Normal_BasicInterval(t *testing.T) {
 	mockExec := mocks.NewMockExecutor(t)
 	mockSeq := mocks.NewMockSequencer(t)
 	mockDAC := mocks.NewMockDA(t)
-	logger := logging.Logger("test")
+	logger := zap.NewNop()
 
 	m := &Manager{
 		store:     mockStore,
@@ -71,7 +71,7 @@ func TestAggregationLoop_Normal_BasicInterval(t *testing.T) {
 		publishLock.Lock()
 		defer publishLock.Unlock()
 		publishTimes = append(publishTimes, time.Now())
-		m.logger.Debug("Mock publishBlock called", "time", publishTimes[len(publishTimes)-1])
+		logger.Debug("Mock publishBlock called", zap.Time("time", publishTimes[len(publishTimes)-1]))
 		return nil
 	}
 	m.publishBlock = mockPublishBlock
@@ -83,22 +83,22 @@ func TestAggregationLoop_Normal_BasicInterval(t *testing.T) {
 	go func() {
 		defer wg.Done()
 		m.AggregationLoop(ctx, make(chan<- error))
-		m.logger.Info("AggregationLoop exited")
+		logger.Info("AggregationLoop exited")
 	}()
 
-	m.logger.Info("Waiting for blocks..., duration:", waitTime)
+	logger.Info("Waiting for blocks...", zap.Duration("duration", waitTime))
 	time.Sleep(waitTime)
 
-	m.logger.Info("Cancelling context")
+	logger.Info("Cancelling context")
 	cancel()
-	m.logger.Info("Waiting for WaitGroup")
+	logger.Info("Waiting for WaitGroup")
 	wg.Wait()
-	m.logger.Info("WaitGroup finished")
+	logger.Info("WaitGroup finished")
 
 	publishLock.Lock()
 	defer publishLock.Unlock()
 
-	m.logger.Info("Recorded publish times, count:", len(publishTimes), "times:", publishTimes)
+	logger.Info("Recorded publish times", zap.Int("count", len(publishTimes)), zap.Any("times", publishTimes))
 
 	expectedCallsLow := int(waitTime/blockTime) - 1
 	expectedCallsHigh := int(waitTime/blockTime) + 1
@@ -108,7 +108,7 @@ func TestAggregationLoop_Normal_BasicInterval(t *testing.T) {
 	if len(publishTimes) > 1 {
 		for i := 1; i < len(publishTimes); i++ {
 			interval := publishTimes[i].Sub(publishTimes[i-1])
-			m.logger.Debug("Checking interval", "index", i, "interval", interval)
+			logger.Debug("Checking interval", zap.Int("index", i), zap.Duration("interval", interval))
 			tolerance := blockTime / 2
 			assert.True(WithinDuration(t, blockTime, interval, tolerance), "Interval %d (%v) not within tolerance (%v) of blockTime (%v)", i, interval, tolerance, blockTime)
 		}
@@ -131,7 +131,7 @@ func TestAggregationLoop_Normal_PublishBlockError(t *testing.T) {
 	mockSeq := mocks.NewMockSequencer(t)
 	mockDAC := mocks.NewMockDA(t)
 
-	logger := logging.Logger("test")
+	logger := zap.NewNop()
 
 	// Create a basic Manager instance
 	m := &Manager{
@@ -173,10 +173,10 @@ func TestAggregationLoop_Normal_PublishBlockError(t *testing.T) {
 		publishLock.Unlock()
 
 		if callNum == 1 {
-			m.logger.Debug("Mock publishBlock returning error", "call", callNum)
+			logger.Debug("Mock publishBlock returning error", zap.Int64("call", callNum))
 			return expectedErr
 		}
-		m.logger.Debug("Mock publishBlock returning nil", "call", callNum)
+		logger.Debug("Mock publishBlock returning nil", zap.Int64("call", callNum))
 		return nil
 	}
 	m.publishBlock = mockPublishBlock
@@ -189,7 +189,7 @@ func TestAggregationLoop_Normal_PublishBlockError(t *testing.T) {
 	go func() {
 		defer wg.Done()
 		m.AggregationLoop(ctx, errCh)
-		m.logger.Info("AggregationLoop exited")
+		logger.Info("AggregationLoop exited")
 	}()
 
 	time.Sleep(waitTime)

block/da_includer.go

@@ -5,6 +5,8 @@ import (
 	"encoding/binary"
 	"fmt"
 
+	"go.uber.org/zap"
+
 	coreda "github.com/evstack/ev-node/core/da"
 	storepkg "github.com/evstack/ev-node/pkg/store"
 )
@@ -25,11 +27,11 @@ func (m *Manager) DAIncluderLoop(ctx context.Context, errCh chan<- error) {
 			daIncluded, err := m.IsDAIncluded(ctx, nextHeight)
 			if err != nil {
 				// No more blocks to check at this time
-				m.logger.Debug("no more blocks to check at this time, height: ", nextHeight, "error: ", err)
+				m.logger.Debug("no more blocks to check at this time", zap.Uint64("height", nextHeight), zap.Error(err))
 				break
 			}
 			if daIncluded {
-				m.logger.Debug("both header and data are DA-included, advancing height: ", nextHeight)
+				m.logger.Debug("both header and data are DA-included, advancing height", zap.Uint64("height", nextHeight))
 				if err := m.SetRollkitHeightToDAHeight(ctx, nextHeight); err != nil {
 					errCh <- fmt.Errorf("failed to set rollkit height to DA height: %w", err)
 					return
@@ -54,18 +56,18 @@ func (m *Manager) DAIncluderLoop(ctx context.Context, errCh chan<- error) {
 func (m *Manager) incrementDAIncludedHeight(ctx context.Context) error {
 	currentHeight := m.GetDAIncludedHeight()
 	newHeight := currentHeight + 1
-	m.logger.Debug("setting final height: ", newHeight)
+	m.logger.Debug("setting final height", zap.Uint64("height", newHeight))
 	err := m.exec.SetFinal(ctx, newHeight)
 	if err != nil {
-		m.logger.Error("failed to set final height: ", newHeight, "error: ", err)
+		m.logger.Error("failed to set final height", zap.Uint64("height", newHeight), zap.Error(err))
 		return err
 	}
 	heightBytes := make([]byte, 8)
 	binary.LittleEndian.PutUint64(heightBytes, newHeight)
-	m.logger.Debug("setting DA included height: ", newHeight)
+	m.logger.Debug("setting DA included height", zap.Uint64("height", newHeight))
 	err = m.store.SetMetadata(ctx, storepkg.DAIncludedHeightKey, heightBytes)
 	if err != nil {
-		m.logger.Error("failed to set DA included height: ", newHeight, "error: ", err)
+		m.logger.Error("failed to set DA included height", zap.Uint64("height", newHeight), zap.Error(err))
 		return err
 	}
 	if !m.daIncludedHeight.CompareAndSwap(currentHeight, newHeight) {

block/da_includer_test.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"go.uber.org/zap"
 
 	coreda "github.com/evstack/ev-node/core/da"
 	"github.com/evstack/ev-node/core/sequencer"
@@ -20,24 +21,10 @@ import (
 )
 
 // newTestManager creates a Manager with mocked Store and Executor for testing DAIncluder logic.
-func newTestManager(t *testing.T) (*Manager, *mocks.MockStore, *mocks.MockExecutor, *MockLogger) {
+func newTestManager(t *testing.T) (*Manager, *mocks.MockStore, *mocks.MockExecutor, *zap.Logger) {
 	store := mocks.NewMockStore(t)
 	exec := mocks.NewMockExecutor(t)
-	logger := new(MockLogger)
-
-	// Allow logging calls with message string and optional key-value pairs (up to 2 pairs / 4 args for simplicity)
-	logger.On("Debug", mock.AnythingOfType("string")).Maybe()
-	logger.On("Debug", mock.AnythingOfType("string"), mock.Anything, mock.Anything).Maybe()
-	logger.On("Debug", mock.AnythingOfType("string"), mock.Anything, mock.Anything, mock.Anything, mock.Anything).Maybe()
-	logger.On("Info", mock.AnythingOfType("string")).Maybe()
-	logger.On("Info", mock.AnythingOfType("string"), mock.Anything, mock.Anything).Maybe()
-	logger.On("Info", mock.AnythingOfType("string"), mock.Anything, mock.Anything, mock.Anything, mock.Anything).Maybe()
-	logger.On("Warn", mock.AnythingOfType("string")).Maybe()
-	logger.On("Warn", mock.AnythingOfType("string"), mock.Anything, mock.Anything).Maybe()
-	logger.On("Warn", mock.AnythingOfType("string"), mock.Anything, mock.Anything, mock.Anything, mock.Anything).Maybe()
-	logger.On("Error", mock.AnythingOfType("string")).Maybe()
-	logger.On("Error", mock.AnythingOfType("string"), mock.Anything, mock.Anything).Maybe()
-	logger.On("Error", mock.AnythingOfType("string"), mock.Anything, mock.Anything, mock.Anything, mock.Anything).Maybe()
+	logger := zap.NewNop() // Use no-op logger for tests
 
 	// Mock Height to always return a high value so IsDAIncluded works
 	store.On("Height", mock.Anything).Return(uint64(100), nil).Maybe()
@@ -171,20 +158,17 @@ func TestDAIncluderLoop_StopsWhenDataNotDAIncluded(t *testing.T) {
 // if GetBlockData returns an error for the next block height.
 func TestDAIncluderLoop_StopsOnGetBlockDataError(t *testing.T) {
 	t.Parallel()
-	m, store, _, mockLogger := newTestManager(t)
+	m, store, _, _ := newTestManager(t)
 	startDAIncludedHeight := uint64(4)
 	m.daIncludedHeight.Store(startDAIncludedHeight)
 
 	store.On("GetBlockData", mock.Anything, uint64(5)).Return(nil, nil, assert.AnError).Once()
 
 	// Expect the debug log for no more blocks to check
-	mockLogger.ExpectedCalls = nil // Clear any previous expectations for specific checks
+
 	// Re-establish general Maybe calls after clearing, then specific Once call
-	mockLogger.On("Debug", mock.AnythingOfType("string")).Maybe()
-	mockLogger.On("Debug", mock.AnythingOfType("string"), mock.Anything, mock.Anything).Maybe()
-	mockLogger.On("Debug", mock.AnythingOfType("string"), mock.Anything, mock.Anything, mock.Anything, mock.Anything).Maybe()
+
 	// Add other Maybe calls if Info/Warn/Error might also occur and are not asserted
-	mockLogger.On("Info", mock.AnythingOfType("string")).Maybe()
 
 	ctx, loopCancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
 	defer loopCancel()
@@ -201,7 +185,7 @@ func TestDAIncluderLoop_StopsOnGetBlockDataError(t *testing.T) {
 
 	assert.Equal(t, startDAIncludedHeight, m.GetDAIncludedHeight())
 	store.AssertExpectations(t)
-	mockLogger.AssertExpectations(t)
+
 }
 
 // TestIncrementDAIncludedHeight_Success verifies that incrementDAIncludedHeight increments the height
@@ -229,7 +213,7 @@ func TestIncrementDAIncludedHeight_Success(t *testing.T) {
 // if SetMetadata fails after SetFinal succeeds.
 func TestIncrementDAIncludedHeight_SetMetadataError(t *testing.T) {
 	t.Parallel()
-	m, store, exec, mockLogger := newTestManager(t)
+	m, store, exec, _ := newTestManager(t)
 	startDAIncludedHeight := uint64(4)
 	expectedDAIncludedHeight := startDAIncludedHeight + 1
 	m.daIncludedHeight.Store(startDAIncludedHeight)
@@ -243,14 +227,14 @@ func TestIncrementDAIncludedHeight_SetMetadataError(t *testing.T) {
 	assert.Error(t, err)
 	store.AssertExpectations(t)
 	exec.AssertExpectations(t)
-	mockLogger.AssertExpectations(t)
+
 }
 
 // TestIncrementDAIncludedHeight_SetFinalError verifies that incrementDAIncludedHeight returns an error
 // if SetFinal fails before SetMetadata, and logs the error.
 func TestIncrementDAIncludedHeight_SetFinalError(t *testing.T) {
 	t.Parallel()
-	m, store, exec, mockLogger := newTestManager(t)
+	m, store, exec, _ := newTestManager(t)
 	startDAIncludedHeight := uint64(4)
 	expectedDAIncludedHeight := startDAIncludedHeight + 1
 	m.daIncludedHeight.Store(startDAIncludedHeight)
@@ -263,7 +247,7 @@ func TestIncrementDAIncludedHeight_SetFinalError(t *testing.T) {
 	assert.Error(t, err)
 	exec.AssertExpectations(t)
 	store.AssertExpectations(t)
-	mockLogger.AssertExpectations(t)
+
 }
 
 // TestDAIncluderLoop_MultipleConsecutiveHeightsDAIncluded verifies that DAIncluderLoop advances the height

block/da_speed_test.go

@@ -10,11 +10,11 @@ import (
 
 	goheaderstore "github.com/celestiaorg/go-header/store"
 	ds "github.com/ipfs/go-datastore"
-	logging "github.com/ipfs/go-log/v2"
 	"github.com/libp2p/go-libp2p/core/crypto"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
 	"google.golang.org/protobuf/proto"
 
 	coreda "github.com/evstack/ev-node/core/da"
@@ -92,8 +92,7 @@ func TestDASpeed(t *testing.T) {
 func setupManagerForTest(t *testing.T, initialDAHeight uint64) (*Manager, *rollmocks.MockDA) {
 	mockDAClient := rollmocks.NewMockDA(t)
 	mockStore := rollmocks.NewMockStore(t)
-	logger := logging.Logger("test")
-	_ = logging.SetLogLevel("test", "FATAL")
+	logger := zap.NewNop()
 
 	headerStore, _ := goheaderstore.NewStore[*types.SignedHeader](ds.NewMapDatastore())
 	dataStore, _ := goheaderstore.NewStore[*types.Data](ds.NewMapDatastore())

block/lazy_aggregation_test.go

@@ -7,9 +7,9 @@ import (
 	"testing"
 	"time"
 
-	logging "github.com/ipfs/go-log/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
 
 	"github.com/evstack/ev-node/pkg/config"
 )
@@ -54,7 +54,7 @@ func setupTestManager(t *testing.T, blockTime, lazyTime time.Duration) (*Manager
 	pubMock := &mockPublishBlock{
 		calls: make(chan struct{}, 10), // Buffer to avoid blocking in tests
 	}
-	logger := logging.Logger("test")
+	logger := zap.NewNop() // Use a no-op logger for tests
 	m := &Manager{
 		logger: logger,
 		config: config.Config{