remove extra comments

tac0turtle · Jul 1, 2025 · Jun 30, 2025 · Jun 30, 2025 · Jun 30, 2025 · Jun 30, 2025
commit 9b4de618e8a0034fb81a6e1fd53489e81f636dc8
diff --git a/apps/testapp/cmd/run.go b/apps/testapp/cmd/run.go
@@ -43,7 +43,6 @@ var RunCmd = &cobra.Command{
 		ctx, cancel := context.WithCancel(context.Background())
 		defer cancel()
 
-		// Pass logger to NewClient, assuming it expects logging.EventLogger or compatible interface
 		daJrpc, err := jsonrpc.NewClient(ctx, logger, nodeConfig.DA.Address, nodeConfig.DA.AuthToken, nodeConfig.DA.Namespace)
 		if err != nil {
 			return err

diff --git a/block/submitter_test.go b/block/submitter_test.go
@@ -248,8 +248,8 @@ func runRetryPartialFailuresCase[T any](t *testing.T, tc retryPartialFailuresCas
 	mockStore := mocks.NewMockStore(t)
 	m.store = mockStore
 	m.logger = logging.Logger("test")
-	// No direct TestLogger equivalent for auto-fail, ensure test logic handles errors.
-	_ = logging.SetLogLevel("test", "debug") // Or other appropriate level for test debugging
+
+	_ = logging.SetLogLevel("test", "debug")
 	da := &mocks.MockDA{}
 	m.da = da
 	m.gasPrice = 1.0
@@ -467,8 +467,8 @@ func newPendingHeaders(t *testing.T) *PendingHeaders {
 	kv, err := store.NewDefaultInMemoryKVStore()
 	require.NoError(t, err)
 	logger := logging.Logger("test")
-	// No direct TestLogger equivalent for auto-fail, ensure test logic handles errors.
-	_ = logging.SetLogLevel("test", "debug") // Or other appropriate level for test debugging
+
+	_ = logging.SetLogLevel("test", "debug")
 	pendingHeaders, err := NewPendingHeaders(store.New(kv), logger)
 	require.NoError(t, err)
 	return pendingHeaders
@@ -478,8 +478,7 @@ func newPendingData(t *testing.T) *PendingData {
 	kv, err := store.NewDefaultInMemoryKVStore()
 	require.NoError(t, err)
 	logger := logging.Logger("test")
-	// No direct TestLogger equivalent for auto-fail, ensure test logic handles errors.
-	_ = logging.SetLogLevel("test", "debug") // Or other appropriate level for test debugging
+	_ = logging.SetLogLevel("test", "debug")
 	pendingData, err := NewPendingData(store.New(kv), logger)
 	require.NoError(t, err)
 	return pendingData

diff --git a/block/test_utils.go b/block/test_utils.go
@@ -57,30 +57,10 @@ func (m *MockLogger) Panicf(format string, args ...interface{}) {
 func (m *MockLogger) Warn(args ...interface{})                 { m.Called(args...) }
 func (m *MockLogger) Warnf(format string, args ...interface{}) { m.Called(format, args) }
 
-// The With method for ipfs/go-log/v2's ZapEventLogger (which wraps zap.SugaredLogger)
-// returns a new logger with added fields. We can mock this by returning a new MockLogger
-// or the same one if we don't need to track fields specifically in the mock.
-// For simplicity here, it returns itself, but tests might need a more sophisticated mock if With fields are asserted.
 func (m *MockLogger) With(keyvals ...interface{}) *zap.SugaredLogger {
 	args := m.Called(append([]interface{}{"With"}, keyvals...)...)
 	if logger, ok := args.Get(0).(*zap.SugaredLogger); ok {
 		return logger
 	}
-	// Fallback or create a new mock if needed for chaining, though ipfs/go-log's EventLogger doesn't have With.
-	// This part might need adjustment based on how With is used in tests.
-	// Typically, `logging.Logger("subsystem").With(...).Info(...)` would be `logging.Logger("subsystem").Info(..., "key", "value")`
-	// or by using the underlying zap logger if direct field addition is needed.
-	// Since EventLogger doesn't define With, this mock method is more for if the concrete ZapEventLogger is used.
-	// For StandardLogger interface, this method wouldn't be called.
-	// Let's assume for now tests don't rely on a chained With from this mock returning a distinct instance.
-	// Returning m if it were to conform to an interface having `With() SomeLoggerInterface`.
-	// However, ipfs/go-log/v2.EventLogger (StandardLogger) does not have `With`.
-	// The `With` method is on the concrete `ZapEventLogger` type.
-	// If direct calls to `logger.With` are made on a `logging.EventLogger` interface,
-	// it would require a type assertion to `*logging.ZapEventLogger` first.
-	// For a mock of `StandardLogger`, `With` isn't part of the interface.
-	return nil // Or a mock SugaredLogger if tests require it.
+	return nil
 }
-
-// Impl is not part of ipfs/go-log/v2.EventLogger or StandardLogger.
-// func (m *MockLogger) Impl() any                        { return m }
diff --git a/da/cmd/local-da/local.go b/da/cmd/local-da/local.go
@@ -46,13 +46,7 @@ func NewLocalDA(logger logging.EventLogger, opts ...func(*LocalDA) *LocalDA) *Lo
 		data:        make(map[uint64][]kvp),
 		timestamps:  make(map[uint64]time.Time),
 		maxBlobSize: DefaultMaxBlobSize,
-		// ipfs/go-log manages subsystems by logger name.
-		// If the passed-in logger is already for "local-da", this is fine.
-		// If it's a general logger, we'd typically get a new one: logging.Logger("local-da")
-		// Assuming the logger passed in is already appropriately scoped or the caller handles this.
-		// If a specific "local-da" subsystem logger is always desired here,
-		// it should be created using logging.Logger("local-da") instead of using With.
-		logger: logger,
+		logger:      logger,
 	}
 	for _, f := range opts {
 		da = f(da)

diff --git a/da/cmd/local-da/main.go b/da/cmd/local-da/main.go
@@ -36,10 +36,6 @@ func main() {
 	}
 
 	// create logger
-	// With ipfs/go-log, we'd typically set up global config first, then get a named logger.
-	// For a simple main like this, we can directly get a logger.
-	// The ".With("module", "da")" pattern isn't directly used for subsystem creation.
-	// We'll get a logger named "da".
 	logging.SetupLogging(logging.Config{Stderr: true, Level: logging.LevelInfo}) // Basic setup
 	logger := logging.Logger("da")
 

diff --git a/da/jsonrpc/proxy_test.go b/da/jsonrpc/proxy_test.go
@@ -46,8 +46,7 @@ func TestProxy(t *testing.T) {
 	dummy := coreda.NewDummyDA(100_000, 0, 0, getTestDABlockTime())
 	dummy.StartHeightTicker()
 	logger := logging.Logger("test")
-	// No direct TestLogger equivalent for auto-fail, ensure test logic handles errors.
-	_ = logging.SetLogLevel("test", "debug") // Or other appropriate level for test debugging
+	_ = logging.SetLogLevel("test", "debug")
 	server := proxy.NewServer(logger, ServerHost, ServerPort, dummy)
 	err := server.Start(context.Background())
 	require.NoError(t, err)

diff --git a/node/full.go b/node/full.go
@@ -156,7 +156,7 @@ func initHeaderSyncService(
 	p2pClient *p2p.Client,
 	logger logging.EventLogger,
 ) (*rollkitsync.HeaderSyncService, error) {
-	headerSyncService, err := rollkitsync.NewHeaderSyncService(mainKV, nodeConfig, genesis, p2pClient, logging.Logger("HeaderSyncService")) // Get HeaderSyncService's own logger
+	headerSyncService, err := rollkitsync.NewHeaderSyncService(mainKV, nodeConfig, genesis, p2pClient, logging.Logger("HeaderSyncService"))
 	if err != nil {
 		return nil, fmt.Errorf("error while initializing HeaderSyncService: %w", err)
 	}
@@ -170,7 +170,7 @@ func initDataSyncService(
 	p2pClient *p2p.Client,
 	logger logging.EventLogger,
 ) (*rollkitsync.DataSyncService, error) {
-	dataSyncService, err := rollkitsync.NewDataSyncService(mainKV, nodeConfig, genesis, p2pClient, logging.Logger("DataSyncService")) // Get DataSyncService's own logger
+	dataSyncService, err := rollkitsync.NewDataSyncService(mainKV, nodeConfig, genesis, p2pClient, logging.Logger("DataSyncService"))
 	if err != nil {
 		return nil, fmt.Errorf("error while initializing DataSyncService: %w", err)
 	}

diff --git a/node/light.go b/node/light.go
@@ -42,7 +42,7 @@ func newLightNode(
 	database ds.Batching,
 	logger logging.EventLogger,
 ) (ln *LightNode, err error) {
-	headerSyncService, err := sync.NewHeaderSyncService(database, conf, genesis, p2pClient, logging.Logger("HeaderSyncService")) // Get HeaderSyncService's own logger
+	headerSyncService, err := sync.NewHeaderSyncService(database, conf, genesis, p2pClient, logging.Logger("HeaderSyncService"))
 	if err != nil {
 		return nil, fmt.Errorf("error while initializing HeaderSyncService: %w", err)
 	}

diff --git a/pkg/cmd/run_node.go b/pkg/cmd/run_node.go
@@ -66,13 +66,6 @@ func SetupLogger(config rollconf.LogConfig) logging.EventLogger {
 		logCfg.Level = logging.LevelInfo
 	}
 
-	// Configure stack traces
-	// In go-log/v2 (which uses zap), stacktraces are automatically included for Error level and above.
-	// If config.Trace is true, we can enable it for lower levels if needed,
-	// but for now, we'll rely on the default behavior which is generally sufficient.
-	// If more specific control is needed, we might need to use logging.WithStacktrace
-	// after the logger is created.
-
 	logging.SetupLogging(logCfg)
 
 	// Return a logger instance for the "main" subsystem

diff --git a/pkg/cmd/run_node_test.go b/pkg/cmd/run_node_test.go
@@ -412,9 +412,6 @@ func TestStartNodeErrors(t *testing.T) {
 				assert.NotPanics(t, runFunc)
 				// Re-check error after NotPanics confirms no panic occurred
 				// Need to re-run StartNode as the original runFunc only checks error if !tc.expectPanic
-				// The currentTestLogger from the runFunc scope is not accessible here.
-				// We need to create a new one or ensure the previous one is passed.
-				// For simplicity, creating a new one for this re-check.
 				checkLogger := logging.Logger("TestStartNodeErrors-check")
 				_ = logging.SetLogLevel("TestStartNodeErrors-check", "FATAL") // NOP behavior
 				err := StartNode(checkLogger, cmd, executor, sequencer, dac, p2pClient, ds, nodeConfig, nil)

diff --git a/pkg/p2p/client_test.go b/pkg/p2p/client_test.go
@@ -35,8 +35,7 @@ func TestNewClientWithHost(t *testing.T) {
 	require.NoError(err)
 	ds := dssync.MutexWrap(datastore.NewMapDatastore())
 	logger := logging.Logger("test")
-	// No direct TestLogger equivalent for auto-fail, ensure test logic handles errors.
-	_ = logging.SetLogLevel("test", "debug") // Or other appropriate level for test debugging
+	_ = logging.SetLogLevel("test", "debug")
 	metrics := NopMetrics()
 
 	// Ensure config directory exists for nodeKey loading

diff --git a/pkg/rpc/client/client_test.go b/pkg/rpc/client/client_test.go
@@ -29,8 +29,7 @@ func setupTestServer(t *testing.T, mockStore *mocks.MockStore, mockP2P *mocks.Mo
 
 	// Create the servers
 	logger := logging.Logger("test")
-	// No direct TestLogger equivalent for auto-fail, ensure test logic handles errors.
-	_ = logging.SetLogLevel("test", "debug") // Or other appropriate level for test debugging
+	_ = logging.SetLogLevel("test", "debug")
 	storeServer := server.NewStoreServer(mockStore, logger)
 	p2pServer := server.NewP2PServer(mockP2P)
 

diff --git a/pkg/rpc/example/example.go b/pkg/rpc/example/example.go
@@ -19,7 +19,7 @@ func StartStoreServer(s store.Store, address string, logger logging.EventLogger)
 	// Create and start the server
 	// Start RPC server
 	rpcAddr := fmt.Sprintf("%s:%d", "localhost", 8080)
-	handler, err := server.NewServiceHandler(s, nil, logger) // Pass logger
+	handler, err := server.NewServiceHandler(s, nil, logger)
 	if err != nil {
 		panic(err)
 	}
@@ -79,7 +79,7 @@ func ExampleServer(s store.Store) {
 
 	// Start RPC server
 	rpcAddr := fmt.Sprintf("%s:%d", "localhost", 8080)
-	handler, err := server.NewServiceHandler(s, nil, logger) // Pass logger
+	handler, err := server.NewServiceHandler(s, nil, logger)
 	if err != nil {
 		panic(err)
 	}

diff --git a/pkg/service/baseservice.go b/pkg/service/baseservice.go
@@ -52,9 +52,6 @@ type BaseService struct {
 // The provided implementation (impl) should be the "subclass" that implements Run.
 func NewBaseService(logger logging.EventLogger, name string, impl Service) *BaseService {
 	if logger == nil {
-		// For ipfs/go-log, a "Nop" equivalent would be a logger with level set to FATAL,
-		// or a logger with a nil core. For simplicity, we'll create a default logger
-		// and set its level if no logger is provided.
 		nopLogger := logging.Logger("nop")
 		_ = logging.SetLogLevel("nop", "FATAL")
 		logger = nopLogger

diff --git a/pkg/sync/sync_service_test.go b/pkg/sync/sync_service_test.go
@@ -44,8 +44,7 @@ func TestHeaderSyncServiceRestart(t *testing.T) {
 	nodeKey, err := key.LoadOrGenNodeKey(filepath.Dir(conf.ConfigPath()))
 	require.NoError(t, err)
 	logger := logging.Logger("test")
-	// No direct TestLogger equivalent for auto-fail, ensure test logic handles errors.
-	_ = logging.SetLogLevel("test", "debug") // Or other appropriate level for test debugging
+	_ = logging.SetLogLevel("test", "debug")
 	priv := nodeKey.PrivKey
 	h, err := mn.AddPeer(priv, nil)
 	require.NoError(t, err)