refactor(bridge-history-api): add combine constraint (#585)

Co-authored-by: vincent <419436363@qq.com>
Co-authored-by: georgehao <haohongfan@gmail.com>
Co-authored-by: colinlyguo <colinlyguo@scroll.io>

bridge/cmd/event_watcher/app/app.go

@@ -21,7 +21,6 @@ import (
 )
 
 var app *cli.App
-var logger log.Logger
 
 func init() {
 	// Set up event-watcher app info.
@@ -33,9 +32,7 @@ func init() {
 	app.Flags = append(app.Flags, cutils.CommonFlags...)
 	app.Commands = []*cli.Command{}
 	app.Before = func(ctx *cli.Context) error {
-		var err error
-		logger, err = cutils.LogSetup(ctx)
-		return err
+		return cutils.LogSetup(ctx)
 	}
 	// Register `event-watcher-test` app for integration-test.
 	cutils.RegisterSimulation(app, cutils.EventWatcherApp)
@@ -51,7 +48,7 @@ func action(ctx *cli.Context) error {
 
 	subCtx, cancel := context.WithCancel(ctx.Context)
 	// Init db connection
-	db, err := utils.InitDB(cfg.DBConfig, logger)
+	db, err := utils.InitDB(cfg.DBConfig)
 	if err != nil {
 		log.Crit("failed to init db connection", "err", err)
 	}

bridge/cmd/gas_oracle/app/app.go

@@ -22,7 +22,6 @@ import (
 )
 
 var app *cli.App
-var logger log.Logger
 
 func init() {
 	// Set up gas-oracle app info.
@@ -35,9 +34,7 @@ func init() {
 	app.Flags = append(app.Flags, cutils.CommonFlags...)
 	app.Commands = []*cli.Command{}
 	app.Before = func(ctx *cli.Context) error {
-		var err error
-		logger, err = cutils.LogSetup(ctx)
-		return err
+		return cutils.LogSetup(ctx)
 	}
 	// Register `gas-oracle-test` app for integration-test.
 	cutils.RegisterSimulation(app, cutils.GasOracleApp)
@@ -52,7 +49,7 @@ func action(ctx *cli.Context) error {
 	}
 	subCtx, cancel := context.WithCancel(ctx.Context)
 	// Init db connection
-	db, err := utils.InitDB(cfg.DBConfig, logger)
+	db, err := utils.InitDB(cfg.DBConfig)
 	if err != nil {
 		log.Crit("failed to init db connection", "err", err)
 	}

bridge/cmd/msg_relayer/app/app.go

@@ -20,7 +20,6 @@ import (
 )
 
 var app *cli.App
-var logger log.Logger
 
 func init() {
 	// Set up message-relayer app info.
@@ -33,9 +32,7 @@ func init() {
 	app.Flags = append(app.Flags, cutils.CommonFlags...)
 	app.Commands = []*cli.Command{}
 	app.Before = func(ctx *cli.Context) error {
-		var err error
-		logger, err = cutils.LogSetup(ctx)
-		return err
+		return cutils.LogSetup(ctx)
 	}
 	// Register `message-relayer-test` app for integration-test.
 	cutils.RegisterSimulation(app, cutils.MessageRelayerApp)
@@ -51,7 +48,7 @@ func action(ctx *cli.Context) error {
 
 	subCtx, cancel := context.WithCancel(ctx.Context)
 	// Init db connection
-	db, err := utils.InitDB(cfg.DBConfig, logger)
+	db, err := utils.InitDB(cfg.DBConfig)
 	if err != nil {
 		log.Crit("failed to init db connection", "err", err)
 	}

bridge/cmd/rollup_relayer/app/app.go

@@ -22,7 +22,6 @@ import (
 )
 
 var app *cli.App
-var logger log.Logger
 
 func init() {
 	// Set up rollup-relayer app info.
@@ -35,9 +34,7 @@ func init() {
 	app.Flags = append(app.Flags, cutils.RollupRelayerFlags...)
 	app.Commands = []*cli.Command{}
 	app.Before = func(ctx *cli.Context) error {
-		var err error
-		logger, err = cutils.LogSetup(ctx)
-		return err
+		return cutils.LogSetup(ctx)
 	}
 	// Register `rollup-relayer-test` app for integration-test.
 	cutils.RegisterSimulation(app, cutils.RollupRelayerApp)
@@ -53,7 +50,7 @@ func action(ctx *cli.Context) error {
 
 	subCtx, cancel := context.WithCancel(ctx.Context)
 	// Init db connection
-	db, err := utils.InitDB(cfg.DBConfig, logger)
+	db, err := utils.InitDB(cfg.DBConfig)
 	if err != nil {
 		log.Crit("failed to init db connection", "err", err)
 	}

bridge/internal/controller/relayer/l1_relayer_test.go

@@ -49,9 +49,7 @@ var (
 )
 
 func setupL1RelayerDB(t *testing.T) *gorm.DB {
-	logger, err1 := utils.LogSetup(nil)
-	assert.NoError(t, err1)
-	db, err := bridgeUtils.InitDB(cfg.DBConfig, logger)
+	db, err := bridgeUtils.InitDB(cfg.DBConfig)
 	assert.NoError(t, err)
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)

bridge/internal/controller/relayer/l2_relayer_test.go

@@ -24,9 +24,7 @@ import (
 )
 
 func setupL2RelayerDB(t *testing.T) *gorm.DB {
-	logger, err1 := utils.LogSetup(nil)
-	assert.NoError(t, err1)
-	db, err := bridgeUtils.InitDB(cfg.DBConfig, logger)
+	db, err := bridgeUtils.InitDB(cfg.DBConfig)
 	assert.NoError(t, err)
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)

bridge/internal/controller/watcher/watcher_test.go

@@ -10,7 +10,6 @@ import (
 	"gorm.io/gorm"
 
 	"scroll-tech/common/docker"
-	cutils "scroll-tech/common/utils"
 
 	"scroll-tech/bridge/internal/config"
 	"scroll-tech/bridge/internal/orm/migrate"
@@ -75,9 +74,7 @@ func setupEnv(t *testing.T) (err error) {
 }
 
 func setupDB(t *testing.T) *gorm.DB {
-	logger, err1 := cutils.LogSetup(nil)
-	assert.NoError(t, err1)
-	db, err := utils.InitDB(cfg.DBConfig, logger)
+	db, err := utils.InitDB(cfg.DBConfig)
 	assert.NoError(t, err)
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)

bridge/internal/orm/orm_test.go

@@ -12,7 +12,6 @@ import (
 
 	"scroll-tech/common/docker"
 	"scroll-tech/common/types"
-	cutils "scroll-tech/common/utils"
 
 	"scroll-tech/bridge/internal/config"
 	"scroll-tech/bridge/internal/orm/migrate"
@@ -46,10 +45,6 @@ func TestMain(m *testing.M) {
 func setupEnv(t *testing.T) {
 	base = docker.NewDockerApp()
 	base.RunDBImage(t)
-
-	logger, err1 := cutils.LogSetup(nil)
-	assert.NoError(t, err1)
-
 	var err error
 	db, err = utils.InitDB(
 		&config.DBConfig{
@@ -58,7 +53,6 @@ func setupEnv(t *testing.T) {
 			MaxOpenNum: base.DBConfig.MaxOpenNum,
 			MaxIdleNum: base.DBConfig.MaxIdleNum,
 		},
-		logger,
 	)
 	assert.NoError(t, err)
 	sqlDB, err := db.DB()

bridge/internal/utils/db.go

@@ -1,52 +1,17 @@
 package utils
 
 import (
-	"context"
-	"time"
-
-	"github.com/scroll-tech/go-ethereum/log"
 	"gorm.io/driver/postgres"
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"
-	"gorm.io/gorm/utils"
 
 	"scroll-tech/bridge/internal/config"
 )
 
-type gormLogger struct {
-	gethLogger log.Logger
-}
-
-func (g *gormLogger) LogMode(level logger.LogLevel) logger.Interface {
-	return g
-}
-
-func (g *gormLogger) Info(_ context.Context, msg string, data ...interface{}) {
-	g.gethLogger.Info(msg, data)
-}
-
-func (g *gormLogger) Warn(_ context.Context, msg string, data ...interface{}) {
-	g.gethLogger.Warn(msg, data)
-}
-
-func (g *gormLogger) Error(_ context.Context, msg string, data ...interface{}) {
-	g.gethLogger.Error(msg, data)
-}
-
-func (g *gormLogger) Trace(_ context.Context, begin time.Time, fc func() (string, int64), err error) {
-	elapsed := time.Since(begin)
-	rows, sql := fc()
-	g.gethLogger.Debug("gorm", "line", utils.FileWithLineNum(), "cost", elapsed, "rows", sql, "sql", rows)
-}
-
 // InitDB init the db handler
-func InitDB(config *config.DBConfig, gethLogger log.Logger) (*gorm.DB, error) {
-	tmpGormLogger := gormLogger{
-		gethLogger: gethLogger,
-	}
-
+func InitDB(config *config.DBConfig) (*gorm.DB, error) {
 	db, err := gorm.Open(postgres.Open(config.DSN), &gorm.Config{
-		Logger: &tmpGormLogger,
+		Logger: logger.Default.LogMode(logger.Info),
 	})
 	if err != nil {
 		return nil, err

bridge/tests/bridge_test.go

@@ -12,7 +12,6 @@ import (
 	"gorm.io/gorm"
 
 	"scroll-tech/common/docker"
-	cutils "scroll-tech/common/utils"
 
 	bcmd "scroll-tech/bridge/cmd"
 	"scroll-tech/bridge/internal/config"
@@ -53,9 +52,7 @@ func setupDB(t *testing.T) *gorm.DB {
 		MaxOpenNum: base.DBConfig.MaxOpenNum,
 		MaxIdleNum: base.DBConfig.MaxIdleNum,
 	}
-	logger, err1 := cutils.LogSetup(nil)
-	assert.NoError(t, err1)
-	db, err := utils.InitDB(cfg, logger)
+	db, err := utils.InitDB(cfg)
 	assert.NoError(t, err)
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)

bridge/utils/confirmation.go

@@ -0,0 +1,56 @@
+package utils
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+
+	"github.com/scroll-tech/go-ethereum/core/types"
+	"github.com/scroll-tech/go-ethereum/rpc"
+)
+
+type ethClient interface {
+	BlockNumber(ctx context.Context) (uint64, error)
+	HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error)
+}
+
+// GetLatestConfirmedBlockNumber get confirmed block number by rpc.BlockNumber type.
+func GetLatestConfirmedBlockNumber(ctx context.Context, client ethClient, confirm rpc.BlockNumber) (uint64, error) {
+	switch true {
+	case confirm == rpc.SafeBlockNumber || confirm == rpc.FinalizedBlockNumber:
+		var tag *big.Int
+		if confirm == rpc.FinalizedBlockNumber {
+			tag = big.NewInt(int64(rpc.FinalizedBlockNumber))
+		} else {
+			tag = big.NewInt(int64(rpc.SafeBlockNumber))
+		}
+
+		header, err := client.HeaderByNumber(ctx, tag)
+		if err != nil {
+			return 0, err
+		}
+		if !header.Number.IsInt64() {
+			return 0, fmt.Errorf("received invalid block confirm: %v", header.Number)
+		}
+		return header.Number.Uint64(), nil
+	case confirm == rpc.LatestBlockNumber:
+		number, err := client.BlockNumber(ctx)
+		if err != nil {
+			return 0, err
+		}
+		return number, nil
+	case confirm.Int64() >= 0: // If it's positive integer, consider it as a certain confirm value.
+		number, err := client.BlockNumber(ctx)
+		if err != nil {
+			return 0, err
+		}
+		cfmNum := uint64(confirm.Int64())
+
+		if number >= cfmNum {
+			return number - cfmNum, nil
+		}
+		return 0, nil
+	default:
+		return 0, fmt.Errorf("unknown confirmation type: %v", confirm)
+	}
+}

bridge/utils/confirmation_test.go

@@ -0,0 +1,134 @@
+package utils
+
+import (
+	"context"
+	"encoding/json"
+	"math/big"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/scroll-tech/go-ethereum/common/math"
+	"github.com/scroll-tech/go-ethereum/core/types"
+	"github.com/scroll-tech/go-ethereum/rpc"
+)
+
+var (
+	tests = []struct {
+		input    string
+		mustFail bool
+		expected rpc.BlockNumber
+	}{
+		{`"0x"`, true, rpc.BlockNumber(0)},
+		{`"0x0"`, false, rpc.BlockNumber(0)},
+		{`"0X1"`, false, rpc.BlockNumber(1)},
+		{`"0x00"`, true, rpc.BlockNumber(0)},
+		{`"0x01"`, true, rpc.BlockNumber(0)},
+		{`"0x1"`, false, rpc.BlockNumber(1)},
+		{`"0x12"`, false, rpc.BlockNumber(18)},
+		{`"0x7fffffffffffffff"`, false, rpc.BlockNumber(math.MaxInt64)},
+		{`"0x8000000000000000"`, true, rpc.BlockNumber(0)},
+		{"0", true, rpc.BlockNumber(0)},
+		{`"ff"`, true, rpc.BlockNumber(0)},
+		{`"safe"`, false, rpc.SafeBlockNumber},
+		{`"finalized"`, false, rpc.FinalizedBlockNumber},
+		{`"pending"`, false, rpc.PendingBlockNumber},
+		{`"latest"`, false, rpc.LatestBlockNumber},
+		{`"earliest"`, false, rpc.EarliestBlockNumber},
+		{`someString`, true, rpc.BlockNumber(0)},
+		{`""`, true, rpc.BlockNumber(0)},
+		{``, true, rpc.BlockNumber(0)},
+	}
+)
+
+func TestUnmarshalJSON(t *testing.T) {
+	for i, test := range tests {
+		var num rpc.BlockNumber
+		err := json.Unmarshal([]byte(test.input), &num)
+		if test.mustFail && err == nil {
+			t.Errorf("Test %d should fail", i)
+			continue
+		}
+		if !test.mustFail && err != nil {
+			t.Errorf("Test %d should pass but got err: %v", i, err)
+			continue
+		}
+		if num != test.expected {
+			t.Errorf("Test %d got unexpected value, want %d, got %d", i, test.expected, num)
+		}
+	}
+}
+
+func TestMarshalJSON(t *testing.T) {
+	for i, test := range tests {
+		var num rpc.BlockNumber
+		want, err := json.Marshal(test.expected)
+		assert.NoError(t, err)
+		if !test.mustFail {
+			err = json.Unmarshal([]byte(test.input), &num)
+			assert.NoError(t, err)
+			got, err := json.Marshal(&num)
+			assert.NoError(t, err)
+			if string(want) != string(got) {
+				t.Errorf("Test %d got unexpected value, want %d, got %d", i, test.expected, num)
+			}
+		}
+	}
+}
+
+type MockEthClient struct {
+	val uint64
+}
+
+func (e MockEthClient) BlockNumber(ctx context.Context) (uint64, error) {
+	return e.val, nil
+}
+
+func (e MockEthClient) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) {
+	var blockNumber int64
+	switch number.Int64() {
+	case int64(rpc.LatestBlockNumber):
+		blockNumber = int64(e.val)
+	case int64(rpc.SafeBlockNumber):
+		blockNumber = int64(e.val) - 6
+	case int64(rpc.FinalizedBlockNumber):
+		blockNumber = int64(e.val) - 12
+	default:
+		blockNumber = number.Int64()
+	}
+	if blockNumber < 0 {
+		blockNumber = 0
+	}
+
+	return &types.Header{Number: new(big.Int).SetInt64(blockNumber)}, nil
+}
+
+func TestGetLatestConfirmedBlockNumber(t *testing.T) {
+	ctx := context.Background()
+	client := MockEthClient{}
+
+	testCases := []struct {
+		blockNumber    uint64
+		confirmation   rpc.BlockNumber
+		expectedResult uint64
+	}{
+		{5, 6, 0},
+		{7, 6, 1},
+		{10, 2, 8},
+		{0, 1, 0},
+		{3, 0, 3},
+		{15, 15, 0},
+		{16, rpc.SafeBlockNumber, 10},
+		{22, rpc.FinalizedBlockNumber, 10},
+		{10, rpc.LatestBlockNumber, 10},
+		{5, rpc.SafeBlockNumber, 0},
+		{11, rpc.FinalizedBlockNumber, 0},
+	}
+
+	for _, testCase := range testCases {
+		client.val = testCase.blockNumber
+		confirmed, err := GetLatestConfirmedBlockNumber(ctx, &client, testCase.confirmation)
+		assert.NoError(t, err)
+		assert.Equal(t, testCase.expectedResult, confirmed)
+	}
+}

bridge/utils/utils.go

@@ -0,0 +1,65 @@
+package utils
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/scroll-tech/go-ethereum/accounts/abi"
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/core/types"
+	"github.com/scroll-tech/go-ethereum/crypto"
+
+	bridgeabi "scroll-tech/bridge/abi"
+)
+
+// Keccak2 compute the keccack256 of two concatenations of bytes32
+func Keccak2(a common.Hash, b common.Hash) common.Hash {
+	return common.BytesToHash(crypto.Keccak256(append(a.Bytes()[:], b.Bytes()[:]...)))
+}
+
+// ComputeMessageHash compute the message hash
+func ComputeMessageHash(
+	sender common.Address,
+	target common.Address,
+	value *big.Int,
+	messageNonce *big.Int,
+	message []byte,
+) common.Hash {
+	data, _ := bridgeabi.L2ScrollMessengerABI.Pack("relayMessage", sender, target, value, messageNonce, message)
+	return common.BytesToHash(crypto.Keccak256(data))
+}
+
+// BufferToUint256Le convert bytes array to uint256 array assuming little-endian
+func BufferToUint256Le(buffer []byte) []*big.Int {
+	buffer256 := make([]*big.Int, len(buffer)/32)
+	for i := 0; i < len(buffer)/32; i++ {
+		v := big.NewInt(0)
+		shft := big.NewInt(1)
+		for j := 0; j < 32; j++ {
+			v = new(big.Int).Add(v, new(big.Int).Mul(shft, big.NewInt(int64(buffer[i*32+j]))))
+			shft = new(big.Int).Mul(shft, big.NewInt(256))
+		}
+		buffer256[i] = v
+	}
+	return buffer256
+}
+
+// UnpackLog unpacks a retrieved log into the provided output structure.
+// @todo: add unit test.
+func UnpackLog(c *abi.ABI, out interface{}, event string, log types.Log) error {
+	if log.Topics[0] != c.Events[event].ID {
+		return fmt.Errorf("event signature mismatch")
+	}
+	if len(log.Data) > 0 {
+		if err := c.UnpackIntoInterface(out, event, log.Data); err != nil {
+			return err
+		}
+	}
+	var indexed abi.Arguments
+	for _, arg := range c.Events[event].Inputs {
+		if arg.Indexed {
+			indexed = append(indexed, arg)
+		}
+	}
+	return abi.ParseTopics(out, indexed, log.Topics[1:])
+}

bridge/utils/utils_test.go

@@ -0,0 +1,49 @@
+package utils
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestKeccak2(t *testing.T) {
+	hash := Keccak2(common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"), common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"))
+	if hash != common.HexToHash("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5") {
+		t.Fatalf("Invalid keccak, want %s, got %s", "0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5", hash.Hex())
+	}
+
+	hash = Keccak2(common.HexToHash("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5"), common.HexToHash("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5"))
+	if hash != common.HexToHash("0xb4c11951957c6f8f642c4af61cd6b24640fec6dc7fc607ee8206a99e92410d30") {
+		t.Fatalf("Invalid keccak, want %s, got %s", "0xb4c11951957c6f8f642c4af61cd6b24640fec6dc7fc607ee8206a99e92410d30", hash.Hex())
+	}
+
+	hash = Keccak2(common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001"), common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000002"))
+	if hash != common.HexToHash("0xe90b7bceb6e7df5418fb78d8ee546e97c83a08bbccc01a0644d599ccd2a7c2e0") {
+		t.Fatalf("Invalid keccak, want %s, got %s", "0xe90b7bceb6e7df5418fb78d8ee546e97c83a08bbccc01a0644d599ccd2a7c2e0", hash.Hex())
+	}
+}
+
+func TestComputeMessageHash(t *testing.T) {
+	hash := ComputeMessageHash(
+		common.HexToAddress("0x1C5A77d9FA7eF466951B2F01F724BCa3A5820b63"),
+		common.HexToAddress("0x4592D8f8D7B001e72Cb26A73e4Fa1806a51aC79d"),
+		big.NewInt(0),
+		big.NewInt(1),
+		[]byte("testbridgecontract"),
+	)
+	assert.Equal(t, "0xda253c04595a49017bb54b1b46088c69752b5ad2f0c47971ac76b8b25abec202", hash.String())
+}
+
+func TestBufferToUint256Le(t *testing.T) {
+	input := []byte{
+		0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	}
+	expectedOutput := []*big.Int{big.NewInt(1)}
+	result := BufferToUint256Le(input)
+	assert.Equal(t, expectedOutput, result)
+}

common/utils/logger.go

@@ -13,7 +13,7 @@ import (
 )
 
 // LogSetup is for setup logger
-func LogSetup(ctx *cli.Context) (log.Logger, error) {
+func LogSetup(ctx *cli.Context) error {
 	var ostream log.Handler
 	if logFile := ctx.String(LogFileFlag.Name); len(logFile) > 0 {
 		fp, err := os.OpenFile(filepath.Clean(logFile), os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0600)
@@ -38,7 +38,6 @@ func LogSetup(ctx *cli.Context) (log.Logger, error) {
 	glogger := log.NewGlogHandler(ostream)
 	// Set log level
 	glogger.Verbosity(log.Lvl(ctx.Int(VerbosityFlag.Name)))
-	logger := log.Root()
-	logger.SetHandler(glogger)
-	return logger, nil
+	log.Root().SetHandler(glogger)
+	return nil
 }

coordinator/cmd/app/app.go

@@ -7,6 +7,7 @@ import (
 	"os/signal"
 
 	"github.com/scroll-tech/go-ethereum/ethclient"
+
 	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/urfave/cli/v2"
 
@@ -35,8 +36,7 @@ func init() {
 	app.Flags = append(app.Flags, apiFlags...)
 
 	app.Before = func(ctx *cli.Context) error {
-		_, err := utils.LogSetup(ctx)
-		return err
+		return utils.LogSetup(ctx)
 	}
 
 	// Register `coordinator-test` app for integration-test.

database/cmd/app/app.go

@@ -24,8 +24,7 @@ func init() {
 	app.Flags = append(app.Flags, utils.CommonFlags...)
 
 	app.Before = func(ctx *cli.Context) error {
-		_, err := utils.LogSetup(ctx)
-		return err
+		return utils.LogSetup(ctx)
 	}
 
 	app.Commands = []*cli.Command{

roller/cmd/app/app.go

@@ -26,8 +26,7 @@ func init() {
 	app.Version = version.Version
 	app.Flags = append(app.Flags, utils.CommonFlags...)
 	app.Before = func(ctx *cli.Context) error {
-		_, err := utils.LogSetup(ctx)
-		return err
+		return utils.LogSetup(ctx)
 	}
 
 	// Register `roller-test` app for integration-test.