Skip to content

Commit db15437

Browse files
abickyabicky
committed
Use logger methods with context
1 parent 7861f3d commit db15437

File tree

4 files changed

+63
-63
lines changed

4 files changed

+63
-63
lines changed

‎pkg/relay/ethereum/chain.go‎

Lines changed: 30 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -112,7 +112,7 @@ func NewChain(ctx context.Context, config ChainConfig) (*Chain, error) {
112112
txMaxSize := config.GetTxMaxSize()
113113
if txMaxSize == 0 {
114114
txMaxSize = 128 * 1024 // go-ethereum/core/txpool/legacypool/legacypool.go
115-
logger.Info(fmt.Sprintf("txMaxSize is zero. set to %v", txMaxSize))
115+
logger.InfoContext(ctx, fmt.Sprintf("txMaxSize is zero. set to %v", txMaxSize))
116116
}
117117

118118
return &Chain{
@@ -160,7 +160,7 @@ func (c *Chain) LatestHeight(ctx context.Context) (ibcexported.Height, error) {
160160
logger := c.GetChainLogger()
161161
bn, err := c.client.BlockNumber(ctx)
162162
if err != nil {
163-
logger.Error("failed to get block number", err)
163+
logger.ErrorContext(ctx, "failed to get block number", err)
164164
return nil, err
165165
}
166166
return clienttypes.NewHeight(0, bn), nil
@@ -222,20 +222,20 @@ func (c *Chain) QueryClientConsensusState(ctx core.QueryContext, dstClientConsHe
222222
s, found, err := c.ibcHandler.GetConsensusState(c.callOptsFromQueryContext(ctx), c.pathEnd.ClientID, pbToHostHeight(dstClientConsHeight))
223223
if err != nil {
224224
revertReason, data := c.parseRpcError(err)
225-
logger.Error("failed to get consensus state", err, logAttrRevertReason, revertReason, logAttrRawErrorData, data)
225+
logger.ErrorContext(ctx.Context(), "failed to get consensus state", err, logAttrRevertReason, revertReason, logAttrRawErrorData, data)
226226
return nil, err
227227
} else if !found {
228-
logger.Error("client consensus not found", errors.New("client consensus not found"))
228+
logger.ErrorContext(ctx.Context(), "client consensus not found", errors.New("client consensus not found"))
229229
return nil, fmt.Errorf("client consensus not found: %v", c.pathEnd.ClientID)
230230
}
231231
var consensusState ibcexported.ConsensusState
232232
if err := c.Codec().UnmarshalInterface(s, &consensusState); err != nil {
233-
logger.Error("failed to unmarshal consensus state", err)
233+
logger.ErrorContext(ctx.Context(), "failed to unmarshal consensus state", err)
234234
return nil, err
235235
}
236236
any, err := clienttypes.PackConsensusState(consensusState)
237237
if err != nil {
238-
logger.Error("failed to pack consensus state", err)
238+
logger.ErrorContext(ctx.Context(), "failed to pack consensus state", err)
239239
return nil, err
240240
}
241241
return clienttypes.NewQueryConsensusStateResponse(any, nil, ctx.Height().(clienttypes.Height)), nil
@@ -245,24 +245,24 @@ func (c *Chain) QueryClientConsensusState(ctx core.QueryContext, dstClientConsHe
245245
// height represents the height of dst chain
246246
func (c *Chain) QueryClientState(ctx core.QueryContext) (*clienttypes.QueryClientStateResponse, error) {
247247
logger := c.GetChainLogger()
248-
defer logger.TimeTrack(time.Now(), "QueryClientState")
248+
defer logger.TimeTrackContext(ctx.Context(), time.Now(), "QueryClientState")
249249
s, found, err := c.ibcHandler.GetClientState(c.callOptsFromQueryContext(ctx), c.pathEnd.ClientID)
250250
if err != nil {
251251
revertReason, data := c.parseRpcError(err)
252-
logger.Error("failed to get client state", err, logAttrRevertReason, revertReason, logAttrRawErrorData, data)
252+
logger.ErrorContext(ctx.Context(), "failed to get client state", err, logAttrRevertReason, revertReason, logAttrRawErrorData, data)
253253
return nil, err
254254
} else if !found {
255-
logger.Error("client not found", errors.New("client not found"))
255+
logger.ErrorContext(ctx.Context(), "client not found", errors.New("client not found"))
256256
return nil, fmt.Errorf("client not found: %v", c.pathEnd.ClientID)
257257
}
258258
var clientState ibcexported.ClientState
259259
if err := c.Codec().UnmarshalInterface(s, &clientState); err != nil {
260-
logger.Error("failed to unmarshal client state", err)
260+
logger.ErrorContext(ctx.Context(), "failed to unmarshal client state", err)
261261
return nil, err
262262
}
263263
any, err := clienttypes.PackClientState(clientState)
264264
if err != nil {
265-
logger.Error("failed to pack client state", err)
265+
logger.ErrorContext(ctx.Context(), "failed to pack client state", err)
266266
return nil, err
267267
}
268268
return clienttypes.NewQueryClientStateResponse(any, nil, ctx.Height().(clienttypes.Height)), nil
@@ -287,11 +287,11 @@ var emptyConnRes = conntypes.NewQueryConnectionResponse(
287287
// QueryConnection returns the remote end of a given connection
288288
func (c *Chain) QueryConnection(ctx core.QueryContext, connectionID string) (*conntypes.QueryConnectionResponse, error) {
289289
logger := c.GetChainLogger()
290-
defer logger.TimeTrack(time.Now(), "QueryConnection")
290+
defer logger.TimeTrackContext(ctx.Context(), time.Now(), "QueryConnection")
291291
conn, found, err := c.ibcHandler.GetConnection(c.callOptsFromQueryContext(ctx), connectionID)
292292
if err != nil {
293293
revertReason, data := c.parseRpcError(err)
294-
logger.Error("failed to get connection", err, logAttrRevertReason, revertReason, logAttrRawErrorData, data)
294+
logger.ErrorContext(ctx.Context(), "failed to get connection", err, logAttrRevertReason, revertReason, logAttrRawErrorData, data)
295295
return nil, err
296296
} else if !found {
297297
return emptyConnRes, nil
@@ -317,11 +317,11 @@ var emptyChannelRes = chantypes.NewQueryChannelResponse(
317317
// QueryChannel returns the channel associated with a channelID
318318
func (c *Chain) QueryChannel(ctx core.QueryContext) (chanRes *chantypes.QueryChannelResponse, err error) {
319319
logger := c.GetChainLogger()
320-
defer logger.TimeTrack(time.Now(), "QueryChannel")
320+
defer logger.TimeTrackContext(ctx.Context(), time.Now(), "QueryChannel")
321321
chann, found, err := c.ibcHandler.GetChannel(c.callOptsFromQueryContext(ctx), c.pathEnd.PortID, c.pathEnd.ChannelID)
322322
if err != nil {
323323
revertReason, data := c.parseRpcError(err)
324-
logger.Error("failed to get channel", err, logAttrRevertReason, revertReason, logAttrRawErrorData, data)
324+
logger.ErrorContext(ctx.Context(), "failed to get channel", err, logAttrRevertReason, revertReason, logAttrRawErrorData, data)
325325
return nil, err
326326
} else if !found {
327327
return emptyChannelRes, nil
@@ -344,7 +344,7 @@ func (c *Chain) QueryUnreceivedPackets(ctx core.QueryContext, seqs []uint64) ([]
344344
case chantypes.UNORDERED:
345345
if rc, err := c.ibcHandler.GetPacketReceipt(c.callOptsFromQueryContext(ctx), c.pathEnd.PortID, c.pathEnd.ChannelID, seq); err != nil {
346346
revertReason, data := c.parseRpcError(err)
347-
logger.Error("failed to get packet receipt", err, logAttrRevertReason, revertReason, logAttrRawErrorData, data)
347+
logger.ErrorContext(ctx.Context(), "failed to get packet receipt", err, logAttrRevertReason, revertReason, logAttrRawErrorData, data)
348348
return nil, err
349349
} else if rc == PACKET_RECEIPT_SUCCESSFUL {
350350
received = true
@@ -359,7 +359,7 @@ func (c *Chain) QueryUnreceivedPackets(ctx core.QueryContext, seqs []uint64) ([]
359359
nextSequenceRecv, err = c.ibcHandler.GetNextSequenceRecv(c.callOptsFromQueryContext(ctx), c.pathEnd.PortID, c.pathEnd.ChannelID)
360360
if err != nil {
361361
revertReason, data := c.parseRpcError(err)
362-
logger.Error("failed to get nextSequenceRecv", err, logAttrRevertReason, revertReason, logAttrRawErrorData, data)
362+
logger.ErrorContext(ctx.Context(), "failed to get nextSequenceRecv", err, logAttrRevertReason, revertReason, logAttrRawErrorData, data)
363363
return nil, err
364364
}
365365
}
@@ -380,30 +380,30 @@ func (c *Chain) QueryUnfinalizedRelayPackets(ctx core.QueryContext, counterparty
380380
logger := c.GetChannelLogger()
381381
checkpoint, err := c.loadCheckpoint(sendCheckpoint)
382382
if err != nil {
383-
logger.Error("failed to load checkpoint", err)
383+
logger.ErrorContext(ctx.Context(), "failed to load checkpoint", err)
384384
return nil, err
385385
}
386386

387387
if checkpoint > ctx.Height().GetRevisionHeight() {
388-
logger.Info("`send` checkpoint is greater than target height", "checkpoint", checkpoint, "height", ctx.Height().GetRevisionHeight())
388+
logger.InfoContext(ctx.Context(), "`send` checkpoint is greater than target height", "checkpoint", checkpoint, "height", ctx.Height().GetRevisionHeight())
389389
return core.PacketInfoList{}, nil
390390
}
391391
packets, err := c.findSentPackets(ctx, checkpoint)
392392
if err != nil {
393-
logger.Error("failed to find sent packets", err)
393+
logger.ErrorContext(ctx.Context(), "failed to find sent packets", err)
394394
return nil, err
395395
}
396396

397397
counterpartyHeader, err := counterparty.GetLatestFinalizedHeader(ctx.Context())
398398
if err != nil {
399-
logger.Error("failed to get latest finalized header", err)
399+
logger.ErrorContext(ctx.Context(), "failed to get latest finalized header", err)
400400
return nil, err
401401
}
402402

403403
counterpartyCtx := core.NewQueryContext(ctx.Context(), counterpartyHeader.GetHeight())
404404
seqs, err := counterparty.QueryUnreceivedPackets(counterpartyCtx, packets.ExtractSequenceList())
405405
if err != nil {
406-
logger.Error("failed to query unreceived packets", err)
406+
logger.ErrorContext(ctx.Context(), "failed to query unreceived packets", err)
407407
return nil, err
408408
}
409409

@@ -414,7 +414,7 @@ func (c *Chain) QueryUnfinalizedRelayPackets(ctx core.QueryContext, counterparty
414414
checkpoint = packets[0].EventHeight.GetRevisionHeight()
415415
}
416416
if err := c.saveCheckpoint(checkpoint, sendCheckpoint); err != nil {
417-
logger.Error("failed to save checkpoint", err)
417+
logger.ErrorContext(ctx.Context(), "failed to save checkpoint", err)
418418
return nil, err
419419
}
420420

@@ -430,7 +430,7 @@ func (c *Chain) QueryUnreceivedAcknowledgements(ctx core.QueryContext, seqs []ui
430430
commitment, err := c.ibcHandler.GetCommitment(c.callOptsFromQueryContext(ctx), key)
431431
if err != nil {
432432
revertReason, data := c.parseRpcError(err)
433-
logger.Error("failed to get hashed packet commitment", err, logAttrRevertReason, revertReason, logAttrRawErrorData, data)
433+
logger.ErrorContext(ctx.Context(), "failed to get hashed packet commitment", err, logAttrRevertReason, revertReason, logAttrRawErrorData, data)
434434
return nil, err
435435
} else if commitment != [32]byte{} {
436436
ret = append(ret, seq)
@@ -444,30 +444,30 @@ func (c *Chain) QueryUnfinalizedRelayAcknowledgements(ctx core.QueryContext, cou
444444
logger := c.GetChannelLogger()
445445
checkpoint, err := c.loadCheckpoint(recvCheckpoint)
446446
if err != nil {
447-
logger.Error("failed to load checkpoint", err)
447+
logger.ErrorContext(ctx.Context(), "failed to load checkpoint", err)
448448
return nil, err
449449
}
450450

451451
if checkpoint > ctx.Height().GetRevisionHeight() {
452-
logger.Info("`recv` checkpoint is greater than target height", "checkpoint", checkpoint, "height", ctx.Height().GetRevisionHeight())
452+
logger.InfoContext(ctx.Context(), "`recv` checkpoint is greater than target height", "checkpoint", checkpoint, "height", ctx.Height().GetRevisionHeight())
453453
return core.PacketInfoList{}, nil
454454
}
455455
packets, err := c.findReceivedPackets(ctx, checkpoint)
456456
if err != nil {
457-
logger.Error("failed to find received packets", err)
457+
logger.ErrorContext(ctx.Context(), "failed to find received packets", err)
458458
return nil, err
459459
}
460460

461461
counterpartyHeader, err := counterparty.GetLatestFinalizedHeader(ctx.Context())
462462
if err != nil {
463-
logger.Error("failed to get latest finalized header", err)
463+
logger.ErrorContext(ctx.Context(), "failed to get latest finalized header", err)
464464
return nil, err
465465
}
466466

467467
counterpartyCtx := core.NewQueryContext(ctx.Context(), counterpartyHeader.GetHeight())
468468
seqs, err := counterparty.QueryUnreceivedAcknowledgements(counterpartyCtx, packets.ExtractSequenceList())
469469
if err != nil {
470-
logger.Error("failed to query unreceived acknowledgements", err)
470+
logger.ErrorContext(ctx.Context(), "failed to query unreceived acknowledgements", err)
471471
return nil, err
472472
}
473473

@@ -478,7 +478,7 @@ func (c *Chain) QueryUnfinalizedRelayAcknowledgements(ctx core.QueryContext, cou
478478
checkpoint = packets[0].EventHeight.GetRevisionHeight()
479479
}
480480
if err := c.saveCheckpoint(checkpoint, recvCheckpoint); err != nil {
481-
logger.Error("failed to save checkpoint", err)
481+
logger.ErrorContext(ctx.Context(), "failed to save checkpoint", err)
482482
return nil, err
483483
}
484484

‎pkg/relay/ethereum/events.go‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -59,24 +59,24 @@ func (chain *Chain) findSentPackets(ctx core.QueryContext, fromHeight uint64) (c
5959
chain.Path().ChannelID,
6060
); err != nil {
6161
revertReason, data := chain.parseRpcError(err)
62-
logger.Error("failed to get channel", err, "port_id", chain.Path().PortID, "channel_id", chain.Path().ChannelID,
62+
logger.ErrorContext(ctx.Context(), "failed to get channel", err, "port_id", chain.Path().PortID, "channel_id", chain.Path().ChannelID,
6363
logAttrRevertReason, revertReason,
6464
logAttrRawErrorData, data)
6565
return nil, err
6666
} else if !found {
6767
err := fmt.Errorf("channel not found")
68-
logger.Error("failed to get channel", err, "port_id", chain.Path().PortID, "channel_id", chain.Path().ChannelID)
68+
logger.ErrorContext(ctx.Context(), "failed to get channel", err, "port_id", chain.Path().PortID, "channel_id", chain.Path().ChannelID)
6969
return nil, err
7070
} else {
7171
dstPortID = channel.Counterparty.PortId
7272
dstChannelID = channel.Counterparty.ChannelId
7373
}
7474
logs, err := chain.filterLogs(ctx, fromHeight, abiSendPacket)
7575
if err != nil {
76-
logger.Error("failed to filter logs", err)
76+
logger.ErrorContext(ctx.Context(), "failed to filter logs", err)
7777
return nil, err
7878
}
79-
defer logger.TimeTrack(now, "findSentPackets", "num_logs", len(logs))
79+
defer logger.TimeTrackContext(ctx.Context(), now, "findSentPackets", "num_logs", len(logs))
8080

8181
var packets core.PacketInfoList
8282
for _, log := range logs {
@@ -115,21 +115,21 @@ func (chain *Chain) findReceivedPackets(ctx core.QueryContext, fromHeight uint64
115115

116116
recvPacketEvents, err := chain.findRecvPacketEvents(ctx, fromHeight)
117117
if err != nil {
118-
logger.Error("failed to find recv packet events", err)
118+
logger.ErrorContext(ctx.Context(), "failed to find recv packet events", err)
119119
return nil, err
120120
} else if len(recvPacketEvents) == 0 {
121121
return nil, nil
122122
}
123123

124124
writeAckEvents, err := chain.findWriteAckEvents(ctx, recvPacketEvents[0].Raw.BlockNumber)
125125
if err != nil {
126-
logger.Error("failed to find write ack events", err)
126+
logger.ErrorContext(ctx.Context(), "failed to find write ack events", err)
127127
return nil, err
128128
} else if len(writeAckEvents) == 0 {
129129
return nil, nil
130130
}
131131

132-
defer logger.TimeTrack(now, "findReceivedPackets", "num_recv_packet_events", len(recvPacketEvents), "num_write_ack_events", len(writeAckEvents))
132+
defer logger.TimeTrackContext(ctx.Context(), now, "findReceivedPackets", "num_recv_packet_events", len(recvPacketEvents), "num_write_ack_events", len(writeAckEvents))
133133

134134
var packets core.PacketInfoList
135135
for _, rp := range recvPacketEvents {

0 commit comments

Comments
 (0)