feat: support log level and log format flags

cmd/blobstream/base/config.go

@@ -2,9 +2,15 @@ package base
 
 import (
 	"fmt"
+	"io"
 	"os"
 	"strings"
 
+	"github.com/cosmos/cosmos-sdk/server"
+	"github.com/rs/zerolog"
+	tmconfig "github.com/tendermint/tendermint/config"
+	tmlog "github.com/tendermint/tendermint/libs/log"
+
 	ethcmn "github.com/ethereum/go-ethereum/common"
 
 	"github.com/celestiaorg/orchestrator-relayer/evm"
@@ -75,8 +81,45 @@ const (
 	FlagCoreRPC  = "core.rpc"
 
 	FlagStartingNonce = "starting-nonce"
+
+	FlagLogLevel  = "log.level"
+	FlagLogFormat = "log.format"
 )
 
+func AddLogLevelFlag(cmd *cobra.Command) {
+	cmd.Flags().String(
+		FlagLogLevel,
+		"info",
+		"The logging level (trace|debug|info|warn|error|fatal|panic)",
+	)
+}
+
+func GetLogFormatFlag(cmd *cobra.Command) (string, bool, error) {
+	changed := cmd.Flags().Changed(FlagLogFormat)
+	val, err := cmd.Flags().GetString(FlagLogFormat)
+	if err != nil {
+		return "", changed, err
+	}
+	return val, changed, nil
+}
+
+func AddLogFormatFlag(cmd *cobra.Command) {
+	cmd.Flags().String(
+		FlagLogFormat,
+		"plain",
+		"The logging format (json|plain)",
+	)
+}
+
+func GetLogLevelFlag(cmd *cobra.Command) (string, bool, error) {
+	changed := cmd.Flags().Changed(FlagLogLevel)
+	val, err := cmd.Flags().GetString(FlagLogLevel)
+	if err != nil {
+		return "", changed, err
+	}
+	return val, changed, nil
+}
+
 func AddStartingNonceFlag(cmd *cobra.Command) {
 	cmd.Flags().String(
 		FlagStartingNonce,
@@ -278,3 +321,19 @@ func ValidateEVMAddress(addr string) error {
 func EnsureConfigPath(configPath string) error {
 	return os.MkdirAll(configPath, os.ModePerm)
 }
+
+// GetLogger creates a new logger and returns
+func GetLogger(level string, format string) (tmlog.Logger, error) {
+	logLvl, err := zerolog.ParseLevel(level)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse log level (%s): %w", level, err)
+	}
+	var logWriter io.Writer
+	if strings.ToLower(format) == tmconfig.LogFormatPlain {
+		logWriter = zerolog.ConsoleWriter{Out: os.Stderr}
+	} else {
+		logWriter = os.Stderr
+	}
+
+	return server.ZeroLogWrapper{Logger: zerolog.New(logWriter).Level(logLvl).With().Timestamp().Logger()}, nil
+}

cmd/blobstream/bootstrapper/cmd.go

@@ -2,10 +2,11 @@ package bootstrapper
 
 import (
 	"context"
-	"os"
 	"strings"
 	"time"
 
+	"github.com/celestiaorg/orchestrator-relayer/cmd/blobstream/base"
+
 	p2pcmd "github.com/celestiaorg/orchestrator-relayer/cmd/blobstream/keys/p2p"
 	"github.com/celestiaorg/orchestrator-relayer/helpers"
 	"github.com/celestiaorg/orchestrator-relayer/p2p"
@@ -14,7 +15,6 @@ import (
 	dssync "github.com/ipfs/go-datastore/sync"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/spf13/cobra"
-	tmlog "github.com/tendermint/tendermint/libs/log"
 )
 
 func Command() *cobra.Command {
@@ -48,8 +48,11 @@ func Start() *cobra.Command {
 			}
 
 			// creating the logger
-			logger := tmlog.NewTMLogger(os.Stdout)
-			logger.Debug("starting bootstrapper node")
+			logger, err := base.GetLogger(config.logLevel, config.logFormat)
+			if err != nil {
+				return err
+			}
+			logger.Info("starting bootstrapper node")
 
 			ctx, cancel := context.WithCancel(cmd.Context())
 			defer cancel()
@@ -144,7 +147,10 @@ func Init() *cobra.Command {
 				return err
 			}
 
-			logger := tmlog.NewTMLogger(os.Stdout)
+			logger, err := base.GetLogger(config.logLevel, config.logFormat)
+			if err != nil {
+				return err
+			}
 
 			initOptions := store.InitOptions{
 				NeedDataStore:   false,

cmd/blobstream/bootstrapper/config.go

@@ -18,13 +18,17 @@ func addStartFlags(cmd *cobra.Command) *cobra.Command {
 	base.AddP2PNicknameFlag(cmd)
 	base.AddP2PListenAddressFlag(cmd)
 	base.AddBootstrappersFlag(cmd)
+	base.AddLogLevelFlag(cmd)
+	base.AddLogFormatFlag(cmd)
 	return cmd
 }
 
 type StartConfig struct {
 	home                       string
 	p2pListenAddr, p2pNickname string
 	bootstrappers              string
+	logLevel                   string
+	logFormat                  string
 }
 
 func parseStartFlags(cmd *cobra.Command) (StartConfig, error) {
@@ -52,11 +56,23 @@ func parseStartFlags(cmd *cobra.Command) (StartConfig, error) {
 		return StartConfig{}, err
 	}
 
+	logLevel, _, err := base.GetLogLevelFlag(cmd)
+	if err != nil {
+		return StartConfig{}, err
+	}
+
+	logFormat, _, err := base.GetLogFormatFlag(cmd)
+	if err != nil {
+		return StartConfig{}, err
+	}
+
 	return StartConfig{
 		p2pNickname:   p2pNickname,
 		p2pListenAddr: p2pListenAddress,
 		home:          homeDir,
 		bootstrappers: bootstrappers,
+		logFormat:     logFormat,
+		logLevel:      logLevel,
 	}, nil
 }
 
@@ -66,11 +82,15 @@ func addInitFlags(cmd *cobra.Command) *cobra.Command {
 		panic(err)
 	}
 	cmd.Flags().String(base.FlagHome, homeDir, "The Blobstream bootstrappers home directory")
+	base.AddLogLevelFlag(cmd)
+	base.AddLogFormatFlag(cmd)
 	return cmd
 }
 
 type InitConfig struct {
-	home string
+	home      string
+	logLevel  string
+	logFormat string
 }
 
 func parseInitFlags(cmd *cobra.Command) (InitConfig, error) {
@@ -85,8 +105,18 @@ func parseInitFlags(cmd *cobra.Command) (InitConfig, error) {
 			return InitConfig{}, err
 		}
 	}
+	logLevel, _, err := base.GetLogLevelFlag(cmd)
+	if err != nil {
+		return InitConfig{}, err
+	}
 
+	logFormat, _, err := base.GetLogFormatFlag(cmd)
+	if err != nil {
+		return InitConfig{}, err
+	}
 	return InitConfig{
-		home: homeDir,
+		home:      homeDir,
+		logFormat: logFormat,
+		logLevel:  logLevel,
 	}, nil
 }

cmd/blobstream/deploy/cmd.go

@@ -2,9 +2,10 @@ package deploy
 
 import (
 	"context"
-	"os"
 	"strconv"
 
+	"github.com/celestiaorg/orchestrator-relayer/cmd/blobstream/base"
+
 	evm2 "github.com/celestiaorg/orchestrator-relayer/cmd/blobstream/keys/evm"
 
 	"github.com/celestiaorg/orchestrator-relayer/cmd/blobstream/keys"
@@ -32,7 +33,10 @@ func Command() *cobra.Command {
 				return err
 			}
 
-			logger := tmlog.NewTMLogger(os.Stdout)
+			logger, err := base.GetLogger(config.logLevel, config.logFormat)
+			if err != nil {
+				return err
+			}
 
 			// checking if the provided home is already initiated
 			isInit := store.IsInit(logger, config.Home, store.InitOptions{NeedEVMKeyStore: true})
@@ -109,7 +113,7 @@ func Command() *cobra.Command {
 			}(s.EVMKeyStore, acc.Address)
 
 			evmClient := evm.NewClient(
-				tmlog.NewTMLogger(os.Stdout),
+				logger,
 				nil,
 				s.EVMKeyStore,
 				&acc,

cmd/blobstream/deploy/config.go

@@ -29,6 +29,8 @@ func addDeployFlags(cmd *cobra.Command) *cobra.Command {
 	}
 	base.AddHomeFlag(cmd, ServiceNameDeployer, homeDir)
 	base.AddGRPCInsecureFlag(cmd)
+	base.AddLogLevelFlag(cmd)
+	base.AddLogFormatFlag(cmd)
 	return cmd
 }
 
@@ -41,6 +43,8 @@ type deployConfig struct {
 	startingNonce     string
 	evmGasLimit       uint64
 	grpcInsecure      bool
+	logLevel          string
+	logFormat         string
 }
 
 func parseDeployFlags(cmd *cobra.Command) (deployConfig, error) {
@@ -100,6 +104,16 @@ func parseDeployFlags(cmd *cobra.Command) (deployConfig, error) {
 		return deployConfig{}, err
 	}
 
+	logLevel, _, err := base.GetLogLevelFlag(cmd)
+	if err != nil {
+		return deployConfig{}, err
+	}
+
+	logFormat, _, err := base.GetLogFormatFlag(cmd)
+	if err != nil {
+		return deployConfig{}, err
+	}
+
 	return deployConfig{
 		Config: base.Config{
 			Home:          homeDir,
@@ -113,5 +127,7 @@ func parseDeployFlags(cmd *cobra.Command) (deployConfig, error) {
 		startingNonce: startingNonce,
 		evmGasLimit:   evmGasLimit,
 		grpcInsecure:  grpcInsecure,
+		logFormat:     logFormat,
+		logLevel:      logLevel,
 	}, nil
 }

cmd/blobstream/keys/evm/config.go

@@ -17,11 +17,15 @@ func keysConfigFlags(cmd *cobra.Command, service string) *cobra.Command {
 	}
 	cmd.Flags().String(base.FlagHome, homeDir, "The Blobstream evm keys home directory")
 	cmd.Flags().String(base.FlagEVMPassphrase, "", "the evm account passphrase (if not specified as a flag, it will be asked interactively)")
+	base.AddLogLevelFlag(cmd)
+	base.AddLogFormatFlag(cmd)
 	return cmd
 }
 
 type KeysConfig struct {
 	*base.Config
+	logLevel  string
+	logFormat string
 }
 
 func parseKeysConfigFlags(cmd *cobra.Command, serviceName string) (KeysConfig, error) {
@@ -41,11 +45,23 @@ func parseKeysConfigFlags(cmd *cobra.Command, serviceName string) (KeysConfig, e
 		return KeysConfig{}, err
 	}
 
+	logLevel, _, err := base.GetLogLevelFlag(cmd)
+	if err != nil {
+		return KeysConfig{}, err
+	}
+
+	logFormat, _, err := base.GetLogFormatFlag(cmd)
+	if err != nil {
+		return KeysConfig{}, err
+	}
+
 	return KeysConfig{
 		Config: &base.Config{
 			Home:          homeDir,
 			EVMPassphrase: passphrase,
 		},
+		logFormat: logFormat,
+		logLevel:  logLevel,
 	}, nil
 }
 
@@ -57,12 +73,16 @@ func keysNewPassphraseConfigFlags(cmd *cobra.Command, service string) *cobra.Com
 	cmd.Flags().String(base.FlagHome, homeDir, "The Blobstream evm keys home directory")
 	cmd.Flags().String(base.FlagEVMPassphrase, "", "the evm account passphrase (if not specified as a flag, it will be asked interactively)")
 	cmd.Flags().String(FlagNewEVMPassphrase, "", "the evm account new passphrase (if not specified as a flag, it will be asked interactively)")
+	base.AddLogLevelFlag(cmd)
+	base.AddLogFormatFlag(cmd)
 	return cmd
 }
 
 type KeysNewPassphraseConfig struct {
 	*base.Config
 	newPassphrase string
+	logLevel      string
+	logFormat     string
 }
 
 func parseKeysNewPassphraseConfigFlags(cmd *cobra.Command, serviceName string) (KeysNewPassphraseConfig, error) {
@@ -87,8 +107,20 @@ func parseKeysNewPassphraseConfigFlags(cmd *cobra.Command, serviceName string) (
 		return KeysNewPassphraseConfig{}, err
 	}
 
+	logLevel, _, err := base.GetLogLevelFlag(cmd)
+	if err != nil {
+		return KeysNewPassphraseConfig{}, err
+	}
+
+	logFormat, _, err := base.GetLogFormatFlag(cmd)
+	if err != nil {
+		return KeysNewPassphraseConfig{}, err
+	}
+
 	return KeysNewPassphraseConfig{
 		Config:        &base.Config{Home: homeDir, EVMPassphrase: passphrase},
 		newPassphrase: newPassphrase,
+		logFormat:     logFormat,
+		logLevel:      logLevel,
 	}, nil
 }