From 74b7eaf431a5dcc93f4a592a6aa98befd3c3cb75 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Federico=20Kunze=20K=C3=BCllmer?= <31522760+fedekunze@users.noreply.github.com> Date: Mon, 12 Jul 2021 14:39:35 -0400 Subject: [PATCH] rpc: fix inconsistent logging levels (#265) * rpc: fix incosistent logging levels * minor changes --- ethereum/rpc/apis.go | 14 +- ethereum/rpc/backend/backend.go | 50 +++--- ethereum/rpc/namespaces/eth/api.go | 153 +++++++++--------- ethereum/rpc/namespaces/eth/filters/api.go | 47 ++---- .../namespaces/eth/filters/filter_system.go | 18 ++- .../rpc/namespaces/eth/filters/filters.go | 69 ++++---- ethereum/rpc/namespaces/personal/api.go | 18 +-- ethereum/rpc/namespaces/txpool/api.go | 8 +- ethereum/rpc/websockets.go | 101 +++++------- server/start.go | 51 +++--- tests/solidity/init-test-node.sh | 2 +- testutil/network/util.go | 2 +- 12 files changed, 248 insertions(+), 285 deletions(-) diff --git a/ethereum/rpc/apis.go b/ethereum/rpc/apis.go index 224cdfc5..d101f389 100644 --- a/ethereum/rpc/apis.go +++ b/ethereum/rpc/apis.go @@ -4,6 +4,8 @@ package rpc import ( "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/server" + "github.com/ethereum/go-ethereum/rpc" "github.com/tharsis/ethermint/ethereum/rpc/backend" "github.com/tharsis/ethermint/ethereum/rpc/namespaces/eth" @@ -29,10 +31,10 @@ const ( ) // GetRPCAPIs returns the list of all APIs -func GetRPCAPIs(clientCtx client.Context, tmWSClient *rpcclient.WSClient) []rpc.API { +func GetRPCAPIs(ctx *server.Context, clientCtx client.Context, tmWSClient *rpcclient.WSClient) []rpc.API { nonceLock := new(types.AddrLocker) - backend := backend.NewEVMBackend(clientCtx) - ethAPI := eth.NewPublicAPI(clientCtx, backend, nonceLock) + backend := backend.NewEVMBackend(ctx.Logger, clientCtx) + ethAPI := eth.NewPublicAPI(ctx.Logger, clientCtx, backend, nonceLock) return []rpc.API{ { @@ -50,7 +52,7 @@ func GetRPCAPIs(clientCtx client.Context, tmWSClient *rpcclient.WSClient) []rpc. { Namespace: EthNamespace, Version: apiVersion, - Service: filters.NewPublicAPI(tmWSClient, backend), + Service: filters.NewPublicAPI(ctx.Logger, tmWSClient, backend), Public: true, }, { @@ -62,13 +64,13 @@ func GetRPCAPIs(clientCtx client.Context, tmWSClient *rpcclient.WSClient) []rpc. { Namespace: PersonalNamespace, Version: apiVersion, - Service: personal.NewAPI(ethAPI), + Service: personal.NewAPI(ctx.Logger, ethAPI), Public: true, }, { Namespace: TxPoolNamespace, Version: apiVersion, - Service: txpool.NewPublicAPI(), + Service: txpool.NewPublicAPI(ctx.Logger), Public: true, }, } diff --git a/ethereum/rpc/backend/backend.go b/ethereum/rpc/backend/backend.go index 1065057e..c99ec1a2 100644 --- a/ethereum/rpc/backend/backend.go +++ b/ethereum/rpc/backend/backend.go @@ -9,8 +9,8 @@ import ( "github.com/tharsis/ethermint/ethereum/rpc/types" "github.com/pkg/errors" + "github.com/tendermint/tendermint/libs/log" tmtypes "github.com/tendermint/tendermint/types" - log "github.com/xlab/suplog" "github.com/cosmos/cosmos-sdk/client" sdk "github.com/cosmos/cosmos-sdk/types" @@ -58,7 +58,7 @@ type EVMBackend struct { } // NewEVMBackend creates a new EVMBackend instance -func NewEVMBackend(clientCtx client.Context) *EVMBackend { +func NewEVMBackend(logger log.Logger, clientCtx client.Context) *EVMBackend { chainID, err := ethermint.ParseChainID(clientCtx.ChainID) if err != nil { panic(err) @@ -67,7 +67,7 @@ func NewEVMBackend(clientCtx client.Context) *EVMBackend { ctx: context.Background(), clientCtx: clientCtx, queryClient: types.NewQueryClient(clientCtx), - logger: log.WithField("module", "evm-backend"), + logger: logger.With("module", "evm-backend"), chainID: chainID, } } @@ -110,21 +110,21 @@ func (e *EVMBackend) GetBlockByNumber(blockNum types.BlockNumber, fullTx bool) ( resBlock, err := e.clientCtx.Client.Block(e.ctx, &height) if err != nil { - // e.logger.Debugf("GetBlockByNumber safely bumping down from %d to latest", height) + // e.logger.Debug("GetBlockByNumber safely bumping down from %d to latest", height) if resBlock, err = e.clientCtx.Client.Block(e.ctx, nil); err != nil { - e.logger.WithError(err).Debugln("GetBlockByNumber failed to get latest block") + e.logger.Debug("GetBlockByNumber failed to get latest block", "error", err.Error()) return nil, nil } } if resBlock.Block == nil { - e.logger.Debugln("GetBlockByNumber block not found", "height", height) + e.logger.Debug("GetBlockByNumber block not found", "height", height) return nil, nil } res, err := e.EthBlockFromTendermint(e.clientCtx, e.queryClient, resBlock.Block, fullTx) if err != nil { - e.logger.WithError(err).Debugf("EthBlockFromTendermint failed with block %s", resBlock.Block.String()) + e.logger.Debug("EthBlockFromTendermint failed", "height", height, "error", err.Error()) } return res, err @@ -134,12 +134,12 @@ func (e *EVMBackend) GetBlockByNumber(blockNum types.BlockNumber, fullTx bool) ( func (e *EVMBackend) GetBlockByHash(hash common.Hash, fullTx bool) (map[string]interface{}, error) { resBlock, err := e.clientCtx.Client.BlockByHash(e.ctx, hash.Bytes()) if err != nil { - e.logger.WithError(err).Debugln("BlockByHash block not found", "hash", hash.Hex()) + e.logger.Debug("BlockByHash block not found", "hash", hash.Hex(), "error", err.Error()) return nil, err } if resBlock.Block == nil { - e.logger.Debugln("BlockByHash block not found", "hash", hash.Hex()) + e.logger.Debug("BlockByHash block not found", "hash", hash.Hex()) return nil, nil } @@ -161,7 +161,7 @@ func (e *EVMBackend) EthBlockFromTendermint( for i, txBz := range block.Txs { tx, err := e.clientCtx.TxConfig.TxDecoder()(txBz) if err != nil { - e.logger.WithError(err).Warningln("failed to decode transaction in block at height ", block.Height) + e.logger.Debug("failed to decode transaction in block", "height", block.Height, "error", err.Error()) continue } @@ -183,13 +183,13 @@ func (e *EVMBackend) EthBlockFromTendermint( // get full transaction from message data from, err := ethMsg.GetSender(e.chainID) if err != nil { - e.logger.WithError(err).Warningln("failed to get sender from already included transaction ", hash) + e.logger.Debug("failed to get sender from already included transaction", "hash", hash.Hex(), "error", err.Error()) from = common.HexToAddress(ethMsg.From) } txData, err := evmtypes.UnpackTxData(ethMsg.Data) if err != nil { - e.logger.WithError(err).Debugln("decoding failed") + e.logger.Debug("decoding failed", "error", err.Error()) return nil, fmt.Errorf("failed to unpack tx data: %w", err) } @@ -202,7 +202,7 @@ func (e *EVMBackend) EthBlockFromTendermint( uint64(i), ) if err != nil { - e.logger.WithError(err).Debugln("NewTransactionFromData for receipt failed", "hash", hash.Hex) + e.logger.Debug("NewTransactionFromData for receipt failed", "hash", hash.Hex(), "error", err.Error()) continue } ethRPCTxs = append(ethRPCTxs, ethTx) @@ -211,15 +211,13 @@ func (e *EVMBackend) EthBlockFromTendermint( blockBloomResp, err := queryClient.BlockBloom(types.ContextWithHeight(block.Height), &evmtypes.QueryBlockBloomRequest{}) if err != nil { - e.logger.WithError(err).Debugln("failed to query BlockBloom", "height", block.Height) + e.logger.Debug("failed to query BlockBloom", "height", block.Height, "error", err.Error()) blockBloomResp = &evmtypes.QueryBlockBloomResponse{Bloom: ethtypes.Bloom{}.Bytes()} } bloom := ethtypes.BytesToBloom(blockBloomResp.Bloom) formattedBlock := types.FormatBlock(block.Header, block.Size(), ethermint.DefaultRPCGasLimit, new(big.Int).SetUint64(gasUsed), ethRPCTxs, bloom) - - e.logger.Infoln(formattedBlock) return formattedBlock, nil } @@ -241,14 +239,13 @@ func (e *EVMBackend) HeaderByNumber(blockNum types.BlockNumber) (*ethtypes.Heade height = 1 default: if blockNum < 0 { - err := errors.Errorf("incorrect block height: %d", height) - return nil, err + return nil, errors.Errorf("incorrect block height: %d", height) } } resBlock, err := e.clientCtx.Client.Block(e.ctx, &height) if err != nil { - e.logger.Warningf("HeaderByNumber failed") + e.logger.Debug("HeaderByNumber failed") return nil, err } @@ -256,7 +253,7 @@ func (e *EVMBackend) HeaderByNumber(blockNum types.BlockNumber) (*ethtypes.Heade res, err := e.queryClient.BlockBloom(types.ContextWithHeight(resBlock.Block.Height), req) if err != nil { - e.logger.Warningf("HeaderByNumber BlockBloom fail %d", resBlock.Block.Height) + e.logger.Debug("HeaderByNumber BlockBloom failed", "height", resBlock.Block.Height) return nil, err } @@ -269,7 +266,7 @@ func (e *EVMBackend) HeaderByNumber(blockNum types.BlockNumber) (*ethtypes.Heade func (e *EVMBackend) HeaderByHash(blockHash common.Hash) (*ethtypes.Header, error) { resBlock, err := e.clientCtx.Client.BlockByHash(e.ctx, blockHash.Bytes()) if err != nil { - e.logger.Warningf("HeaderByHash fail") + e.logger.Debug("HeaderByHash failed", "hash", blockHash.Hex()) return nil, err } @@ -277,7 +274,7 @@ func (e *EVMBackend) HeaderByHash(blockHash common.Hash) (*ethtypes.Header, erro res, err := e.queryClient.BlockBloom(types.ContextWithHeight(resBlock.Block.Height), req) if err != nil { - e.logger.Warningf("HeaderByHash BlockBloom fail %d", resBlock.Block.Height) + e.logger.Debug("HeaderByHash BlockBloom failed", "height", resBlock.Block.Height) return nil, err } @@ -296,7 +293,7 @@ func (e *EVMBackend) GetTransactionLogs(txHash common.Hash) ([]*ethtypes.Log, er res, err := e.queryClient.TxLogs(e.ctx, req) if err != nil { - e.logger.Warningf("TxLogs fail") + e.logger.Debug("TxLogs failed", "tx-hash", req.Hash) return nil, err } @@ -332,7 +329,7 @@ func (e *EVMBackend) GetLogs(blockHash common.Hash) ([][]*ethtypes.Log, error) { res, err := e.queryClient.BlockLogs(e.ctx, req) if err != nil { - e.logger.Warningf("BlockLogs fail") + e.logger.Debug("BlockLogs failed", "hash", req.Hash) return nil, err } @@ -364,8 +361,7 @@ func (e *EVMBackend) GetLogsByNumber(blockNum types.BlockNumber) ([][]*ethtypes. height = 1 default: if blockNum < 0 { - err := errors.Errorf("incorrect block height: %d", height) - return nil, err + return nil, errors.Errorf("incorrect block height: %d", height) } } @@ -375,7 +371,7 @@ func (e *EVMBackend) GetLogsByNumber(blockNum types.BlockNumber) ([][]*ethtypes. return [][]*ethtypes.Log{}, nil } - e.logger.Warningf("failed to query block at %d", height) + e.logger.Debug("failed to query block", "height", height) return nil, err } diff --git a/ethereum/rpc/namespaces/eth/api.go b/ethereum/rpc/namespaces/eth/api.go index 52d94dc2..85396a2d 100644 --- a/ethereum/rpc/namespaces/eth/api.go +++ b/ethereum/rpc/namespaces/eth/api.go @@ -10,7 +10,7 @@ import ( "github.com/pkg/errors" "github.com/spf13/viper" - log "github.com/xlab/suplog" + "github.com/tendermint/tendermint/libs/log" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/client/flags" @@ -48,6 +48,7 @@ type PublicAPI struct { // NewPublicAPI creates an instance of the public ETH Web3 API. func NewPublicAPI( + logger log.Logger, clientCtx client.Context, backend backend.Backend, nonceLock *rpctypes.AddrLocker, @@ -80,7 +81,7 @@ func NewPublicAPI( clientCtx: clientCtx, queryClient: rpctypes.NewQueryClient(clientCtx), chainIDEpoch: epoch, - logger: log.WithField("module", "json-rpc"), + logger: logger.With("client", "json-rpc"), backend: backend, nonceLock: nonceLock, } @@ -95,20 +96,20 @@ func (e *PublicAPI) ClientCtx() client.Context { // ProtocolVersion returns the supported Ethereum protocol version. func (e *PublicAPI) ProtocolVersion() hexutil.Uint { - e.logger.Debugln("eth_protocolVersion") + e.logger.Debug("eth_protocolVersion") return hexutil.Uint(ethermint.ProtocolVersion) } // ChainId returns the chain's identifier in hex format func (e *PublicAPI) ChainId() (hexutil.Uint, error) { // nolint - e.logger.Debugln("eth_chainId") + e.logger.Debug("eth_chainId") return hexutil.Uint(uint(e.chainIDEpoch.Uint64())), nil } // Syncing returns whether or not the current node is syncing with other peers. Returns false if not, or a struct // outlining the state of the sync if it is. func (e *PublicAPI) Syncing() (interface{}, error) { - e.logger.Debugln("eth_syncing") + e.logger.Debug("eth_syncing") status, err := e.clientCtx.Client.Status(e.ctx) if err != nil { @@ -130,7 +131,7 @@ func (e *PublicAPI) Syncing() (interface{}, error) { // Coinbase is the address that staking rewards will be send to (alias for Etherbase). func (e *PublicAPI) Coinbase() (string, error) { - e.logger.Debugln("eth_coinbase") + e.logger.Debug("eth_coinbase") node, err := e.clientCtx.GetNode() if err != nil { @@ -158,19 +159,19 @@ func (e *PublicAPI) Coinbase() (string, error) { // Mining returns whether or not this node is currently mining. Always false. func (e *PublicAPI) Mining() bool { - e.logger.Debugln("eth_mining") + e.logger.Debug("eth_mining") return false } // Hashrate returns the current node's hashrate. Always 0. func (e *PublicAPI) Hashrate() hexutil.Uint64 { - e.logger.Debugln("eth_hashrate") + e.logger.Debug("eth_hashrate") return 0 } // GasPrice returns the current gas price based on Ethermint's gas price oracle. func (e *PublicAPI) GasPrice() *hexutil.Big { - e.logger.Debugln("eth_gasPrice") + e.logger.Debug("eth_gasPrice") // TODO: use minimum value defined in config instead of default or implement oracle out := big.NewInt(ethermint.DefaultGasPrice) return (*hexutil.Big)(out) @@ -178,7 +179,7 @@ func (e *PublicAPI) GasPrice() *hexutil.Big { // Accounts returns the list of accounts available to this node. func (e *PublicAPI) Accounts() ([]common.Address, error) { - e.logger.Debugln("eth_accounts") + e.logger.Debug("eth_accounts") addresses := make([]common.Address, 0) // return [] instead of nil if empty @@ -197,13 +198,13 @@ func (e *PublicAPI) Accounts() ([]common.Address, error) { // BlockNumber returns the current block number. func (e *PublicAPI) BlockNumber() (hexutil.Uint64, error) { - // e.logger.Debugln("eth_blockNumber") + e.logger.Debug("eth_blockNumber") return e.backend.BlockNumber() } // GetBalance returns the provided account's balance up to the provided block number. func (e *PublicAPI) GetBalance(address common.Address, blockNum rpctypes.BlockNumber) (*hexutil.Big, error) { // nolint: interfacer - e.logger.Debugln("eth_getBalance", "address", address.String(), "block number", blockNum) + e.logger.Debug("eth_getBalance", "address", address.String(), "block number", blockNum) req := &evmtypes.QueryBalanceRequest{ Address: address.String(), @@ -224,7 +225,7 @@ func (e *PublicAPI) GetBalance(address common.Address, blockNum rpctypes.BlockNu // GetStorageAt returns the contract storage at the given address, block number, and key. func (e *PublicAPI) GetStorageAt(address common.Address, key string, blockNum rpctypes.BlockNumber) (hexutil.Bytes, error) { // nolint: interfacer - e.logger.Debugln("eth_getStorageAt", "address", address.Hex(), "key", key, "block number", blockNum) + e.logger.Debug("eth_getStorageAt", "address", address.Hex(), "key", key, "block number", blockNum) req := &evmtypes.QueryStorageRequest{ Address: address.String(), @@ -242,7 +243,7 @@ func (e *PublicAPI) GetStorageAt(address common.Address, key string, blockNum rp // GetTransactionCount returns the number of transactions at the given address up to the given block number. func (e *PublicAPI) GetTransactionCount(address common.Address, blockNum rpctypes.BlockNumber) (*hexutil.Uint64, error) { - e.logger.Debugln("eth_getTransactionCount", "address", address.Hex(), "block number", blockNum) + e.logger.Debug("eth_getTransactionCount", "address", address.Hex(), "block number", blockNum) // Get nonce (sequence) from account from := sdk.AccAddress(address.Bytes()) @@ -267,7 +268,7 @@ func (e *PublicAPI) GetTransactionCount(address common.Address, blockNum rpctype // GetBlockTransactionCountByHash returns the number of transactions in the block identified by hash. func (e *PublicAPI) GetBlockTransactionCountByHash(hash common.Hash) *hexutil.Uint { - e.logger.Debugln("eth_getBlockTransactionCountByHash", "hash", hash.Hex()) + e.logger.Debug("eth_getBlockTransactionCountByHash", "hash", hash.Hex()) resBlock, err := e.clientCtx.Client.BlockByHash(e.ctx, hash.Bytes()) if err != nil { @@ -280,7 +281,7 @@ func (e *PublicAPI) GetBlockTransactionCountByHash(hash common.Hash) *hexutil.Ui // GetBlockTransactionCountByNumber returns the number of transactions in the block identified by number. func (e *PublicAPI) GetBlockTransactionCountByNumber(blockNum rpctypes.BlockNumber) *hexutil.Uint { - e.logger.Debugln("eth_getBlockTransactionCountByNumber", "block number", blockNum) + e.logger.Debug("eth_getBlockTransactionCountByNumber", "block number", blockNum) resBlock, err := e.clientCtx.Client.Block(e.ctx, blockNum.TmHeight()) if err != nil { return nil @@ -302,7 +303,7 @@ func (e *PublicAPI) GetUncleCountByBlockNumber(blockNum rpctypes.BlockNumber) he // GetCode returns the contract code at the given address and block number. func (e *PublicAPI) GetCode(address common.Address, blockNumber rpctypes.BlockNumber) (hexutil.Bytes, error) { // nolint: interfacer - e.logger.Debugln("eth_getCode", "address", address.Hex(), "block number", blockNumber) + e.logger.Debug("eth_getCode", "address", address.Hex(), "block number", blockNumber) req := &evmtypes.QueryCodeRequest{ Address: address.String(), @@ -318,26 +319,26 @@ func (e *PublicAPI) GetCode(address common.Address, blockNumber rpctypes.BlockNu // GetTransactionLogs returns the logs given a transaction hash. func (e *PublicAPI) GetTransactionLogs(txHash common.Hash) ([]*ethtypes.Log, error) { - e.logger.Debugln("eth_getTransactionLogs", "hash", txHash) + e.logger.Debug("eth_getTransactionLogs", "hash", txHash) return e.backend.GetTransactionLogs(txHash) } // Sign signs the provided data using the private key of address via Geth's signature standard. func (e *PublicAPI) Sign(address common.Address, data hexutil.Bytes) (hexutil.Bytes, error) { - e.logger.Debugln("eth_sign", "address", address.Hex(), "data", common.Bytes2Hex(data)) + e.logger.Debug("eth_sign", "address", address.Hex(), "data", common.Bytes2Hex(data)) from := sdk.AccAddress(address.Bytes()) _, err := e.clientCtx.Keyring.KeyByAddress(from) if err != nil { - e.logger.Errorln("failed to find key in keyring", "address", address.String()) + e.logger.Error("failed to find key in keyring", "address", address.String()) return nil, fmt.Errorf("%s; %s", keystore.ErrNoMatch, err.Error()) } // Sign the requested hash with the wallet signature, _, err := e.clientCtx.Keyring.SignByAddress(from, data) if err != nil { - e.logger.Panicln("keyring.SignByAddress failed") + e.logger.Error("keyring.SignByAddress failed", "address", address.Hex()) return nil, err } @@ -347,12 +348,12 @@ func (e *PublicAPI) Sign(address common.Address, data hexutil.Bytes) (hexutil.By // SendTransaction sends an Ethereum transaction. func (e *PublicAPI) SendTransaction(args rpctypes.SendTxArgs) (common.Hash, error) { - e.logger.Debugln("eth_sendTransaction", "args", args.String()) + e.logger.Debug("eth_sendTransaction", "args", args.String()) // Look up the wallet containing the requested signer _, err := e.clientCtx.Keyring.KeyByAddress(sdk.AccAddress(args.From.Bytes())) if err != nil { - e.logger.WithError(err).Errorln("failed to find key in keyring", "address", args.From) + e.logger.Error("failed to find key in keyring", "address", args.From, "error", err.Error()) return common.Hash{}, fmt.Errorf("%s; %s", keystore.ErrNoMatch, err.Error()) } @@ -364,7 +365,7 @@ func (e *PublicAPI) SendTransaction(args rpctypes.SendTxArgs) (common.Hash, erro msg := args.ToTransaction() if err := msg.ValidateBasic(); err != nil { - e.logger.WithError(err).Debugln("tx failed basic validation") + e.logger.Debug("tx failed basic validation", "error", err.Error()) return common.Hash{}, err } @@ -373,38 +374,38 @@ func (e *PublicAPI) SendTransaction(args rpctypes.SendTxArgs) (common.Hash, erro // Sign transaction if err := msg.Sign(signer, e.clientCtx.Keyring); err != nil { - e.logger.Debugln("failed to sign tx", "error", err) + e.logger.Debug("failed to sign tx", "error", err.Error()) return common.Hash{}, err } // Assemble transaction from fields builder, ok := e.clientCtx.TxConfig.NewTxBuilder().(authtx.ExtensionOptionsTxBuilder) if !ok { - e.logger.WithError(err).Panicln("clientCtx.TxConfig.NewTxBuilder returns unsupported builder") + e.logger.Error("clientCtx.TxConfig.NewTxBuilder returns unsupported builder", "error", err.Error()) } option, err := codectypes.NewAnyWithValue(&evmtypes.ExtensionOptionsEthereumTx{}) if err != nil { - e.logger.WithError(err).Panicln("codectypes.NewAnyWithValue failed to pack an obvious value") + e.logger.Error("codectypes.NewAnyWithValue failed to pack an obvious value", "error", err.Error()) return common.Hash{}, err } builder.SetExtensionOptions(option) err = builder.SetMsgs(msg) if err != nil { - e.logger.WithError(err).Panicln("builder.SetMsgs failed") + e.logger.Error("builder.SetMsgs failed", "error", err.Error()) } // Query params to use the EVM denomination res, err := e.queryClient.QueryClient.Params(e.ctx, &evmtypes.QueryParamsRequest{}) if err != nil { - e.logger.WithError(err).Errorln("failed to query evm params") + e.logger.Error("failed to query evm params", "error", err.Error()) return common.Hash{}, err } txData, err := evmtypes.UnpackTxData(msg.Data) if err != nil { - e.logger.WithError(err).Errorln("failed to unpack tx data") + e.logger.Error("failed to unpack tx data", "error", err.Error()) return common.Hash{}, err } @@ -416,7 +417,7 @@ func (e *PublicAPI) SendTransaction(args rpctypes.SendTxArgs) (common.Hash, erro txEncoder := e.clientCtx.TxConfig.TxEncoder() txBytes, err := txEncoder(builder.GetTx()) if err != nil { - e.logger.WithError(err).Errorln("failed to encode eth tx using default encoder") + e.logger.Error("failed to encode eth tx using default encoder", "error", err.Error()) return common.Hash{}, err } @@ -430,7 +431,7 @@ func (e *PublicAPI) SendTransaction(args rpctypes.SendTxArgs) (common.Hash, erro if err == nil { err = errors.New(rsp.RawLog) } - e.logger.WithError(err).Errorln("failed to broadcast tx") + e.logger.Error("failed to broadcast tx", "error", err.Error()) return txHash, err } @@ -440,53 +441,53 @@ func (e *PublicAPI) SendTransaction(args rpctypes.SendTxArgs) (common.Hash, erro // SendRawTransaction send a raw Ethereum transaction. func (e *PublicAPI) SendRawTransaction(data hexutil.Bytes) (common.Hash, error) { - e.logger.Debugln("eth_sendRawTransaction", "data_len", len(data)) + e.logger.Debug("eth_sendRawTransaction", "length", len(data)) // RLP decode raw transaction bytes tx, err := e.clientCtx.TxConfig.TxDecoder()(data) if err != nil { - e.logger.WithError(err).Errorln("transaction decoding failed") + e.logger.Error("transaction decoding failed", "error", err.Error()) return common.Hash{}, err } ethereumTx, isEthTx := tx.(*evmtypes.MsgEthereumTx) if !isEthTx { - e.logger.Debugln("invalid transaction type", "type", fmt.Sprintf("%T", tx)) + e.logger.Debug("invalid transaction type", "type", fmt.Sprintf("%T", tx)) return common.Hash{}, fmt.Errorf("invalid transaction type %T", tx) } if err := ethereumTx.ValidateBasic(); err != nil { - e.logger.WithError(err).Debugln("tx failed basic validation") + e.logger.Debug("tx failed basic validation", "error", err.Error()) return common.Hash{}, err } builder, ok := e.clientCtx.TxConfig.NewTxBuilder().(authtx.ExtensionOptionsTxBuilder) if !ok { - e.logger.Panicln("clientCtx.TxConfig.NewTxBuilder returns unsupported builder") + e.logger.Error("clientCtx.TxConfig.NewTxBuilder returns unsupported builder") } option, err := codectypes.NewAnyWithValue(&evmtypes.ExtensionOptionsEthereumTx{}) if err != nil { - e.logger.WithError(err).Panicln("codectypes.NewAnyWithValue failed to pack an obvious value") + e.logger.Error("codectypes.NewAnyWithValue failed to pack an obvious value", "error", err.Error()) } builder.SetExtensionOptions(option) err = builder.SetMsgs(tx.GetMsgs()...) if err != nil { - e.logger.WithError(err).Panicln("builder.SetMsgs failed") + e.logger.Error("builder.SetMsgs failed", "error", err.Error()) } // Query params to use the EVM denomination res, err := e.queryClient.QueryClient.Params(e.ctx, &evmtypes.QueryParamsRequest{}) if err != nil { - e.logger.WithError(err).Errorln("failed to query evm params") + e.logger.Error("failed to query evm params", "error", err.Error()) return common.Hash{}, err } txData, err := evmtypes.UnpackTxData(ethereumTx.Data) if err != nil { - e.logger.WithError(err).Errorln("failed to unpack tx data") + e.logger.Error("failed to unpack tx data", "error", err.Error()) return common.Hash{}, err } @@ -497,7 +498,7 @@ func (e *PublicAPI) SendRawTransaction(data hexutil.Bytes) (common.Hash, error) // Encode transaction by default Tx encoder txBytes, err := e.clientCtx.TxConfig.TxEncoder()(builder.GetTx()) if err != nil { - e.logger.WithError(err).Errorln("failed to encode eth tx using default encoder") + e.logger.Error("failed to encode eth tx using default encoder", "error", err.Error()) return common.Hash{}, err } @@ -509,7 +510,7 @@ func (e *PublicAPI) SendRawTransaction(data hexutil.Bytes) (common.Hash, error) if err == nil { err = errors.New(rsp.RawLog) } - e.logger.WithError(err).Errorln("failed to broadcast tx") + e.logger.Error("failed to broadcast tx", "error", err.Error()) return txHash, err } @@ -518,7 +519,7 @@ func (e *PublicAPI) SendRawTransaction(data hexutil.Bytes) (common.Hash, error) // Call performs a raw contract call. func (e *PublicAPI) Call(args evmtypes.CallArgs, blockNr rpctypes.BlockNumber, _ *rpctypes.StateOverride) (hexutil.Bytes, error) { - e.logger.Debugln("eth_call", "args", args.String(), "block number", blockNr) + e.logger.Debug("eth_call", "args", args.String(), "block number", blockNr) data, err := e.doCall(args, blockNr) if err != nil { return []byte{}, err @@ -549,11 +550,9 @@ func (e *PublicAPI) doCall( return res, nil } -//EstimateGas returns an estimate of gas usage for the given smart contract call. -// It adds 1,000 gas to the returned value instead of using the gas adjustment -// param from the SDK. +// EstimateGas returns an estimate of gas usage for the given smart contract call. func (e *PublicAPI) EstimateGas(args evmtypes.CallArgs) (hexutil.Uint64, error) { - e.logger.Debugln("eth_estimateGas") + e.logger.Debug("eth_estimateGas") // From ContextWithHeight: if the provided height is 0, // it will return an empty context and the gRPC query will use @@ -572,13 +571,13 @@ func (e *PublicAPI) EstimateGas(args evmtypes.CallArgs) (hexutil.Uint64, error) // GetBlockByHash returns the block identified by hash. func (e *PublicAPI) GetBlockByHash(hash common.Hash, fullTx bool) (map[string]interface{}, error) { - e.logger.Debugln("eth_getBlockByHash", "hash", hash.Hex(), "full", fullTx) + e.logger.Debug("eth_getBlockByHash", "hash", hash.Hex(), "full", fullTx) return e.backend.GetBlockByHash(hash, fullTx) } // GetBlockByNumber returns the block identified by number. func (e *PublicAPI) GetBlockByNumber(ethBlockNum rpctypes.BlockNumber, fullTx bool) (map[string]interface{}, error) { - e.logger.Debugln("eth_getBlockByNumber", "number", ethBlockNum, "full", fullTx) + e.logger.Debug("eth_getBlockByNumber", "number", ethBlockNum, "full", fullTx) return e.backend.GetBlockByNumber(ethBlockNum, fullTx) } @@ -599,11 +598,11 @@ func (e *PublicAPI) GetTxByEthHash(hash common.Hash) (*tmrpctypes.ResultTx, erro // GetTransactionByHash returns the transaction identified by hash. func (e *PublicAPI) GetTransactionByHash(hash common.Hash) (*rpctypes.RPCTransaction, error) { - e.logger.Debugln("eth_getTransactionByHash", "hash", hash.Hex()) + e.logger.Debug("eth_getTransactionByHash", "hash", hash.Hex()) res, err := e.GetTxByEthHash(hash) if err != nil { - e.logger.WithError(err).Debugln("tx not found", "hash", hash.Hex()) + e.logger.Debug("tx not found", "hash", hash.Hex(), "error", err.Error()) // try to find tx in mempool txs, err := e.backend.PendingTransactions() @@ -634,19 +633,19 @@ func (e *PublicAPI) GetTransactionByHash(hash common.Hash) (*rpctypes.RPCTransac resBlock, err := e.clientCtx.Client.Block(e.ctx, &res.Height) if err != nil { - e.logger.WithError(err).Debugln("block not found", "height", res.Height) + e.logger.Debug("block not found", "height", res.Height, "error", err.Error()) return nil, nil } tx, err := e.clientCtx.TxConfig.TxDecoder()(res.Tx) if err != nil { - e.logger.WithError(err).Debugln("decoding failed") + e.logger.Debug("decoding failed", "error", err.Error()) return nil, fmt.Errorf("failed to decode tx: %w", err) } msg, err := evmtypes.UnwrapEthereumMsg(&tx) if err != nil { - e.logger.WithError(err).Debugln("invalid tx") + e.logger.Debug("invalid tx", "error", err.Error()) return nil, err } @@ -661,30 +660,30 @@ func (e *PublicAPI) GetTransactionByHash(hash common.Hash) (*rpctypes.RPCTransac // GetTransactionByBlockHashAndIndex returns the transaction identified by hash and index. func (e *PublicAPI) GetTransactionByBlockHashAndIndex(hash common.Hash, idx hexutil.Uint) (*rpctypes.RPCTransaction, error) { - e.logger.Debugln("eth_getTransactionByBlockHashAndIndex", "hash", hash.Hex(), "index", idx) + e.logger.Debug("eth_getTransactionByBlockHashAndIndex", "hash", hash.Hex(), "index", idx) resBlock, err := e.clientCtx.Client.BlockByHash(e.ctx, hash.Bytes()) if err != nil { - e.logger.WithError(err).Debugln("block not found", "hash", hash.Hex()) + e.logger.Debug("block not found", "hash", hash.Hex(), "error", err.Error()) return nil, nil } i := int(idx) if i >= len(resBlock.Block.Txs) { - e.logger.Debugln("block txs index out of bound", "index", i) + e.logger.Debug("block txs index out of bound", "index", i) return nil, nil } txBz := resBlock.Block.Txs[i] tx, err := e.clientCtx.TxConfig.TxDecoder()(txBz) if err != nil { - e.logger.WithError(err).Debugln("decoding failed") + e.logger.Debug("decoding failed", "error", err.Error()) return nil, fmt.Errorf("failed to decode tx: %w", err) } msg, err := evmtypes.UnwrapEthereumMsg(&tx) if err != nil { - e.logger.WithError(err).Debugln("invalid tx") + e.logger.Debug("invalid tx", "error", err.Error()) return nil, err } @@ -699,30 +698,30 @@ func (e *PublicAPI) GetTransactionByBlockHashAndIndex(hash common.Hash, idx hexu // GetTransactionByBlockNumberAndIndex returns the transaction identified by number and index. func (e *PublicAPI) GetTransactionByBlockNumberAndIndex(blockNum rpctypes.BlockNumber, idx hexutil.Uint) (*rpctypes.RPCTransaction, error) { - e.logger.Debugln("eth_getTransactionByBlockNumberAndIndex", "number", blockNum, "index", idx) + e.logger.Debug("eth_getTransactionByBlockNumberAndIndex", "number", blockNum, "index", idx) resBlock, err := e.clientCtx.Client.Block(e.ctx, blockNum.TmHeight()) if err != nil { - e.logger.WithError(err).Debugln("block not found", "height", blockNum.Int64()) + e.logger.Debug("block not found", "height", blockNum.Int64(), "error", err.Error()) return nil, nil } i := int(idx) if i >= len(resBlock.Block.Txs) { - e.logger.Debugln("block txs index out of bound", "index", i) + e.logger.Debug("block txs index out of bound", "index", i) return nil, nil } txBz := resBlock.Block.Txs[i] tx, err := e.clientCtx.TxConfig.TxDecoder()(txBz) if err != nil { - e.logger.WithError(err).Debugln("decoding failed") + e.logger.Debug("decoding failed", "error", err.Error()) return nil, fmt.Errorf("failed to decode tx: %w", err) } msg, err := evmtypes.UnwrapEthereumMsg(&tx) if err != nil { - e.logger.WithError(err).Debugln("invalid tx") + e.logger.Debug("invalid tx", "error", err.Error()) return nil, err } @@ -737,42 +736,42 @@ func (e *PublicAPI) GetTransactionByBlockNumberAndIndex(blockNum rpctypes.BlockN // GetTransactionReceipt returns the transaction receipt identified by hash. func (e *PublicAPI) GetTransactionReceipt(hash common.Hash) (map[string]interface{}, error) { - e.logger.Debugln("eth_getTransactionReceipt", "hash", hash.Hex()) + e.logger.Debug("eth_getTransactionReceipt", "hash", hash.Hex()) res, err := e.GetTxByEthHash(hash) if err != nil { - e.logger.WithError(err).Debugln("tx not found", "hash", hash.Hex()) + e.logger.Debug("tx not found", "hash", hash.Hex(), "error", err.Error()) return nil, nil } resBlock, err := e.clientCtx.Client.Block(e.ctx, &res.Height) if err != nil { - e.logger.WithError(err).Debugln("block not found", "height", res.Height) + e.logger.Debug("block not found", "height", res.Height, "error", err.Error()) return nil, nil } tx, err := e.clientCtx.TxConfig.TxDecoder()(res.Tx) if err != nil { - e.logger.WithError(err).Debugln("decoding failed") + e.logger.Debug("decoding failed", "error", err.Error()) return nil, fmt.Errorf("failed to decode tx: %w", err) } msg, err := evmtypes.UnwrapEthereumMsg(&tx) if err != nil { - e.logger.WithError(err).Debugln("invalid tx") + e.logger.Debug("invalid tx", "error", err.Error()) return nil, err } txData, err := evmtypes.UnpackTxData(msg.Data) if err != nil { - e.logger.WithError(err).Errorln("failed to unpack tx data") + e.logger.Error("failed to unpack tx data", "error", err.Error()) return nil, err } cumulativeGasUsed := uint64(0) blockRes, err := e.clientCtx.Client.BlockResults(e.ctx, &res.Height) if err != nil { - e.logger.WithError(err).Debugln("failed to retrieve block results", "height", res.Height) + e.logger.Debug("failed to retrieve block results", "height", res.Height, "error", err.Error()) return nil, nil } @@ -795,7 +794,7 @@ func (e *PublicAPI) GetTransactionReceipt(hash common.Hash) (map[string]interfac resLogs, err := e.queryClient.TxLogs(e.ctx, &evmtypes.QueryTxLogsRequest{Hash: hash.Hex()}) if err != nil { - e.logger.WithError(err).Debugln("logs not found", "hash", hash.Hex()) + e.logger.Debug("logs not found", "hash", hash.Hex(), "error", err.Error()) resLogs = &evmtypes.QueryTxLogsResponse{Logs: []*evmtypes.Log{}} } @@ -841,7 +840,7 @@ func (e *PublicAPI) GetTransactionReceipt(hash common.Hash) (map[string]interfac // PendingTransactions returns the transactions that are in the transaction pool // and have a from address that is one of the accounts this node manages. func (e *PublicAPI) PendingTransactions() ([]*rpctypes.RPCTransaction, error) { - e.logger.Debugln("eth_getPendingTransactions") + e.logger.Debug("eth_getPendingTransactions") txs, err := e.backend.PendingTransactions() if err != nil { @@ -886,7 +885,7 @@ func (e *PublicAPI) GetUncleByBlockNumberAndIndex(number hexutil.Uint, idx hexut // GetProof returns an account object with proof and any storage proofs func (e *PublicAPI) GetProof(address common.Address, storageKeys []string, blockNumber rpctypes.BlockNumber) (*rpctypes.AccountResult, error) { height := blockNumber.Int64() - e.logger.Debugln("eth_getProof", "address", address.Hex(), "keys", storageKeys, "number", height) + e.logger.Debug("eth_getProof", "address", address.Hex(), "keys", storageKeys, "number", height) ctx := rpctypes.ContextWithHeight(height) clientCtx := e.clientCtx.WithHeight(height) @@ -1011,7 +1010,7 @@ func (e *PublicAPI) setTxDefaults(args rpctypes.SendTxArgs) (rpctypes.SendTxArgs return args, err } args.Gas = &estimated - e.logger.Debugln("estimate gas usage automatically", "gas", args.Gas) + e.logger.Debug("estimate gas usage automatically", "gas", args.Gas) } if args.ChainID == nil { @@ -1046,7 +1045,7 @@ func (e *PublicAPI) getAccountNonce(accAddr common.Address, pending bool, height // to manually add them. pendingTxs, err := e.backend.PendingTransactions() if err != nil { - logger.WithError(err).Errorln("fails to fetch pending transactions") + logger.Error("failed to fetch pending transactions", "error", err.Error()) return nonce, nil } diff --git a/ethereum/rpc/namespaces/eth/filters/api.go b/ethereum/rpc/namespaces/eth/filters/api.go index b06471a3..f52ef5ec 100644 --- a/ethereum/rpc/namespaces/eth/filters/api.go +++ b/ethereum/rpc/namespaces/eth/filters/api.go @@ -8,7 +8,7 @@ import ( "github.com/tharsis/ethermint/ethereum/rpc/types" - log "github.com/xlab/suplog" + "github.com/tendermint/tendermint/libs/log" coretypes "github.com/tendermint/tendermint/rpc/core/types" rpcclient "github.com/tendermint/tendermint/rpc/jsonrpc/client" @@ -51,6 +51,7 @@ type filter struct { // PublicFilterAPI offers support to create and manage filters. This will allow external clients to retrieve various // information related to the Ethereum protocol such as blocks, transactions and logs. type PublicFilterAPI struct { + logger log.Logger backend Backend events *EventSystem filtersMu sync.Mutex @@ -58,11 +59,13 @@ type PublicFilterAPI struct { } // NewPublicAPI returns a new PublicFilterAPI instance. -func NewPublicAPI(tmWSClient *rpcclient.WSClient, backend Backend) *PublicFilterAPI { +func NewPublicAPI(logger log.Logger, tmWSClient *rpcclient.WSClient, backend Backend) *PublicFilterAPI { + logger = logger.With("api", "filter") api := &PublicFilterAPI{ + logger: logger, backend: backend, filters: make(map[rpc.ID]*filter), - events: NewEventSystem(tmWSClient), + events: NewEventSystem(logger, tmWSClient), } go api.timeoutLoop() @@ -125,10 +128,7 @@ func (api *PublicFilterAPI) NewPendingTransactionFilter() rpc.ID { data, ok := ev.Data.(tmtypes.EventDataTx) if !ok { - log.WithFields(log.Fields{ - "expected": "tmtypes.EventDataTx", - "actual": fmt.Sprintf("%T", ev.Data), - }).Warningln("event Data type mismatch") + api.logger.Debug("event data type mismatch", "type", fmt.Sprintf("%T", ev.Data)) continue } @@ -185,10 +185,7 @@ func (api *PublicFilterAPI) NewPendingTransactions(ctx context.Context) (*rpc.Su data, ok := ev.Data.(tmtypes.EventDataTx) if !ok { - log.WithFields(log.Fields{ - "expected": "tmtypes.EventDataTx", - "actual": fmt.Sprintf("%T", ev.Data), - }).Warningln("event Data type mismatch") + api.logger.Debug("event data type mismatch", "type", fmt.Sprintf("%T", ev.Data)) continue } @@ -243,10 +240,7 @@ func (api *PublicFilterAPI) NewBlockFilter() rpc.ID { data, ok := ev.Data.(tmtypes.EventDataNewBlockHeader) if !ok { - log.WithFields(log.Fields{ - "expected": "tmtypes.EventDataNewBlockHeader", - "actual": fmt.Sprintf("%T", ev.Data), - }).Warningln("event Data type mismatch") + api.logger.Debug("event data type mismatch", "type", fmt.Sprintf("%T", ev.Data)) continue } @@ -296,10 +290,7 @@ func (api *PublicFilterAPI) NewHeads(ctx context.Context) (*rpc.Subscription, er data, ok := ev.Data.(tmtypes.EventDataNewBlockHeader) if !ok { - log.WithFields(log.Fields{ - "expected": "tmtypes.EventDataNewBlockHeader", - "actual": fmt.Sprintf("%T", ev.Data), - }).Warningln("event Data type mismatch") + api.logger.Debug("event data type mismatch", "type", fmt.Sprintf("%T", ev.Data)) continue } @@ -359,10 +350,7 @@ func (api *PublicFilterAPI) Logs(ctx context.Context, crit filters.FilterCriteri // get transaction result data dataTx, ok := ev.Data.(tmtypes.EventDataTx) if !ok { - log.WithFields(log.Fields{ - "expected": "tmtypes.EventDataTx", - "actual": fmt.Sprintf("%T", ev.Data), - }).Warningln("event Data type mismatch") + api.logger.Debug("event data type mismatch", "type", fmt.Sprintf("%T", ev.Data)) continue } @@ -436,10 +424,7 @@ func (api *PublicFilterAPI) NewFilter(criteria filters.FilterCriteria) (rpc.ID, } dataTx, ok := ev.Data.(tmtypes.EventDataTx) if !ok { - log.WithFields(log.Fields{ - "expected": "tmtypes.EventDataTx", - "actual": fmt.Sprintf("%T", ev.Data), - }).Warningln("event Data type mismatch") + api.logger.Debug("event data type mismatch", "type", fmt.Sprintf("%T", ev.Data)) continue } @@ -474,7 +459,7 @@ func (api *PublicFilterAPI) GetLogs(ctx context.Context, crit filters.FilterCrit var filter *Filter if crit.BlockHash != nil { // Block filter requested, construct a single-shot filter - filter = NewBlockFilter(api.backend, crit) + filter = NewBlockFilter(api.logger, api.backend, crit) } else { // Convert the RPC block numbers into internal representations begin := rpc.LatestBlockNumber.Int64() @@ -486,7 +471,7 @@ func (api *PublicFilterAPI) GetLogs(ctx context.Context, crit filters.FilterCrit end = crit.ToBlock.Int64() } // Construct the range filter - filter = NewRangeFilter(api.backend, begin, end, crit.Addresses, crit.Topics) + filter = NewRangeFilter(api.logger, api.backend, begin, end, crit.Addresses, crit.Topics) } // Run the filter and return all the logs @@ -536,7 +521,7 @@ func (api *PublicFilterAPI) GetFilterLogs(ctx context.Context, id rpc.ID) ([]*et var filter *Filter if f.crit.BlockHash != nil { // Block filter requested, construct a single-shot filter - filter = NewBlockFilter(api.backend, f.crit) + filter = NewBlockFilter(api.logger, api.backend, f.crit) } else { // Convert the RPC block numbers into internal representations begin := rpc.LatestBlockNumber.Int64() @@ -548,7 +533,7 @@ func (api *PublicFilterAPI) GetFilterLogs(ctx context.Context, id rpc.ID) ([]*et end = f.crit.ToBlock.Int64() } // Construct the range filter - filter = NewRangeFilter(api.backend, begin, end, f.crit.Addresses, f.crit.Topics) + filter = NewRangeFilter(api.logger, api.backend, begin, end, f.crit.Addresses, f.crit.Topics) } // Run the filter and return all the logs logs, err := filter.Logs(ctx) diff --git a/ethereum/rpc/namespaces/eth/filters/filter_system.go b/ethereum/rpc/namespaces/eth/filters/filter_system.go index 2dd50abb..e1821fda 100644 --- a/ethereum/rpc/namespaces/eth/filters/filter_system.go +++ b/ethereum/rpc/namespaces/eth/filters/filter_system.go @@ -7,9 +7,9 @@ import ( "time" "github.com/pkg/errors" - log "github.com/xlab/suplog" tmjson "github.com/tendermint/tendermint/libs/json" + "github.com/tendermint/tendermint/libs/log" tmquery "github.com/tendermint/tendermint/libs/pubsub/query" coretypes "github.com/tendermint/tendermint/rpc/core/types" rpcclient "github.com/tendermint/tendermint/rpc/jsonrpc/client" @@ -35,6 +35,7 @@ var ( // EventSystem creates subscriptions, processes events and broadcasts them to the // subscription which match the subscription criteria using the Tendermint's RPC client. type EventSystem struct { + logger log.Logger ctx context.Context tmWSClient *rpcclient.WSClient @@ -57,13 +58,14 @@ type EventSystem struct { // // The returned manager has a loop that needs to be stopped with the Stop function // or by stopping the given mux. -func NewEventSystem(tmWSClient *rpcclient.WSClient) *EventSystem { +func NewEventSystem(logger log.Logger, tmWSClient *rpcclient.WSClient) *EventSystem { index := make(filterIndex) for i := filters.UnknownSubscription; i < filters.LastIndexSubscription; i++ { index[i] = make(map[rpc.ID]*Subscription) } es := &EventSystem{ + logger: logger, ctx: context.Background(), tmWSClient: tmWSClient, lightMode: false, @@ -222,7 +224,7 @@ func (es *EventSystem) eventLoop() { ch := make(chan coretypes.ResultEvent) es.topicChans[f.event] = ch if err := es.eventBus.AddTopic(f.event, ch); err != nil { - log.WithField("topic", f.event).WithError(err).Errorln("failed to add event topic to event bus") + es.logger.Error("failed to add event topic to event bus", "topic", f.event, "error", err.Error()) } es.indexMux.Unlock() close(f.installed) @@ -241,7 +243,7 @@ func (es *EventSystem) eventLoop() { // remove topic only when channel is not used by other subscriptions if !channelInUse { if err := es.tmWSClient.Unsubscribe(es.ctx, f.event); err != nil { - log.WithError(err).WithField("query", f.event).Errorln("failed to unsubscribe from query") + es.logger.Error("failed to unsubscribe from query", "query", f.event, "error", err.Error()) } ch, ok := es.topicChans[f.event] @@ -267,7 +269,7 @@ func (es *EventSystem) consumeEvents() { time.Sleep(5 * time.Second) continue } else if err := tmjson.Unmarshal(rpcResp.Result, &ev); err != nil { - log.WithError(err).Warningln("failed to JSON unmarshal ResponsesCh result event") + es.logger.Error("failed to JSON unmarshal ResponsesCh result event", "error", err.Error()) continue } @@ -280,8 +282,8 @@ func (es *EventSystem) consumeEvents() { ch, ok := es.topicChans[ev.Query] es.indexMux.RUnlock() if !ok { - log.WithField("topic", ev.Query).Warningln("channel for subscription not found, lol") - log.Infoln("available channels:", es.eventBus.Topics()) + es.logger.Debug("channel for subscription not found", "topic", ev.Query) + es.logger.Debug("list of available channels", "channels", es.eventBus.Topics()) continue } @@ -289,7 +291,7 @@ func (es *EventSystem) consumeEvents() { t := time.NewTimer(time.Second) select { case <-t.C: - log.WithField("topic", ev.Query).Warningln("dropped event during lagging subscription") + es.logger.Debug("dropped event during lagging subscription", "topic", ev.Query) case ch <- ev: } } diff --git a/ethereum/rpc/namespaces/eth/filters/filters.go b/ethereum/rpc/namespaces/eth/filters/filters.go index a3329625..3e7f6a7e 100644 --- a/ethereum/rpc/namespaces/eth/filters/filters.go +++ b/ethereum/rpc/namespaces/eth/filters/filters.go @@ -8,7 +8,7 @@ import ( "github.com/tharsis/ethermint/ethereum/rpc/types" "github.com/pkg/errors" - log "github.com/xlab/suplog" + "github.com/tendermint/tendermint/libs/log" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/bloombits" @@ -18,6 +18,7 @@ import ( // Filter can be used to retrieve and filter logs. type Filter struct { + logger log.Logger backend Backend criteria filters.FilterCriteria matcher *bloombits.Matcher @@ -25,14 +26,14 @@ type Filter struct { // NewBlockFilter creates a new filter which directly inspects the contents of // a block to figure out whether it is interesting or not. -func NewBlockFilter(backend Backend, criteria filters.FilterCriteria) *Filter { +func NewBlockFilter(logger log.Logger, backend Backend, criteria filters.FilterCriteria) *Filter { // Create a generic filter and convert it into a block filter - return newFilter(backend, criteria, nil) + return newFilter(logger, backend, criteria, nil) } // NewRangeFilter creates a new filter which uses a bloom filter on blocks to // figure out whether a particular block is interesting or not. -func NewRangeFilter(backend Backend, begin, end int64, addresses []common.Address, topics [][]common.Hash) *Filter { +func NewRangeFilter(logger log.Logger, backend Backend, begin, end int64, addresses []common.Address, topics [][]common.Hash) *Filter { // Flatten the address and topic filter clauses into a single bloombits filter // system. Since the bloombits are not positional, nil topics are permitted, // which get flattened into a nil byte slice. @@ -63,12 +64,13 @@ func NewRangeFilter(backend Backend, begin, end int64, addresses []common.Addres Topics: topics, } - return newFilter(backend, criteria, bloombits.NewMatcher(size, filtersBz)) + return newFilter(logger, backend, criteria, bloombits.NewMatcher(size, filtersBz)) } // newFilter returns a new Filter -func newFilter(backend Backend, criteria filters.FilterCriteria, matcher *bloombits.Matcher) *Filter { +func newFilter(logger log.Logger, backend Backend, criteria filters.FilterCriteria, matcher *bloombits.Matcher) *Filter { return &Filter{ + logger: logger, backend: backend, criteria: criteria, matcher: matcher, @@ -90,13 +92,11 @@ func (f *Filter) Logs(_ context.Context) ([]*ethtypes.Log, error) { if f.criteria.BlockHash != nil && *f.criteria.BlockHash != (common.Hash{}) { header, err := f.backend.HeaderByHash(*f.criteria.BlockHash) if err != nil { - err = errors.Wrap(err, "failed to fetch header by hash") - return nil, err + return nil, errors.Wrap(err, "failed to fetch header by hash") } if header == nil { - err := errors.Errorf("unknown block header %s", f.criteria.BlockHash.String()) - return nil, err + return nil, errors.Errorf("unknown block header %s", f.criteria.BlockHash.String()) } return f.blockLogs(header) @@ -105,12 +105,11 @@ func (f *Filter) Logs(_ context.Context) ([]*ethtypes.Log, error) { // Figure out the limits of the filter range header, err := f.backend.HeaderByNumber(types.EthLatestBlockNumber) if err != nil { - err = errors.Wrap(err, "failed to fetch header by number (latest)") - return nil, err + return nil, errors.Wrap(err, "failed to fetch header by number (latest)") } if header == nil || header.Number == nil { - log.Warningln("header not found or has no number") + f.logger.Debug("header not found or has no number") return nil, nil } @@ -123,8 +122,7 @@ func (f *Filter) Logs(_ context.Context) ([]*ethtypes.Log, error) { } if f.criteria.ToBlock.Int64()-f.criteria.FromBlock.Int64() > maxFilterBlocks { - err := errors.Errorf("maximum [from, to] blocks distance: %d", maxFilterBlocks) - return nil, err + return nil, errors.Errorf("maximum [from, to] blocks distance: %d", maxFilterBlocks) } // check bounds @@ -137,9 +135,10 @@ func (f *Filter) Logs(_ context.Context) ([]*ethtypes.Log, error) { for i := f.criteria.FromBlock.Int64(); i <= f.criteria.ToBlock.Int64(); i++ { block, err := f.backend.GetBlockByNumber(types.BlockNumber(i), false) if err != nil { - err = errors.Wrapf(err, "failed to fetch block by number %d", i) - return logs, err - } else if block["transactions"] == nil { + return logs, errors.Wrapf(err, "failed to fetch block by number %d", i) + } + + if block["transactions"] == nil { continue } @@ -147,28 +146,32 @@ func (f *Filter) Logs(_ context.Context) ([]*ethtypes.Log, error) { txs, ok := block["transactions"].([]interface{}) if !ok { - txHashes, ok = block["transactions"].([]common.Hash) + _, ok = block["transactions"].([]common.Hash) if !ok { - log.WithField( - "transactions", - fmt.Sprintf("%T", block["transactions"]), - ).Errorln("reading transactions from block data: bad field type") - continue + f.logger.Error( + "reading transactions from block data failed", + "type", fmt.Sprintf("%T", block["transactions"]), + ) } - } else if len(txs) == 0 && len(txHashes) == 0 { + + continue + } + + if len(txs) == 0 { continue } for _, tx := range txs { txHash, ok := tx.(common.Hash) if !ok { - log.WithField( - "tx", - fmt.Sprintf("%T", tx), - ).Errorln("transactions list contains non-hash element") - } else { - txHashes = append(txHashes, txHash) + f.logger.Error( + "transactions list contains non-hash element", + "type", fmt.Sprintf("%T", tx), + ) + continue } + + txHashes = append(txHashes, txHash) } logsMatched := f.checkMatches(txHashes) @@ -188,9 +191,7 @@ func (f *Filter) blockLogs(header *ethtypes.Header) ([]*ethtypes.Log, error) { // eth header's hash doesn't match tm block hash logsList, err := f.backend.GetLogsByNumber(types.BlockNumber(header.Number.Int64())) if err != nil { - err = errors.Wrapf(err, "failed to fetch logs block number %d", header.Number.Int64()) - - return []*ethtypes.Log{}, err + return []*ethtypes.Log{}, errors.Wrapf(err, "failed to fetch logs block number %d", header.Number.Int64()) } var unfiltered []*ethtypes.Log // nolint: prealloc diff --git a/ethereum/rpc/namespaces/personal/api.go b/ethereum/rpc/namespaces/personal/api.go index e4d42a40..1cdb1748 100644 --- a/ethereum/rpc/namespaces/personal/api.go +++ b/ethereum/rpc/namespaces/personal/api.go @@ -9,7 +9,7 @@ import ( "github.com/tharsis/ethermint/crypto/hd" ethermint "github.com/tharsis/ethermint/types" - log "github.com/xlab/suplog" + "github.com/tendermint/tendermint/libs/log" sdkcrypto "github.com/cosmos/cosmos-sdk/crypto" "github.com/cosmos/cosmos-sdk/crypto/keyring" @@ -32,10 +32,10 @@ type PrivateAccountAPI struct { } // NewAPI creates an instance of the public Personal Eth API. -func NewAPI(ethAPI *eth.PublicAPI) *PrivateAccountAPI { +func NewAPI(logger log.Logger, ethAPI *eth.PublicAPI) *PrivateAccountAPI { return &PrivateAccountAPI{ ethAPI: ethAPI, - logger: log.WithField("module", "personal"), + logger: logger.With("api", "personal"), } } @@ -96,7 +96,7 @@ func (api *PrivateAccountAPI) ListAccounts() ([]common.Address, error) { // LockAccount will lock the account associated with the given address when it's unlocked. // It removes the key corresponding to the given address from the API's local keys. func (api *PrivateAccountAPI) LockAccount(address common.Address) bool { // nolint: interfacer - api.logger.Debugln("personal_lockAccount", "address", address.String()) + api.logger.Debug("personal_lockAccount", "address", address.String()) api.logger.Info("personal_lockAccount not supported") // TODO: Not supported. See underlying issue https://github.com/99designs/keyring/issues/85 return false @@ -115,9 +115,9 @@ func (api *PrivateAccountAPI) NewAccount(password string) (common.Address, error } addr := common.BytesToAddress(info.GetPubKey().Address().Bytes()) - api.logger.Infoln("Your new key was generated", "address", addr.String()) - api.logger.Infoln("Please backup your key file!", "path", os.Getenv("HOME")+"/.ethermint/"+name) - api.logger.Infoln("Please remember your password!") + api.logger.Info("Your new key was generated", "address", addr.String()) + api.logger.Info("Please backup your key file!", "path", os.Getenv("HOME")+"/.ethermint/"+name) + api.logger.Info("Please remember your password!") return addr, nil } @@ -125,7 +125,7 @@ func (api *PrivateAccountAPI) NewAccount(password string) (common.Address, error // the given password for duration seconds. If duration is nil it will use a // default of 300 seconds. It returns an indication if the account was unlocked. func (api *PrivateAccountAPI) UnlockAccount(_ context.Context, addr common.Address, _ string, _ *uint64) (bool, error) { // nolint: interfacer - api.logger.Debugln("personal_unlockAccount", "address", addr.String()) + api.logger.Debug("personal_unlockAccount", "address", addr.String()) // TODO: Not supported. See underlying issue https://github.com/99designs/keyring/issues/85 return false, nil } @@ -154,7 +154,7 @@ func (api *PrivateAccountAPI) Sign(_ context.Context, data hexutil.Bytes, addr c sig, _, err := api.ethAPI.ClientCtx().Keyring.SignByAddress(cosmosAddr, accounts.TextHash(data)) if err != nil { - api.logger.WithError(err).Debugln("failed to sign with key", "data", data, "address", addr.String()) + api.logger.Error("failed to sign with key", "data", data, "address", addr.String(), "error", err.Error()) return nil, err } diff --git a/ethereum/rpc/namespaces/txpool/api.go b/ethereum/rpc/namespaces/txpool/api.go index 29894213..4e60cd18 100644 --- a/ethereum/rpc/namespaces/txpool/api.go +++ b/ethereum/rpc/namespaces/txpool/api.go @@ -1,9 +1,11 @@ package txpool import ( + "github.com/tendermint/tendermint/libs/log" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/tharsis/ethermint/ethereum/rpc/types" - log "github.com/xlab/suplog" ) // PublicAPI offers and API for the transaction pool. It only operates on data that is non-confidential. @@ -13,9 +15,9 @@ type PublicAPI struct { } // NewPublicAPI creates a new tx pool service that gives information about the transaction pool. -func NewPublicAPI() *PublicAPI { +func NewPublicAPI(logger log.Logger) *PublicAPI { return &PublicAPI{ - logger: log.WithField("module", "txpool"), + logger: logger.With("module", "txpool"), } } diff --git a/ethereum/rpc/websockets.go b/ethereum/rpc/websockets.go index d7fb5ae0..d9500e5c 100644 --- a/ethereum/rpc/websockets.go +++ b/ethereum/rpc/websockets.go @@ -9,22 +9,20 @@ import ( "net/http" "sync" - "github.com/ethereum/go-ethereum/eth/filters" - - rpcfilters "github.com/tharsis/ethermint/ethereum/rpc/namespaces/eth/filters" - "github.com/gorilla/mux" "github.com/gorilla/websocket" "github.com/pkg/errors" - log "github.com/xlab/suplog" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/eth/filters" + "github.com/ethereum/go-ethereum/rpc" + + "github.com/tendermint/tendermint/libs/log" coretypes "github.com/tendermint/tendermint/rpc/core/types" rpcclient "github.com/tendermint/tendermint/rpc/jsonrpc/client" tmtypes "github.com/tendermint/tendermint/types" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/rpc" - + rpcfilters "github.com/tharsis/ethermint/ethereum/rpc/namespaces/eth/filters" "github.com/tharsis/ethermint/ethereum/rpc/types" evmtypes "github.com/tharsis/ethermint/x/evm/types" ) @@ -68,12 +66,13 @@ type websocketsServer struct { logger log.Logger } -func NewWebsocketsServer(tmWSClient *rpcclient.WSClient, rpcAddr, wsAddr string) WebsocketsServer { +func NewWebsocketsServer(logger log.Logger, tmWSClient *rpcclient.WSClient, rpcAddr, wsAddr string) WebsocketsServer { + logger = logger.With("module", "websocket-server") return &websocketsServer{ rpcAddr: rpcAddr, wsAddr: wsAddr, - api: newPubSubAPI(tmWSClient), - logger: log.WithField("module", "websocket-server"), + api: newPubSubAPI(logger, tmWSClient), + logger: logger, } } @@ -88,7 +87,7 @@ func (s *websocketsServer) Start() { return } - s.logger.WithError(err).Errorln("failed to start HTTP server for WS") + s.logger.Error("failed to start HTTP server for WS", "error", err.Error()) } }() } @@ -102,7 +101,7 @@ func (s *websocketsServer) ServeHTTP(w http.ResponseWriter, r *http.Request) { conn, err := upgrader.Upgrade(w, r, nil) if err != nil { - s.logger.WithError(err).Warningln("websocket upgrade failed") + s.logger.Debug("websocket upgrade failed", "error", err.Error()) return } @@ -280,12 +279,13 @@ type pubSubAPI struct { } // newPubSubAPI creates an instance of the ethereum PubSub API. -func newPubSubAPI(tmWSClient *rpcclient.WSClient) *pubSubAPI { +func newPubSubAPI(logger log.Logger, tmWSClient *rpcclient.WSClient) *pubSubAPI { + logger = logger.With("module", "websocket-client") return &pubSubAPI{ - events: rpcfilters.NewEventSystem(tmWSClient), + events: rpcfilters.NewEventSystem(logger, tmWSClient), filtersMu: new(sync.RWMutex), filters: make(map[rpc.ID]*wsSubscription), - logger: log.WithField("module", "websocket-client"), + logger: logger, } } @@ -358,10 +358,7 @@ func (api *pubSubAPI) subscribeNewHeads(wsConn *wsConn) (rpc.ID, error) { data, ok := event.Data.(tmtypes.EventDataNewBlockHeader) if !ok { - log.WithFields(log.Fields{ - "expected": "tmtypes.EventDataNewBlockHeader", - "actual": fmt.Sprintf("%T", event.Data), - }).Warningln("event Data type mismatch") + api.logger.Debug("event data type mismatch", "type", fmt.Sprintf("%T", event.Data)) continue } @@ -386,7 +383,7 @@ func (api *pubSubAPI) subscribeNewHeads(wsConn *wsConn) (rpc.ID, error) { err = wsSub.wsConn.WriteJSON(res) if err != nil { - api.logger.WithError(err).Error("error writing header, will drop peer") + api.logger.Error("error writing header, will drop peer", "error", err.Error()) try(func() { api.filtersMu.RUnlock() @@ -411,7 +408,7 @@ func (api *pubSubAPI) subscribeNewHeads(wsConn *wsConn) (rpc.ID, error) { api.unsubscribe(subID) return } - log.WithError(err).Debugln("dropping NewHeads WebSocket subscription", subID) + api.logger.Debug("dropping NewHeads WebSocket subscription", "subscription-id", subID, "error", err.Error()) api.unsubscribe(subID) case <-unsubscribed: return @@ -423,20 +420,15 @@ func (api *pubSubAPI) subscribeNewHeads(wsConn *wsConn) (rpc.ID, error) { } func try(fn func(), l log.Logger, desc string) { - if l == nil { - l = log.DefaultLogger - } - defer func() { if x := recover(); x != nil { if err, ok := x.(error); ok { // debug.PrintStack() - l.WithError(err).Debugln("panic during", desc) + l.Debug("panic during "+desc, "error", err.Error()) return } - // debug.PrintStack() - l.Debugf("panic during %s: %+v", desc, x) + l.Debug(fmt.Sprintf("panic during %s: %+v", desc, x)) return } }() @@ -451,9 +443,7 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID, params, ok := extra.(map[string]interface{}) if !ok { err := errors.New("invalid criteria") - log.WithFields(log.Fields{ - "criteria": fmt.Sprintf("expected: map[string]interface{}, got %T", extra), - }).Errorln(err) + api.logger.Debug("invalid criteria", "type", fmt.Sprintf("%T", extra)) return "", err } @@ -461,12 +451,8 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID, address, ok := params["address"].(string) addresses, sok := params["address"].([]interface{}) if !ok && !sok { - err := errors.New("invalid address; must be address or array of addresses") - log.WithFields(log.Fields{ - "address": ok, - "addresses": sok, - "type": fmt.Sprintf("%T", params["address"]), - }).Errorln(err) + err := errors.New("invalid addresses; must be address or array of addresses") + api.logger.Debug("invalid addresses", "type", fmt.Sprintf("%T", params["address"])) return "", err } @@ -480,7 +466,7 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID, address, ok := addr.(string) if !ok { err := errors.New("invalid address") - log.WithField("type", fmt.Sprintf("%T", addr)).Errorln(err) + api.logger.Debug("invalid address", "type", fmt.Sprintf("%T", addr)) return "", err } @@ -492,12 +478,8 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID, if params["topics"] != nil { topics, ok := params["topics"].([]interface{}) if !ok { - err := errors.New("invalid topics") - - log.WithFields(log.Fields{ - "type": fmt.Sprintf("expected []interface{}, got %T", params["topics"]), - }).Errorln(err) - + err := errors.Errorf("invalid topics: %s", topics) + api.logger.Error("invalid topics", "type", fmt.Sprintf("%T", topics)) return "", err } @@ -507,7 +489,7 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID, tstr, ok := topic.(string) if !ok { err := errors.Errorf("invalid topic: %s", topic) - log.WithField("type", fmt.Sprintf("expected string, got %T", topic)).Errorln(err) + api.logger.Error("invalid topic", "type", fmt.Sprintf("%T", topic)) return err } @@ -533,11 +515,7 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID, subtopicsList, ok := subtopics.([]interface{}) if !ok { err := errors.New("invalid subtopics") - - log.WithFields(log.Fields{ - "type": fmt.Sprintf("expected []interface{}, got %T", subtopics), - }).Errorln(err) - + api.logger.Error("invalid subtopic", "type", fmt.Sprintf("%T", subtopics)) return "", err } @@ -546,7 +524,7 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID, tstr, ok := subtopic.(string) if !ok { err := errors.Errorf("invalid subtopic: %s", subtopic) - log.WithField("type", fmt.Sprintf("expected string, got %T", subtopic)).Errorln(err) + api.logger.Error("invalid subtopic", "type", fmt.Sprintf("%T", subtopic)) return "", err } @@ -560,7 +538,7 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID, critBz, err := json.Marshal(crit) if err != nil { - log.WithError(err).Errorln("failed to JSON marshal criteria") + api.logger.Error("failed to JSON marshal criteria", "error", err.Error()) return rpc.ID(""), err } @@ -569,7 +547,7 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID, sub, _, err := api.events.SubscribeLogs(crit) if err != nil { - log.WithError(err).Errorln("failed to subscribe logs") + api.logger.Error("failed to subscribe logs", "error", err.Error()) return rpc.ID(""), err } @@ -594,16 +572,13 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID, dataTx, ok := event.Data.(tmtypes.EventDataTx) if !ok { - log.WithFields(log.Fields{ - "expected": "tmtypes.EventDataTx", - "actual": fmt.Sprintf("%T", event.Data), - }).Warningln("event Data type mismatch") + api.logger.Debug("event data type mismatch", "type", fmt.Sprintf("%T", event.Data)) continue } txResponse, err := evmtypes.DecodeTxResponse(dataTx.TxResult.Result.Data) if err != nil { - log.WithError(err).Errorln("failed to decode tx response") + api.logger.Error("failed to decode tx response", "error", err.Error()) return } @@ -615,7 +590,7 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID, api.filtersMu.RLock() wsSub, ok := api.filters[subID] if !ok { - log.Warningln("subID not in filters", subID) + api.logger.Debug("subID not in filters", subID) return } api.filtersMu.RUnlock() @@ -650,7 +625,7 @@ func (api *pubSubAPI) subscribeLogs(wsConn *wsConn, extra interface{}) (rpc.ID, api.unsubscribe(subID) return } - log.WithError(err).Warningln("dropping Logs WebSocket subscription", subID) + api.logger.Debug("dropping Logs WebSocket subscription", "subscription-id", subID, "error", err.Error()) api.unsubscribe(subID) case <-unsubscribed: return @@ -706,7 +681,7 @@ func (api *pubSubAPI) subscribePendingTransactions(wsConn *wsConn) (rpc.ID, erro err = wsSub.wsConn.WriteJSON(res) if err != nil { - api.logger.WithError(err).Warningln("error writing header, will drop peer") + api.logger.Debug("error writing header, will drop peer", "error", err.Error()) try(func() { api.filtersMu.Lock() @@ -727,7 +702,7 @@ func (api *pubSubAPI) subscribePendingTransactions(wsConn *wsConn) (rpc.ID, erro api.unsubscribe(subID) return } - log.WithError(err).Warningln("dropping PendingTransactions WebSocket subscription", subID) + api.logger.Debug("dropping PendingTransactions WebSocket subscription", subID, "error", err.Error()) api.unsubscribe(subID) case <-unsubscribed: return diff --git a/server/start.go b/server/start.go index 1364dce7..e1ce90f7 100644 --- a/server/start.go +++ b/server/start.go @@ -15,7 +15,6 @@ import ( "github.com/rs/cors" "github.com/spf13/cobra" "github.com/xlab/closer" - log "github.com/xlab/suplog" "google.golang.org/grpc" tcmd "github.com/tendermint/tendermint/cmd/tendermint/commands" @@ -168,17 +167,18 @@ which accepts a path for the resulting pprof file. func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator types.AppCreator) error { cfg := ctx.Config home := cfg.RootDir + logger := ctx.Logger traceWriterFile := ctx.Viper.GetString(flagTraceStore) db, err := openDB(home) if err != nil { - log.WithError(err).Errorln("failed to open DB") + logger.Error("failed to open DB", "error", err.Error()) return err } traceWriter, err := openTraceWriter(traceWriterFile) if err != nil { - log.WithError(err).Errorln("failed to open trace writer") + logger.Error("failed to open trace writer", "error", err.Error()) return err } @@ -186,7 +186,7 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty nodeKey, err := p2p.LoadOrGenNodeKey(cfg.NodeKeyFile()) if err != nil { - log.WithError(err).Errorln("failed load or gen node key") + logger.Error("failed load or gen node key", "error", err.Error()) return err } @@ -202,12 +202,12 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty ctx.Logger.With("module", "node"), ) if err != nil { - log.WithError(err).Errorln("failed init node") + logger.Error("failed init node", "error", err.Error()) return err } if err := tmNode.Start(); err != nil { - log.WithError(err).Errorln("failed start tendermint server") + logger.Error("failed start tendermint server", "error", err.Error()) return err } @@ -228,7 +228,7 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty if config.GRPC.Enable { grpcSrv, err = servergrpc.StartGRPCServer(clientCtx, app, config.GRPC.Address) if err != nil { - log.WithError(err).Errorln("failed to boot GRPC server") + logger.Error("failed to boot GRPC server", "error", err.Error()) return err } } @@ -241,18 +241,19 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty if config.EVMRPC.Enable { tmEndpoint := "/websocket" tmRPCAddr := cfg.RPC.ListenAddress - log.Infoln("EVM RPC Connecting to Tendermint WebSocket at", tmRPCAddr+tmEndpoint) + logger.Info("EVM RPC Connecting to Tendermint WebSocket at", tmRPCAddr+tmEndpoint) tmWsClient := ConnectTmWS(tmRPCAddr, tmEndpoint) rpcServer := ethrpc.NewServer() - apis := rpc.GetRPCAPIs(clientCtx, tmWsClient) + apis := rpc.GetRPCAPIs(ctx, clientCtx, tmWsClient) for _, api := range apis { if err := rpcServer.RegisterName(api.Namespace, api.Service); err != nil { - log.WithFields(log.Fields{ - "namespace": api.Namespace, - "service": api.Service, - }).WithError(err).Fatalln("failed to register service in EVM RPC namespace") + logger.Error( + "failed to register service in EVM RPC namespace", + "namespace", api.Namespace, + "service", api.Service, + ) return err } } @@ -286,31 +287,31 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty errCh := make(chan error) go func() { - log.Infoln("Starting EVM RPC server on", config.EVMRPC.RPCAddress) + logger.Info("Starting EVM RPC server", "address", config.EVMRPC.RPCAddress) if err := httpSrv.ListenAndServe(); err != nil { if err == http.ErrServerClosed { close(httpSrvDone) return } - log.WithError(err).Errorln("failed to start EVM RPC server") + logger.Error("failed to start EVM RPC server", "error", err.Error()) errCh <- err } }() select { case err := <-errCh: - log.WithError(err).Errorln("failed to boot EVM RPC server") + logger.Error("failed to boot EVM RPC server", "error", err.Error()) return err case <-time.After(1 * time.Second): // assume EVM RPC server started successfully } - log.Infoln("Starting EVM WebSocket server on", config.EVMRPC.WsAddress) + logger.Info("Starting EVM WebSocket server", "address", config.EVMRPC.WsAddress) _, port, _ := net.SplitHostPort(config.EVMRPC.RPCAddress) // allocate separate WS connection to Tendermint tmWsClient = ConnectTmWS(tmRPCAddr, tmEndpoint) - wsSrv = rpc.NewWebsocketsServer(tmWsClient, "localhost:"+port, config.EVMRPC.WsAddress) + wsSrv = rpc.NewWebsocketsServer(logger, tmWsClient, "localhost:"+port, config.EVMRPC.WsAddress) go wsSrv.Start() } @@ -329,7 +330,7 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty select { case err := <-errCh: - log.WithError(err).Errorln("failed to boot API server") + logger.Error("failed to boot API server", "error", err.Error()) return err case <-time.After(5 * time.Second): // assume server started successfully } @@ -340,17 +341,17 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty if cpuProfile := ctx.Viper.GetString(flagCPUProfile); cpuProfile != "" { f, err := os.Create(cpuProfile) if err != nil { - log.WithError(err).Errorln("failed to create CP profile") + logger.Error("failed to create CP profile", "error", err.Error()) return err } - log.WithField("profile", cpuProfile).Infoln("starting CPU profiler") + logger.Info("starting CPU profiler", "profile", cpuProfile) if err := pprof.StartCPUProfile(f); err != nil { return err } cpuProfileCleanup = func() { - log.WithField("profile", cpuProfile).Infoln("stopping CPU profiler") + logger.Info("stopping CPU profiler", "profile", cpuProfile) pprof.StopCPUProfile() f.Close() } @@ -370,9 +371,9 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty defer cancelFn() if err := httpSrv.Shutdown(shutdownCtx); err != nil { - log.WithError(err).Warningln("HTTP server shutdown produced a warning") + logger.Error("HTTP server shutdown produced a warning", "error", err.Error()) } else { - log.Infoln("HTTP server shut down, waiting 5 sec") + logger.Info("HTTP server shut down, waiting 5 sec") select { case <-time.Tick(5 * time.Second): case <-httpSrvDone: @@ -384,7 +385,7 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty grpcSrv.Stop() } - log.Infoln("Bye!") + logger.Info("Bye!") }) closer.Hold() diff --git a/tests/solidity/init-test-node.sh b/tests/solidity/init-test-node.sh index 3d426f57..b742b7ef 100755 --- a/tests/solidity/init-test-node.sh +++ b/tests/solidity/init-test-node.sh @@ -40,4 +40,4 @@ ethermintd collect-gentxs ethermintd validate-genesis # Start the node (remove the --pruning=nothing flag if historical queries are not needed) -ethermintd start --pruning=nothing --rpc.unsafe --keyring-backend test --trace --log_level "info" +ethermintd start --pruning=nothing --rpc.unsafe --keyring-backend test --trace --log_level info diff --git a/testutil/network/util.go b/testutil/network/util.go index 10f83a3b..b49e3671 100644 --- a/testutil/network/util.go +++ b/testutil/network/util.go @@ -121,7 +121,7 @@ func startInProcess(cfg Config, val *Validator) error { val.jsonRPC = jsonrpc.NewServer() - apis := rpc.GetRPCAPIs(val.ClientCtx, tmWsClient) + apis := rpc.GetRPCAPIs(val.Ctx, val.ClientCtx, tmWsClient) for _, api := range apis { if err := val.jsonRPC.RegisterName(api.Namespace, api.Service); err != nil { return fmt.Errorf("failed to register JSON-RPC namespace %s: %w", api.Namespace, err)