From 85e3d29e0591a06961042bcab7a8e87315f778a2 Mon Sep 17 00:00:00 2001 From: Dongri Jin Date: Wed, 19 Jul 2023 10:24:19 +0900 Subject: [PATCH] Change Error, Info to Errorw, Infow Signed-off-by: Dongri Jin --- cmd/query.go | 32 +++- core/channel.go | 82 ++++++--- core/client.go | 109 ++++++++---- core/config.go | 37 ++-- core/connection.go | 135 ++++++++++---- core/headers.go | 37 ++-- core/naive-strategy.go | 389 +++++++++++++++++++++++++++++------------ core/packet-tx.go | 32 +++- core/relayMsgs.go | 13 +- core/service.go | 33 ++-- logger/zap.go | 111 +++++++++++- 11 files changed, 739 insertions(+), 271 deletions(-) diff --git a/cmd/query.go b/cmd/query.go index ee06cfbd..516a76b9 100644 --- a/cmd/query.go +++ b/cmd/query.go @@ -14,7 +14,6 @@ import ( "github.com/hyperledger-labs/yui-relayer/helpers" "github.com/hyperledger-labs/yui-relayer/logger" "github.com/spf13/cobra" - "go.uber.org/zap" ) // queryCmd represents the chain command @@ -180,8 +179,8 @@ func queryBalanceCmd(ctx *config.Context) *cobra.Command { } func queryUnrelayedPackets(ctx *config.Context) *cobra.Command { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() cmd := &cobra.Command{ Use: "unrelayed-packets [path]", Short: "Query for the packet sequence numbers that remain to be relayed on a given path", @@ -209,11 +208,11 @@ func queryUnrelayedPackets(ctx *config.Context) *cobra.Command { } out, err := json.Marshal(sp) if err != nil { - logger.Error("failed to marshal sequences", zap.Any("sp", sp), zap.Error(err)) + queryErrorw(zapLogger, "failed to marshal sequences", err) return err } - logger.Info("unrelayed sequences", zap.String("sequences", string(out))) + fmt.Println(string(out)) return nil }, } @@ -222,8 +221,8 @@ func queryUnrelayedPackets(ctx *config.Context) *cobra.Command { } func queryUnrelayedAcknowledgements(ctx *config.Context) *cobra.Command { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() cmd := &cobra.Command{ Use: "unrelayed-acknowledgements [path]", Short: "Query for the packet sequence numbers that remain to be relayed on a given path", @@ -253,14 +252,29 @@ func queryUnrelayedAcknowledgements(ctx *config.Context) *cobra.Command { out, err := json.Marshal(sp) if err != nil { - logger.Error("failed to marshal sequences", zap.Any("sp", sp), zap.Error(err)) + queryErrorw(zapLogger, "failed to marshal sequences", err) return err } - logger.Info("unrelayed acknowledgements", zap.String("acknowledgements", string(out))) + queryInfow(zapLogger, "unrelayed acknowledgements", fmt.Sprintf("acknowledgements %s", string(out))) return nil }, } return cmd } + +func queryErrorw(zapLogger *logger.ZapLogger, msg string, err error) { + zapLogger.Errorw( + msg, + err, + "core.query", + ) +} + +func queryInfow(zapLogger *logger.ZapLogger, msg string, info string) { + zapLogger.Infow( + msg, + info, + ) +} diff --git a/core/channel.go b/core/channel.go index a62e385b..8c2eebda 100644 --- a/core/channel.go +++ b/core/channel.go @@ -7,14 +7,13 @@ import ( retry "github.com/avast/retry-go" chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" "github.com/hyperledger-labs/yui-relayer/logger" - "go.uber.org/zap" ) // CreateChannel runs the channel creation messages on timeout until they pass // TODO: add max retries or something to this function func CreateChannel(src, dst *ProvableChain, ordered bool, to time.Duration) error { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() var order chantypes.Order if ordered { order = chantypes.ORDERED @@ -27,10 +26,12 @@ func CreateChannel(src, dst *ProvableChain, ordered bool, to time.Duration) erro for ; true; <-ticker.C { chanSteps, err := createChannelStep(src, dst, order) if err != nil { - logger.Error(fmt.Sprintf("failed to create channel step: [%s]chan{%s}port{%s} -> [%s]chan{%s}port{%s}", - src.ChainID(), src.Path().ChannelID, src.Path().PortID, - dst.ChainID(), dst.Path().ChannelID, dst.Path().PortID), - zap.Error(err)) + channelErrorw( + zapLogger, + "failed to create channel step", + src, dst, + err, + ) return err } @@ -44,9 +45,11 @@ func CreateChannel(src, dst *ProvableChain, ordered bool, to time.Duration) erro // In the case of success and this being the last transaction // debug logging, log created connection and break case chanSteps.Success() && chanSteps.Last: - logger.Info(fmt.Sprintf("★ Channel created: [%s]chan{%s}port{%s} -> [%s]chan{%s}port{%s}", - src.ChainID(), src.Path().ChannelID, src.Path().PortID, - dst.ChainID(), dst.Path().ChannelID, dst.Path().PortID)) + channnelInfowChannel( + zapLogger, + "★ Channel created", + src, dst, + ) return nil // In the case of success, reset the failures counter case chanSteps.Success(): @@ -55,15 +58,19 @@ func CreateChannel(src, dst *ProvableChain, ordered bool, to time.Duration) erro // In the case of failure, increment the failures counter and exit if this is the 3rd failure case !chanSteps.Success(): failures++ - logger.Info("retrying transaction...") + zapLogger.Zap.Info("retrying transaction...") time.Sleep(5 * time.Second) if failures > 2 { - logger.Error(fmt.Sprintf("! Channel failed: [%s]chan{%s}port{%s} -> [%s]chan{%s}port{%s}", - src.ChainID(), src.Path().ChannelID, src.Path().PortID, - dst.ChainID(), dst.Path().ChannelID, dst.Path().PortID)) + channelErrorw( + zapLogger, + "! Channel failed", + src, dst, + err, + ) return fmt.Errorf("! Channel failed: [%s]chan{%s}port{%s} -> [%s]chan{%s}port{%s}", src.ChainID(), src.Path().ClientID, src.Path().ChannelID, - dst.ChainID(), dst.Path().ClientID, dst.Path().ChannelID) + dst.ChainID(), dst.Path().ClientID, dst.Path().ChannelID, + ) } } } @@ -174,16 +181,37 @@ func createChannelStep(src, dst *ProvableChain, ordering chantypes.Order) (*Rela } func logChannelStates(src, dst Chain, srcChan, dstChan *chantypes.QueryChannelResponse) { - logger := logger.ZapLogger() - defer logger.Sync() - logger.Info(fmt.Sprintf("- [%s]@{%d}chan(%s)-{%s} : [%s]@{%d}chan(%s)-{%s}", - src.ChainID(), - mustGetHeight(srcChan.ProofHeight), - src.Path().ChannelID, - srcChan.Channel.State, - dst.ChainID(), - mustGetHeight(dstChan.ProofHeight), - dst.Path().ChannelID, - dstChan.Channel.State, - )) + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() + zapLogger.InfowChannel( + "channel states", + src.ChainID(), src.Path().ChannelID, src.Path().PortID, + dst.ChainID(), dst.Path().ChannelID, dst.Path().PortID, + fmt.Sprintf( + "src channel height: [%d] state: %s | dst channel height: [%d] state: %s", + mustGetHeight(srcChan.ProofHeight), + srcChan.Channel.State, + mustGetHeight(dstChan.ProofHeight), + dstChan.Channel.State, + ), + ) +} + +func channelErrorw(zapLogger *logger.ZapLogger, msg string, src, dst *ProvableChain, err error) { + zapLogger.ErrorwChannel( + msg, + src.ChainID(), src.Path().ChannelID, src.Path().PortID, + dst.ChainID(), dst.Path().ChannelID, dst.Path().PortID, + err, + "core.channel", + ) +} + +func channnelInfowChannel(zapLogger *logger.ZapLogger, msg string, src, dst *ProvableChain) { + zapLogger.InfowChannel( + msg, + src.ChainID(), src.Path().ChannelID, src.Path().PortID, + dst.ChainID(), dst.Path().ChannelID, dst.Path().PortID, + "", + ) } diff --git a/core/client.go b/core/client.go index 37d4d5d1..27d81996 100644 --- a/core/client.go +++ b/core/client.go @@ -1,48 +1,60 @@ package core import ( - "fmt" - sdk "github.com/cosmos/cosmos-sdk/types" "github.com/hyperledger-labs/yui-relayer/logger" - "go.uber.org/zap" "golang.org/x/sync/errgroup" ) func CreateClients(src, dst *ProvableChain) error { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() + var ( clients = &RelayMsgs{Src: []sdk.Msg{}, Dst: []sdk.Msg{}} ) srcH, dstH, err := getHeadersForCreateClient(src, dst) if err != nil { - logger.Error(fmt.Sprintf("failed to get headers for create client [%s]chan{%s}port{%s} -> [%s]chan{%s}port{%s}", - src.ChainID(), src.Path().ChannelID, src.Path().PortID, - dst.ChainID(), dst.Path().ChannelID, dst.Path().PortID), - zap.Error(err)) + clientErrorwChannel( + zapLogger, + "failed to get headers for create client", + src, dst, + err, + ) return err } srcAddr, err := src.GetAddress() if err != nil { - logger.Error(fmt.Sprintf("failed to get address for create client [src: %s]", src.ChainID()), zap.Error(err)) + clientErrorwChannel( + zapLogger, + "failed to get address for create client", + src, dst, + err, + ) return err } dstAddr, err := dst.GetAddress() if err != nil { - logger.Error(fmt.Sprintf("failed to get address for create client [dst: %s]", dst.ChainID()), zap.Error(err)) + clientErrorwChannel( + zapLogger, + "failed to get address for create client", + src, dst, + err, + ) return err } { msg, err := dst.CreateMsgCreateClient(src.Path().ClientID, dstH, srcAddr) if err != nil { - logger.Error(fmt.Sprintf("failed to create client on dst chain [%s]chan{%s}port{%s} -> [%s]chan{%s}port{%s}", - src.ChainID(), src.Path().ChannelID, src.Path().PortID, - dst.ChainID(), dst.Path().ChannelID, dst.Path().PortID), - zap.Error(err)) + clientErrorwChannel( + zapLogger, + "failed to create client", + src, dst, + err, + ) return err } clients.Src = append(clients.Src, msg) @@ -51,10 +63,12 @@ func CreateClients(src, dst *ProvableChain) error { { msg, err := src.CreateMsgCreateClient(dst.Path().ClientID, srcH, dstAddr) if err != nil { - logger.Error(fmt.Sprintf("failed to create client on src chain [%s]chan{%s}port{%s} -> [%s]chan{%s}port{%s}", - src.ChainID(), src.Path().ChannelID, src.Path().PortID, - dst.ChainID(), dst.Path().ChannelID, dst.Path().PortID), - zap.Error(err)) + clientErrorwChannel( + zapLogger, + "failed to create client", + src, dst, + err, + ) return err } clients.Dst = append(clients.Dst, msg) @@ -64,34 +78,41 @@ func CreateClients(src, dst *ProvableChain) error { if clients.Ready() { // TODO: Add retry here for out of gas or other errors if clients.Send(src, dst); clients.Success() { - logger.Info(fmt.Sprintf("★ Clients created: [%s]client(%s) and [%s]client(%s)", - src.ChainID(), src.Path().ClientID, dst.ChainID(), dst.Path().ClientID)) + clientInfowChannel( + zapLogger, + "★ Clients created", + src, dst, + ) } } return nil } func UpdateClients(src, dst *ProvableChain) error { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() var ( clients = &RelayMsgs{Src: []sdk.Msg{}, Dst: []sdk.Msg{}} ) // First, update the light clients to the latest header and return the header sh, err := NewSyncHeaders(src, dst) if err != nil { - logger.Error(fmt.Sprintf("failed to create sync headers for update client [%s]chan{%s}port{%s} -> [%s]chan{%s}port{%s}", - src.ChainID(), src.Path().ChannelID, src.Path().PortID, - dst.ChainID(), dst.Path().ChannelID, dst.Path().PortID), - zap.Error(err)) + clientErrorwChannel( + zapLogger, + "failed to create sync headers for update client", + src, dst, + err, + ) return err } srcUpdateHeaders, dstUpdateHeaders, err := sh.SetupBothHeadersForUpdate(src, dst) if err != nil { - logger.Error(fmt.Sprintf("failed to setup both headers for update client [%s]chan{%s}port{%s} -> [%s]chan{%s}port{%s}", - src.ChainID(), src.Path().ChannelID, src.Path().PortID, - dst.ChainID(), dst.Path().ChannelID, dst.Path().PortID), - zap.Error(err)) + clientErrorwChannel( + zapLogger, + "failed to setup both headers for update client", + src, dst, + err, + ) return err } if len(dstUpdateHeaders) > 0 { @@ -103,8 +124,11 @@ func UpdateClients(src, dst *ProvableChain) error { // Send msgs to both chains if clients.Ready() { if clients.Send(src, dst); clients.Success() { - logger.Info(fmt.Sprintf("★ Clients updated: [%s]client(%s) and [%s]client(%s)", - src.ChainID(), src.Path().ClientID, dst.ChainID(), dst.Path().ClientID)) + clientInfowChannel( + zapLogger, + "★ Clients updated", + src, dst, + ) } } return nil @@ -126,3 +150,22 @@ func getHeadersForCreateClient(src, dst LightClient) (srch, dsth Header, err err } return srch, dsth, nil } + +func clientErrorwChannel(zapLogger *logger.ZapLogger, msg string, src, dst *ProvableChain, err error) { + zapLogger.ErrorwChannel( + msg, + src.ChainID(), src.Path().ChannelID, src.Path().PortID, + dst.ChainID(), dst.Path().ChannelID, dst.Path().PortID, + err, + "core.client", + ) +} + +func clientInfowChannel(zapLogger *logger.ZapLogger, msg string, src, dst *ProvableChain) { + zapLogger.InfowChannel( + msg, + src.ChainID(), src.Path().ChannelID, src.Path().PortID, + dst.ChainID(), dst.Path().ChannelID, dst.Path().PortID, + "", + ) +} diff --git a/core/config.go b/core/config.go index 54302818..f7147303 100644 --- a/core/config.go +++ b/core/config.go @@ -8,7 +8,6 @@ import ( "github.com/cosmos/gogoproto/proto" "github.com/hyperledger-labs/yui-relayer/logger" "github.com/hyperledger-labs/yui-relayer/utils" - "go.uber.org/zap" ) // ChainProverConfig defines the top level configuration for a chain instance @@ -35,16 +34,16 @@ type ProverConfig interface { // NewChainProverConfig returns a new config instance func NewChainProverConfig(m codec.JSONCodec, chain ChainConfig, client ProverConfig) (*ChainProverConfig, error) { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() cbz, err := utils.MarshalJSONAny(m, chain) if err != nil { - logger.Error("error marshalling chain config", zap.Any("config", chain), zap.Error(err)) + configErrorw(zapLogger, "error marshalling chain config", err) return nil, err } clbz, err := utils.MarshalJSONAny(m, client) if err != nil { - logger.Error("error marshalling client config", zap.Any("config", client), zap.Error(err)) + configErrorw(zapLogger, "error marshalling client config", err) return nil, err } return &ChainProverConfig{ @@ -57,16 +56,16 @@ func NewChainProverConfig(m codec.JSONCodec, chain ChainConfig, client ProverCon // Init initialises the configuration func (cc *ChainProverConfig) Init(m codec.Codec) error { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() var chain ChainConfig if err := utils.UnmarshalJSONAny(m, &chain, cc.Chain); err != nil { - logger.Error("error unmarshalling chain config", zap.Any("config", cc.Chain), zap.Error(err)) + configErrorw(zapLogger, "error unmarshalling chain config", err) return err } var prover ProverConfig if err := utils.UnmarshalJSONAny(m, &prover, cc.Prover); err != nil { - logger.Error("error unmarshalling client config", zap.Any("config", cc.Prover), zap.Error(err)) + configErrorw(zapLogger, "error unmarshalling client config", err) return err } cc.chain = chain @@ -92,27 +91,35 @@ func (cc ChainProverConfig) GetProverConfig() (ProverConfig, error) { // Build returns a new ProvableChain instance func (cc ChainProverConfig) Build() (*ProvableChain, error) { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() chainConfig, err := cc.GetChainConfig() if err != nil { - logger.Error("error getting chain config", zap.Error(err)) + configErrorw(zapLogger, "error getting chain config", err) return nil, err } proverConfig, err := cc.GetProverConfig() if err != nil { - logger.Error("error getting client config", zap.Error(err)) + configErrorw(zapLogger, "error getting client config", err) return nil, err } chain, err := chainConfig.Build() if err != nil { - logger.Error("error building chain", zap.Error(err)) + configErrorw(zapLogger, "error building chain", err) return nil, err } prover, err := proverConfig.Build(chain) if err != nil { - logger.Error("error building prover", zap.Error(err)) + configErrorw(zapLogger, "error building prover", err) return nil, err } return NewProvableChain(chain, prover), nil } + +func configErrorw(zapLogger *logger.ZapLogger, msg string, err error) { + zapLogger.Errorw( + msg, + err, + "core.config", + ) +} diff --git a/core/connection.go b/core/connection.go index e4ce8fe4..43159ca2 100644 --- a/core/connection.go +++ b/core/connection.go @@ -1,6 +1,7 @@ package core import ( + "errors" "fmt" "log" "time" @@ -11,7 +12,6 @@ import ( conntypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types" ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported" "github.com/hyperledger-labs/yui-relayer/logger" - "go.uber.org/zap" ) var ( @@ -22,18 +22,20 @@ var ( ) func CreateConnection(src, dst *ProvableChain, to time.Duration) error { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() ticker := time.NewTicker(to) failed := 0 for ; true; <-ticker.C { connSteps, err := createConnectionStep(src, dst) if err != nil { - logger.Error(fmt.Sprintf("failed to create connection step: [%s]client{%s}conn{%s} -> [%s]client{%s}conn{%s}", - src.ChainID(), src.Path().ClientID, src.Path().ConnectionID, - dst.ChainID(), dst.Path().ClientID, dst.Path().ConnectionID), - zap.Error(err)) + connectionErrorwConnection( + zapLogger, + "failed to create connection step", + src, dst, + err, + ) return err } @@ -47,9 +49,11 @@ func CreateConnection(src, dst *ProvableChain, to time.Duration) error { // In the case of success and this being the last transaction // debug logging, log created connection and break case connSteps.Success() && connSteps.Last: - logger.Info(fmt.Sprintf("★ Connection created: [%s]client{%s}conn{%s} -> [%s]client{%s}conn{%s}", - src.ChainID(), src.Path().ClientID, src.Path().ConnectionID, - dst.ChainID(), dst.Path().ClientID, dst.Path().ConnectionID)) + connectionInfowConnection( + zapLogger, + "★ Connection created", + src, dst, + ) return nil // In the case of success, reset the failures counter case connSteps.Success(): @@ -61,12 +65,16 @@ func CreateConnection(src, dst *ProvableChain, to time.Duration) error { log.Println("retrying transaction...") time.Sleep(5 * time.Second) if failed > 2 { - logger.Error(fmt.Sprintf("! Connection failed: [%s]client{%s}conn{%s} -> [%s]client{%s}conn{%s}", - src.ChainID(), src.Path().ClientID, src.Path().ConnectionID, - dst.ChainID(), dst.Path().ClientID, dst.Path().ConnectionID)) + connectionErrorwConnection( + zapLogger, + "! Connection failed", + src, dst, + errors.New("failed 3 times"), + ) return fmt.Errorf("! Connection failed: [%s]client{%s}conn{%s} -> [%s]client{%s}conn{%s}", src.ChainID(), src.Path().ClientID, src.Path().ConnectionID, - dst.ChainID(), dst.Path().ClientID, dst.Path().ConnectionID) + dst.ChainID(), dst.Path().ClientID, dst.Path().ConnectionID, + ) } } @@ -76,8 +84,8 @@ func CreateConnection(src, dst *ProvableChain, to time.Duration) error { } func createConnectionStep(src, dst *ProvableChain) (*RelayMsgs, error) { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() out := NewRelayMsgs() if err := validatePaths(src, dst); err != nil { return nil, err @@ -201,7 +209,11 @@ func createConnectionStep(src, dst *ProvableChain) (*RelayMsgs, error) { out.Last = true default: - logger.Error(fmt.Sprintf("not implemented error: %v %v", srcConn.Connection.State, dstConn.Connection.State)) + connectionErrorw( + zapLogger, + "not implemented", + fmt.Errorf("not implemented error: %v %v", srcConn.Connection.State, dstConn.Connection.State), + ) panic(fmt.Sprintf("not implemented error: %v %v", srcConn.Connection.State, dstConn.Connection.State)) } @@ -220,27 +232,34 @@ func validatePaths(src, dst Chain) error { } func logConnectionStates(src, dst Chain, srcConn, dstConn *conntypes.QueryConnectionResponse) { - logger := logger.ZapLogger() - defer logger.Sync() - logger.Info(fmt.Sprintf("- [%s]@{%d}conn(%s)-{%s} : [%s]@{%d}conn(%s)-{%s}", - src.ChainID(), - mustGetHeight(srcConn.ProofHeight), - src.Path().ConnectionID, - srcConn.Connection.State, - dst.ChainID(), - mustGetHeight(dstConn.ProofHeight), - dst.Path().ConnectionID, - dstConn.Connection.State, - )) + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() + connectionInfow( + zapLogger, + "connection states", + fmt.Sprintf("- [%s]@{%d}conn(%s)-{%s} : [%s]@{%d}conn(%s)-{%s}", + src.ChainID(), + mustGetHeight(srcConn.ProofHeight), + src.Path().ConnectionID, + srcConn.Connection.State, + dst.ChainID(), + mustGetHeight(dstConn.ProofHeight), + dst.Path().ConnectionID, + dstConn.Connection.State, + )) } // mustGetHeight takes the height inteface and returns the actual height func mustGetHeight(h ibcexported.Height) uint64 { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() height, ok := h.(clienttypes.Height) if !ok { - logger.Error("height is not an instance of height! wtf") + connectionErrorw( + zapLogger, + "height is not an instance of height! wtf", + fmt.Errorf("height is not an instance of height! wtf"), + ) panic("height is not an instance of height! wtf") } return height.GetRevisionHeight() @@ -249,12 +268,58 @@ func mustGetHeight(h ibcexported.Height) uint64 { func mustGetAddress(chain interface { GetAddress() (sdk.AccAddress, error) }) sdk.AccAddress { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() addr, err := chain.GetAddress() if err != nil { - logger.Error("failed to get address", zap.Error(err)) + connectionErrorw( + zapLogger, + "failed to get address", + err, + ) panic(err) } return addr } + +func connectionInfow(zapLogger *logger.ZapLogger, msg string, info string) { + zapLogger.Infow( + msg, + info, + ) +} + +func connectionErrorw(zapLogger *logger.ZapLogger, msg string, err error) { + zapLogger.Errorw( + msg, + err, + "core.connection", + ) +} + +func connectionErrorwConnection(zapLogger *logger.ZapLogger, msg string, src, dst *ProvableChain, err error) { + zapLogger.ErrorwChannel( + msg, + src.ChainID(), + src.Path().ClientID, + src.Path().ConnectionID, + dst.ChainID(), + dst.Path().ClientID, + dst.Path().ConnectionID, + err, + "core.connection", + ) +} + +func connectionInfowConnection(zapLogger *logger.ZapLogger, msg string, src, dst *ProvableChain) { + zapLogger.InfowConnection( + msg, + src.ChainID(), + src.Path().ClientID, + src.Path().ConnectionID, + dst.ChainID(), + dst.Path().ClientID, + dst.Path().ConnectionID, + "", + ) +} diff --git a/core/headers.go b/core/headers.go index 8cf9f55e..e097ab71 100644 --- a/core/headers.go +++ b/core/headers.go @@ -6,7 +6,6 @@ import ( "github.com/cosmos/ibc-go/v7/modules/core/exported" "github.com/hyperledger-labs/yui-relayer/logger" - "go.uber.org/zap" ) type Header interface { @@ -54,17 +53,17 @@ var _ SyncHeaders = (*syncHeaders)(nil) // NewSyncHeaders returns a new instance of SyncHeaders that can be easily // kept "reasonably up to date" func NewSyncHeaders(src, dst ChainInfoLightClient) (SyncHeaders, error) { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() if err := ensureDifferentChains(src, dst); err != nil { - logger.Error("error ensuring different chains", zap.Error(err)) + headersErrorw(zapLogger, "error ensuring different chains", err) return nil, err } sh := &syncHeaders{ latestFinalizedHeaders: map[string]Header{src.ChainID(): nil, dst.ChainID(): nil}, } if err := sh.Updates(src, dst); err != nil { - logger.Error("error updating headers", zap.Error(err)) + headersErrorw(zapLogger, "error updating headers", err) return nil, err } return sh, nil @@ -72,21 +71,21 @@ func NewSyncHeaders(src, dst ChainInfoLightClient) (SyncHeaders, error) { // Updates updates the headers on both chains func (sh *syncHeaders) Updates(src, dst ChainInfoLightClient) error { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() if err := ensureDifferentChains(src, dst); err != nil { - logger.Error("error ensuring different chains", zap.Error(err)) + headersErrorw(zapLogger, "error ensuring different chains", err) return err } srcHeader, err := src.GetLatestFinalizedHeader() if err != nil { - logger.Error("error getting latest finalized header of src", zap.Error(err)) + headersErrorw(zapLogger, "error getting latest finalized header of src", err) return err } dstHeader, err := dst.GetLatestFinalizedHeader() if err != nil { - logger.Error("error getting latest finalized header of dst", zap.Error(err)) + headersErrorw(zapLogger, "error getting latest finalized header of dst", err) return err } @@ -107,10 +106,10 @@ func (sh syncHeaders) GetQueryContext(chainID string) QueryContext { // SetupHeadersForUpdate returns `src` chain's headers to update the client on `dst` chain func (sh syncHeaders) SetupHeadersForUpdate(src, dst ChainICS02QuerierLightClient) ([]Header, error) { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() if err := ensureDifferentChains(src, dst); err != nil { - logger.Error("error ensuring different chains", zap.Error(err)) + headersErrorw(zapLogger, "error ensuring different chains", err) return nil, err } return src.SetupHeadersForUpdate(dst, sh.GetLatestFinalizedHeader(src.ChainID())) @@ -118,16 +117,16 @@ func (sh syncHeaders) SetupHeadersForUpdate(src, dst ChainICS02QuerierLightClien // SetupBothHeadersForUpdate returns both `src` and `dst` chain's headers to update the clients on each chain func (sh syncHeaders) SetupBothHeadersForUpdate(src, dst ChainICS02QuerierLightClient) ([]Header, []Header, error) { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() srcHs, err := sh.SetupHeadersForUpdate(src, dst) if err != nil { - logger.Error("error setting up headers for update on src", zap.Error(err)) + headersErrorw(zapLogger, "error setting up headers for update on src", err) return nil, nil, err } dstHs, err := sh.SetupHeadersForUpdate(dst, src) if err != nil { - logger.Error("error setting up headers for update on dst", zap.Error(err)) + headersErrorw(zapLogger, "error setting up headers for update on dst", err) return nil, nil, err } return srcHs, dstHs, nil @@ -140,3 +139,7 @@ func ensureDifferentChains(src, dst ChainInfo) error { return nil } } + +func headersErrorw(zapLogger *logger.ZapLogger, msg string, err error) { + zapLogger.Errorw(msg, err, "core.headers") +} diff --git a/core/naive-strategy.go b/core/naive-strategy.go index be8887d8..b694c54a 100644 --- a/core/naive-strategy.go +++ b/core/naive-strategy.go @@ -2,6 +2,7 @@ package core import ( "context" + "errors" "fmt" "log" @@ -9,7 +10,6 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" "github.com/hyperledger-labs/yui-relayer/logger" - "go.uber.org/zap" "golang.org/x/sync/errgroup" ) @@ -32,28 +32,32 @@ func (st NaiveStrategy) GetType() string { } func (st NaiveStrategy) SetupRelay(ctx context.Context, src, dst *ProvableChain) error { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() if err := src.SetupForRelay(ctx); err != nil { - logger.Error(fmt.Sprintf("failed to setup src chain [%s]chan{%s}port{%s} -> [%s]chan{%s}port{%s}", - src.ChainID(), src.Path().ChannelID, src.Path().PortID, - dst.ChainID(), dst.Path().ChannelID, dst.Path().PortID), - zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "failed to setup for src", + src, dst, + err, + ) return err } if err := dst.SetupForRelay(ctx); err != nil { - logger.Error(fmt.Sprintf("failed to setup dst chain [%s]chan{%s}port{%s} -> [%s]chan{%s}port{%s}", - src.ChainID(), src.Path().ChannelID, src.Path().PortID, - dst.ChainID(), dst.Path().ChannelID, dst.Path().PortID), - zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "failed to setup for dst", + src, dst, + err, + ) return err } return nil } func (st NaiveStrategy) UnrelayedSequences(src, dst *ProvableChain, sh SyncHeaders) (*RelaySequences, error) { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() var ( eg = new(errgroup.Group) srcPacketSeq = []uint64{} @@ -71,22 +75,35 @@ func (st NaiveStrategy) UnrelayedSequences(src, dst *ProvableChain, sh SyncHeade res, err = src.QueryPacketCommitments(srcCtx, 0, 1000) switch { case err != nil: - logger.Error(fmt.Sprintf("- [%s]@{%d} - error querying packet commitments", - src.ChainID(), srcCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error querying packet commitments", + src, dst, + err, + ) return err case res == nil: - logger.Error(fmt.Sprintf("- [%s]@{%d} - nil packet commitments", - src.ChainID(), srcCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "nil packet commitments", + src, dst, + errors.New("however response is nil"), + ) return fmt.Errorf("no error on QueryPacketCommitments for %s, however response is nil", src.ChainID()) default: return nil } }, rtyAtt, rtyDel, rtyErr, retry.OnRetry(func(n uint, err error) { - logger.Info(fmt.Sprintf("- [%s]@{%d} - try(%d/%d) query packet commitments: %s", - src.ChainID(), srcCtx.Height().GetRevisionHeight(), n+1, rtyAttNum, err)) + zapLogger.Zap.Info( + fmt.Sprintf("- [%s]@{%d} - try(%d/%d) query packet commitments: %s", src.ChainID(), srcCtx.Height().GetRevisionHeight(), n+1, rtyAttNum, err), + ) })); err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - max retry exceeded querying packet commitments", - src.ChainID(), srcCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "max retry exceeded querying packet commitments", + src, dst, + err, + ) return err } for _, pc := range res.Commitments { @@ -101,22 +118,38 @@ func (st NaiveStrategy) UnrelayedSequences(src, dst *ProvableChain, sh SyncHeade res, err = dst.QueryPacketCommitments(dstCtx, 0, 1000) switch { case err != nil: - logger.Error(fmt.Sprintf("- [%s]@{%d} - error querying packet commitments", - dst.ChainID(), dstCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error querying packet commitments", + src, dst, + err, + ) return err case res == nil: - logger.Error(fmt.Sprintf("- [%s]@{%d} - nil packet commitments", - dst.ChainID(), dstCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "nil packet commitments", + src, dst, + errors.New("however response is nil"), + ) return fmt.Errorf("no error on QueryPacketCommitments for %s, however response is nil", dst.ChainID()) default: return nil } }, rtyAtt, rtyDel, rtyErr, retry.OnRetry(func(n uint, err error) { - logger.Info(fmt.Sprintf("- [%s]@{%d} - try(%d/%d) query packet commitments: %s", - dst.ChainID(), dstCtx.Height().GetRevisionHeight(), n+1, rtyAttNum, err)) + naiveInfowChannel( + zapLogger, + "query package commitments", + src, dst, + fmt.Sprintf("- [%s]@{%d} - try(%d/%d) query packet commitments: %s", dst.ChainID(), dstCtx.Height().GetRevisionHeight(), n+1, rtyAttNum, err), + ) })); err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - max retry exceeded querying packet commitments", - dst.ChainID(), dstCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "max retry exceeded querying packet commitments", + src, dst, + err, + ) return err } for _, pc := range res.Commitments { @@ -126,40 +159,56 @@ func (st NaiveStrategy) UnrelayedSequences(src, dst *ProvableChain, sh SyncHeade }) if err := eg.Wait(); err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - error querying packet commitments", - src.ChainID(), srcCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error querying packet commitments", + src, dst, + err, + ) return nil, err } eg.Go(func() error { // Query all packets sent by src that have been received by dst - src, err := dst.QueryUnrecievedPackets(dstCtx, srcPacketSeq) + srcPacket, err := dst.QueryUnrecievedPackets(dstCtx, srcPacketSeq) if err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - error querying unrelayed packets", - dst.ChainID(), dstCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error querying unrelayed packets", + src, dst, + err, + ) return err - } else if src != nil { - rs.Src = src + } else if srcPacket != nil { + rs.Src = srcPacket } return nil }) eg.Go(func() error { // Query all packets sent by dst that have been received by src - dst, err := src.QueryUnrecievedPackets(srcCtx, dstPacketSeq) + dstPacket, err := src.QueryUnrecievedPackets(srcCtx, dstPacketSeq) if err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - error querying unrelayed packets", - src.ChainID(), srcCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error querying unrelayed packets", + src, dst, + err, + ) return err - } else if dst != nil { - rs.Dst = dst + } else if dstPacket != nil { + rs.Dst = dstPacket } return nil }) if err := eg.Wait(); err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - error querying unrelayed packets", - src.ChainID(), srcCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error querying unrelayed packets", + src, dst, + err, + ) return nil, err } @@ -167,8 +216,8 @@ func (st NaiveStrategy) UnrelayedSequences(src, dst *ProvableChain, sh SyncHeade } func (st NaiveStrategy) RelayPackets(src, dst *ProvableChain, sp *RelaySequences, sh SyncHeaders) error { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() // set the maximum relay transaction constraints msgs := &RelayMsgs{ Src: []sdk.Msg{}, @@ -181,22 +230,34 @@ func (st NaiveStrategy) RelayPackets(src, dst *ProvableChain, sp *RelaySequences dstCtx := sh.GetQueryContext(dst.ChainID()) srcAddress, err := src.GetAddress() if err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - error getting address", - src.ChainID(), srcCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error getting address", + src, dst, + err, + ) return err } dstAddress, err := dst.GetAddress() if err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - error getting address", - dst.ChainID(), dstCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error getting address", + src, dst, + err, + ) return err } if len(sp.Src) > 0 { hs, err := sh.SetupHeadersForUpdate(src, dst) if err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - error setting up headers for update", - src.ChainID(), srcCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error setting up headers for update", + src, dst, + err, + ) return err } if len(hs) > 0 { @@ -207,8 +268,12 @@ func (st NaiveStrategy) RelayPackets(src, dst *ProvableChain, sp *RelaySequences if len(sp.Dst) > 0 { hs, err := sh.SetupHeadersForUpdate(dst, src) if err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - error setting up headers for update", - dst.ChainID(), dstCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error setting up headers for update", + src, dst, + err, + ) return err } if len(hs) > 0 { @@ -218,20 +283,32 @@ func (st NaiveStrategy) RelayPackets(src, dst *ProvableChain, sp *RelaySequences packetsForDst, err := collectPackets(srcCtx, src, sp.Src, dstAddress) if err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - error collecting packets", - src.ChainID(), srcCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error collecting packets", + src, dst, + err, + ) return err } packetsForSrc, err := collectPackets(dstCtx, dst, sp.Dst, srcAddress) if err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - error collecting packets", - dst.ChainID(), dstCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error collecting packets", + src, dst, + err, + ) return err } if len(packetsForDst) == 0 && len(packetsForSrc) == 0 { - logger.Info(fmt.Sprintf("- No packets to relay between [%s]port{%s} and [%s]port{%s}", - src.ChainID(), src.Path().PortID, dst.ChainID(), dst.Path().PortID)) + naiveInfowChannel( + zapLogger, + "Nopackates to relay", + src, dst, + "", + ) return nil } @@ -252,8 +329,8 @@ func (st NaiveStrategy) RelayPackets(src, dst *ProvableChain, sp *RelaySequences } func (st NaiveStrategy) UnrelayedAcknowledgements(src, dst *ProvableChain, sh SyncHeaders) (*RelaySequences, error) { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() var ( eg = new(errgroup.Group) srcPacketSeq = []uint64{} @@ -272,23 +349,39 @@ func (st NaiveStrategy) UnrelayedAcknowledgements(src, dst *ProvableChain, sh Sy res, err = src.QueryPacketAcknowledgementCommitments(srcCtx, 0, 1000) switch { case err != nil: - logger.Error(fmt.Sprintf("- [%s]@{%d} - error querying packet acknowledgements", - src.ChainID(), srcCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error querying packet acknowledgements", + src, dst, + err, + ) return err case res == nil: - logger.Error(fmt.Sprintf("- [%s]@{%d} - nil packet commitments", - src.ChainID(), srcCtx.Height().GetRevisionHeight())) + naiveErrorwChannel( + zapLogger, + "nil packet commitments", + src, dst, + errors.New("nil packet commitments"), + ) return fmt.Errorf("no error on QueryPacketUnrelayedAcknowledgements for %s, however response is nil", src.ChainID()) default: return nil } }, rtyAtt, rtyDel, rtyErr, retry.OnRetry(func(n uint, err error) { - logger.Info(fmt.Sprintf("- [%s]@{%d} - try(%d/%d) query packet acknowledgements", - src.ChainID(), srcCtx.Height().GetRevisionHeight(), n+1, rtyAttNum), zap.Error(err)) + naiveInfowChannel( + zapLogger, + "query packet acknowledgements", + src, dst, + fmt.Sprintf("- [%s]@{%d} - try(%d/%d) query packet acknowledgements [Error: %s]", src.ChainID(), srcCtx.Height().GetRevisionHeight(), n+1, rtyAttNum, err.Error()), + ) sh.Updates(src, dst) })); err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - max retry exceeded querying packet acknowledgements", - src.ChainID(), srcCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "max retry exceeded querying packet acknowledgements", + src, dst, + err, + ) return err } for _, pc := range res.Acknowledgements { @@ -303,19 +396,31 @@ func (st NaiveStrategy) UnrelayedAcknowledgements(src, dst *ProvableChain, sh Sy res, err = dst.QueryPacketAcknowledgementCommitments(dstCtx, 0, 1000) switch { case err != nil: - logger.Error(fmt.Sprintf("- [%s]@{%d} - error querying packet acknowledgements", - dst.ChainID(), dstCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error querying packet acknowledgements", + src, dst, + err, + ) return err case res == nil: - logger.Error(fmt.Sprintf("- [%s]@{%d} - nil packet acknowledgements acknowledgements", - dst.ChainID(), dstCtx.Height().GetRevisionHeight())) + naiveErrorwChannel( + zapLogger, + "nil packet acknowledgements acknowledgements", + src, dst, + errors.New("nil packet acknowledgements"), + ) return fmt.Errorf("no error on QueryPacketUnrelayedAcknowledgements for %s, however response is nil", dst.ChainID()) default: return nil } }, rtyAtt, rtyDel, rtyErr, retry.OnRetry(func(n uint, err error) { - logger.Info(fmt.Sprintf("- [%s]@{%d} - try(%d/%d) query packet acknowledgements", - dst.ChainID(), dstCtx.Height().GetRevisionHeight(), n+1, rtyAttNum), zap.Error(err)) + naiveInfowChannel( + zapLogger, + "query packet acknowledgements", + src, dst, + fmt.Sprintf("- [%s]@{%d} - try(%d/%d) query packet acknowledgements [Error: %s]", dst.ChainID(), dstCtx.Height().GetRevisionHeight(), n+1, rtyAttNum, err.Error()), + ) sh.Updates(src, dst) })); err != nil { return err @@ -327,41 +432,57 @@ func (st NaiveStrategy) UnrelayedAcknowledgements(src, dst *ProvableChain, sh Sy }) if err := eg.Wait(); err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - error querying packet commitments", - src.ChainID(), srcCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error querying packet commitments", + src, dst, + err, + ) return nil, err } eg.Go(func() error { // Query all packets sent by src that have been received by dst - src, err := dst.QueryUnrecievedAcknowledgements(dstCtx, srcPacketSeq) + srcPacket, err := dst.QueryUnrecievedAcknowledgements(dstCtx, srcPacketSeq) // return err if err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - error querying unrelayed acknowledgements", - dst.ChainID(), dstCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error querying unrelayed acknowledgements", + src, dst, + err, + ) return err - } else if src != nil { - rs.Src = src + } else if srcPacket != nil { + rs.Src = srcPacket } return nil }) eg.Go(func() error { // Query all packets sent by dst that have been received by src - dst, err := src.QueryUnrecievedAcknowledgements(srcCtx, dstPacketSeq) + dstPacket, err := src.QueryUnrecievedAcknowledgements(srcCtx, dstPacketSeq) if err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - error querying unrelayed acknowledgements", - src.ChainID(), srcCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error querying unrelayed acknowledgements", + src, dst, + err, + ) return err - } else if dst != nil { - rs.Dst = dst + } else if dstPacket != nil { + rs.Dst = dstPacket } return nil }) if err := eg.Wait(); err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - error querying unrelayed acknowledgements", - src.ChainID(), srcCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error querying unrelayed acknowledgements", + src, dst, + err, + ) return nil, err } @@ -389,15 +510,19 @@ func collectPackets(ctx QueryContext, chain *ProvableChain, seqs []uint64, signe } func logPacketsRelayed(src, dst Chain, num int) { - logger := logger.ZapLogger() - defer logger.Sync() - logger.Info(fmt.Sprintf("★ Relayed %d packets: [%s]port{%s}->[%s]port{%s}", - num, dst.ChainID(), dst.Path().PortID, src.ChainID(), src.Path().PortID)) + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() + zapLogger.InfowChannel( + fmt.Sprintf("★ Relayed %d packets", num), + src.ChainID(), src.Path().ChannelID, src.Path().PortID, + dst.ChainID(), dst.Path().ChannelID, dst.Path().PortID, + "", + ) } func (st NaiveStrategy) RelayAcknowledgements(src, dst *ProvableChain, sp *RelaySequences, sh SyncHeaders) error { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() // set the maximum relay transaction constraints msgs := &RelayMsgs{ Src: []sdk.Msg{}, @@ -410,22 +535,34 @@ func (st NaiveStrategy) RelayAcknowledgements(src, dst *ProvableChain, sp *Relay dstCtx := sh.GetQueryContext(dst.ChainID()) srcAddress, err := src.GetAddress() if err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - error getting address", - src.ChainID(), srcCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error getting address", + src, dst, + err, + ) return err } dstAddress, err := dst.GetAddress() if err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - error getting address", - dst.ChainID(), dstCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error getting address", + src, dst, + err, + ) return err } if len(sp.Src) > 0 { hs, err := sh.SetupHeadersForUpdate(src, dst) if err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - error setting up headers", - src.ChainID(), srcCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error setting up headers", + src, dst, + err, + ) return err } if len(hs) > 0 { @@ -436,8 +573,12 @@ func (st NaiveStrategy) RelayAcknowledgements(src, dst *ProvableChain, sp *Relay if len(sp.Dst) > 0 { hs, err := sh.SetupHeadersForUpdate(dst, src) if err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - error setting up headers", - dst.ChainID(), dstCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error setting up headers", + src, dst, + err, + ) return err } if len(hs) > 0 { @@ -447,20 +588,32 @@ func (st NaiveStrategy) RelayAcknowledgements(src, dst *ProvableChain, sp *Relay acksForDst, err := collectAcks(dstCtx, srcCtx, dst, src, sp.Src, dstAddress) if err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - error querying unrelayed acknowledgements", - dst.ChainID(), dstCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error querying unrelayed acknowledgements", + src, dst, + err, + ) return err } acksForSrc, err := collectAcks(srcCtx, dstCtx, src, dst, sp.Dst, srcAddress) if err != nil { - logger.Error(fmt.Sprintf("- [%s]@{%d} - error querying unrelayed acknowledgements", - src.ChainID(), srcCtx.Height().GetRevisionHeight()), zap.Error(err)) + naiveErrorwChannel( + zapLogger, + "error querying unrelayed acknowledgements", + src, dst, + err, + ) return err } if len(acksForDst) == 0 && len(acksForSrc) == 0 { - logger.Info(fmt.Sprintf("- No acknowledgements to relay between [%s]port{%s} and [%s]port{%s}", - src.ChainID(), src.Path().PortID, dst.ChainID(), dst.Path().PortID)) + naiveInfowChannel( + zapLogger, + "no acknowledgements to relay", + src, dst, + "", + ) return nil } @@ -503,3 +656,21 @@ func collectAcks(senderCtx, receiverCtx QueryContext, senderChain, receiverChain return msgs, nil } + +func naiveErrorwChannel(zapLogger *logger.ZapLogger, msg string, src, dst *ProvableChain, err error) { + zapLogger.ErrorwChannel(msg, + src.ChainID(), src.Path().ChannelID, src.Path().PortID, + dst.ChainID(), dst.Path().ChannelID, dst.Path().PortID, + err, + "core.naive-strategy", + ) +} + +func naiveInfowChannel(zapLogger *logger.ZapLogger, msg string, src, dst *ProvableChain, info string) { + zapLogger.InfowChannel( + msg, + src.ChainID(), src.Path().ChannelID, src.Path().PortID, + dst.ChainID(), dst.Path().ChannelID, dst.Path().PortID, + info, + ) +} diff --git a/core/packet-tx.go b/core/packet-tx.go index f985b413..c8beeec9 100644 --- a/core/packet-tx.go +++ b/core/packet-tx.go @@ -1,17 +1,17 @@ package core import ( + "errors" "fmt" "time" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/hyperledger-labs/yui-relayer/logger" - "go.uber.org/zap" ) func SendTransferMsg(src, dst *ProvableChain, amount sdk.Coin, dstAddr fmt.Stringer, toHeightOffset uint64, toTimeOffset time.Duration) error { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() var ( timeoutHeight uint64 timeoutTimestamp uint64 @@ -41,7 +41,12 @@ func SendTransferMsg(src, dst *ProvableChain, amount sdk.Coin, dstAddr fmt.Strin srcAddr, err := src.GetAddress() if err != nil { - logger.Error(fmt.Sprintf("failed to get address for send transfer [src: %s]", src.ChainID()), zap.Error(err)) + packetErrorwChannel( + zapLogger, + "failed to get address for send transfer", + src, dst, + err, + ) return err } @@ -54,10 +59,23 @@ func SendTransferMsg(src, dst *ProvableChain, amount sdk.Coin, dstAddr fmt.Strin } if txs.Send(src, dst); !txs.Success() { - logger.Error(fmt.Sprintf("failed to send transfer message [%s]chan{%s}port{%s} -> [%s]chan{%s}port{%s}", - src.ChainID(), src.Path().ChannelID, src.Path().PortID, - dst.ChainID(), dst.Path().ChannelID, dst.Path().PortID)) + packetErrorwChannel( + zapLogger, + "failed to send transfer message", + src, dst, + errors.New("failed to send transfer message"), + ) return fmt.Errorf("failed to send transfer message") } return nil } + +func packetErrorwChannel(zapLogger *logger.ZapLogger, msg string, src, dst *ProvableChain, err error) { + zapLogger.ErrorwChannel( + msg, + src.ChainID(), src.Path().ChannelID, src.Path().PortID, + dst.ChainID(), dst.Path().ChannelID, dst.Path().PortID, + err, + "core.packet-tx", + ) +} diff --git a/core/relayMsgs.go b/core/relayMsgs.go index 124a74ac..fc994c15 100644 --- a/core/relayMsgs.go +++ b/core/relayMsgs.go @@ -4,7 +4,6 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/gogoproto/proto" "github.com/hyperledger-labs/yui-relayer/logger" - "go.uber.org/zap" ) // RelayMsgs contains the msgs that need to be sent to both a src and dst chain @@ -50,8 +49,8 @@ func (r *RelayMsgs) IsMaxTx(msgLen, txSize uint64) bool { // Send sends the messages with appropriate output // TODO: Parallelize? Maybe? func (r *RelayMsgs) Send(src, dst Chain) { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() //nolint:prealloc // can not be pre allocated var ( msgLen, txSize uint64 @@ -64,7 +63,7 @@ func (r *RelayMsgs) Send(src, dst Chain) { for _, msg := range r.Src { bz, err := proto.Marshal(msg) if err != nil { - logger.Error("failed to marshal msg", zap.Any("msg", msg), zap.Error(err)) + relayMsgsErrorw(zapLogger, "failed to marshal msg", err) panic(err) } @@ -94,7 +93,7 @@ func (r *RelayMsgs) Send(src, dst Chain) { for _, msg := range r.Dst { bz, err := proto.Marshal(msg) if err != nil { - logger.Error("failed to marshal msg", zap.Any("msg", msg), zap.Error(err)) + relayMsgsErrorw(zapLogger, "failed to marshal msg", err) panic(err) } @@ -117,3 +116,7 @@ func (r *RelayMsgs) Send(src, dst Chain) { r.Succeeded = false } } + +func relayMsgsErrorw(zapLogger *logger.ZapLogger, msg string, err error) { + zapLogger.Errorw(msg, err, "core.relayMegs") +} diff --git a/core/service.go b/core/service.go index 9658d6d0..2dcbedd0 100644 --- a/core/service.go +++ b/core/service.go @@ -7,7 +7,6 @@ import ( retry "github.com/avast/retry-go" "github.com/hyperledger-labs/yui-relayer/logger" - "go.uber.org/zap" ) // StartService starts a relay service @@ -41,8 +40,8 @@ func NewRelayService(st StrategyI, src, dst *ProvableChain, sh SyncHeaders, inte // Start starts a relay service func (srv *RelayService) Start(ctx context.Context) error { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() for { if err := retry.Do(func() error { select { @@ -52,7 +51,11 @@ func (srv *RelayService) Start(ctx context.Context) error { return srv.Serve(ctx) } }, rtyAtt, rtyDel, rtyErr, retry.OnRetry(func(n uint, err error) { - logger.Info(fmt.Sprintf("- [%s][%s]try(%d/%d) relay-service: %s", srv.src.ChainID(), srv.dst.ChainID(), n+1, rtyAttNum, err)) + serviceInfow( + zapLogger, + "relay-service", + fmt.Sprintf("- [%s][%s]try(%d/%d) relay-service: %s", srv.src.ChainID(), srv.dst.ChainID(), n+1, rtyAttNum, err), + ) })); err != nil { return err } @@ -62,11 +65,11 @@ func (srv *RelayService) Start(ctx context.Context) error { // Serve performs packet-relay func (srv *RelayService) Serve(ctx context.Context) error { - logger := logger.ZapLogger() - defer logger.Sync() + zapLogger := logger.GetLogger() + defer zapLogger.Zap.Sync() // First, update the latest headers for src and dst if err := srv.sh.Updates(srv.src, srv.dst); err != nil { - logger.Error("failed to update headers", zap.Error(err)) + serviceErrorw(zapLogger, "failed to update headers", err) return err } @@ -74,11 +77,11 @@ func (srv *RelayService) Serve(ctx context.Context) error { pseqs, err := srv.st.UnrelayedSequences(srv.src, srv.dst, srv.sh) if err != nil { - logger.Error("failed to get unrelayed sequences", zap.Error(err)) + serviceErrorw(zapLogger, "failed to get unrelayed sequences", err) return err } if err := srv.st.RelayPackets(srv.src, srv.dst, pseqs, srv.sh); err != nil { - logger.Error("failed to relay packets", zap.Error(err)) + serviceErrorw(zapLogger, "failed to relay packets", err) return err } @@ -86,13 +89,21 @@ func (srv *RelayService) Serve(ctx context.Context) error { aseqs, err := srv.st.UnrelayedAcknowledgements(srv.src, srv.dst, srv.sh) if err != nil { - logger.Error("failed to get unrelayed acknowledgements", zap.Error(err)) + serviceErrorw(zapLogger, "failed to get unrelayed acknowledgements", err) return err } if err := srv.st.RelayAcknowledgements(srv.src, srv.dst, aseqs, srv.sh); err != nil { - logger.Error("failed to relay acknowledgements", zap.Error(err)) + serviceErrorw(zapLogger, "failed to relay acknowledgements", err) return err } return nil } + +func serviceErrorw(zapLogger *logger.ZapLogger, msg string, err error) { + zapLogger.Errorw(msg, err, "core.service") +} + +func serviceInfow(zapLogger *logger.ZapLogger, msg string, info interface{}) { + zapLogger.Infow(msg, info) +} diff --git a/logger/zap.go b/logger/zap.go index bf36b2a4..854c052b 100644 --- a/logger/zap.go +++ b/logger/zap.go @@ -8,7 +8,11 @@ import ( "go.uber.org/zap/zapcore" ) -var zapLogger *zap.SugaredLogger +type ZapLogger struct { + Zap *zap.SugaredLogger +} + +var zapLogger *ZapLogger func init() { logLevelEnv := os.Getenv("LOG_LEVEL") @@ -53,9 +57,110 @@ func init() { if err != nil { log.Fatalf("CreateLogger Error: %v", err) } - zapLogger = logger.Sugar() + + zapLogger = new(ZapLogger) + zapLogger.Zap = logger.Sugar() + } -func ZapLogger() *zap.SugaredLogger { +func GetLogger() *ZapLogger { return zapLogger } + +func (zl *ZapLogger) Errorw( + msg string, + err error, + stackKey string, +) { + zl.Zap.Errorw( + msg, + "error", zap.Error(err), + "stack trace", zap.StackSkip(stackKey, 2), + ) +} + +func (zl *ZapLogger) ErrorwChannel( + msg string, + srcChainID, srcChannelID, srcPortID string, + dstChainID, dstChannelID, dstPortID string, + err error, + stackKey string, +) { + zl.Zap.Errorw( + msg, + "source chain id", srcChainID, + "source channnel id", srcChannelID, + "source port id", srcPortID, + "destination chain id", dstChainID, + "destination channel id", dstChannelID, + "destination port id", dstPortID, + "error", zap.Error(err), + "stack trace", zap.StackSkip(stackKey, 2), + ) +} + +func (zl *ZapLogger) ErrorwConnection( + msg string, + srcChainID, srcClientID, srcConnectionID, + dstChainID, dstClientID, dstConnectionID string, + err error, + stackKey string, +) { + zl.Zap.Errorw( + msg, + "source chain id", srcChainID, + "source client id", srcClientID, + "source connection id", srcConnectionID, + "destination chain id", dstChainID, + "destination client id", dstClientID, + "destination connection id", dstConnectionID, + "error", zap.Error(err), + "stack trace", zap.StackSkip(stackKey, 2), + ) +} + +func (zl *ZapLogger) Infow( + msg string, + info interface{}, +) { + zl.Zap.Infow( + msg, + "info", info, + ) +} + +func (zl *ZapLogger) InfowChannel( + msg string, + srcChainID, srcChannelID, srcPortID string, + dstChainID, dstChannelID, dstPortID string, + info interface{}, +) { + zl.Zap.Infow( + msg, + "source chain id", srcChainID, + "source channnel id", srcChannelID, + "source port id", srcPortID, + "destination chain id", dstChainID, + "destination channel id", dstChannelID, + "destination port id", dstPortID, + "info", info, + ) +} + +func (zl *ZapLogger) InfowConnection( + msg string, + srcChainID, srcClientID, srcConnectionID string, + dstChainID, dstClientID, dstConnectionID string, + info interface{}, +) { + zl.Zap.Infow( + msg, + "source chain id", srcChainID, + "source client id", srcClientID, + "source connection id", srcConnectionID, + "destination chain id", dstChainID, + "destination client id", dstClientID, + "destination connection id", dstConnectionID, + "info", info, + ) +}