chore(logs): remove duplicate msg key (#1180)

* Remove `msg` parameter key in logs.

closes: #1176

libp2p/connmanager.nim

@@ -136,7 +136,8 @@ proc triggerConnEvent*(c: ConnManager, peerId: PeerId, event: ConnEvent) {.async
   except CancelledError as exc:
     raise exc
   except CatchableError as exc:
-    warn "Exception in triggerConnEvents", msg = exc.msg, peer = peerId, event = $event
+    warn "Exception in triggerConnEvents",
+      description = exc.msg, peer = peerId, event = $event
 
 proc addPeerEventHandler*(
     c: ConnManager, handler: PeerEventHandler, kind: PeerEventKind
@@ -169,7 +170,7 @@ proc triggerPeerEvents*(c: ConnManager, peerId: PeerId, event: PeerEvent) {.asyn
   except CancelledError as exc:
     raise exc
   except CatchableError as exc: # handlers should not raise!
-    warn "Exception in triggerPeerEvents", exc = exc.msg, peer = peerId
+    warn "Exception in triggerPeerEvents", description = exc.msg, peer = peerId
 
 proc expectConnection*(
     c: ConnManager, p: PeerId, dir: Direction
@@ -212,7 +213,7 @@ proc closeMuxer(muxer: Muxer) {.async.} =
     try:
       await muxer.handler # TODO noraises?
     except CatchableError as exc:
-      trace "Exception in close muxer handler", exc = exc.msg
+      trace "Exception in close muxer handler", description = exc.msg
   trace "Cleaned up muxer", m = muxer
 
 proc muxCleanup(c: ConnManager, mux: Muxer) {.async.} =
@@ -235,7 +236,7 @@ proc muxCleanup(c: ConnManager, mux: Muxer) {.async.} =
   except CatchableError as exc:
     # This is top-level procedure which will work as separate task, so it
     # do not need to propagate CancelledError and should handle other errors
-    warn "Unexpected exception peer cleanup handler", mux, msg = exc.msg
+    warn "Unexpected exception peer cleanup handler", mux, description = exc.msg
 
 proc onClose(c: ConnManager, mux: Muxer) {.async.} =
   ## connection close even handler
@@ -246,7 +247,8 @@ proc onClose(c: ConnManager, mux: Muxer) {.async.} =
     await mux.connection.join()
     trace "Connection closed, cleaning up", mux
   except CatchableError as exc:
-    debug "Unexpected exception in connection manager's cleanup", errMsg = exc.msg, mux
+    debug "Unexpected exception in connection manager's cleanup",
+      description = exc.msg, mux
   finally:
     await c.muxCleanup(mux)
 
@@ -358,7 +360,7 @@ proc trackConnection*(cs: ConnectionSlot, conn: Connection) =
     try:
       await conn.join()
     except CatchableError as exc:
-      trace "Exception in semaphore monitor, ignoring", exc = exc.msg
+      trace "Exception in semaphore monitor, ignoring", description = exc.msg
 
     cs.release()
 

libp2p/dialer.nim

@@ -62,10 +62,12 @@ proc dialAndUpgrade(
           libp2p_total_dial_attempts.inc()
           await transport.dial(hostname, address, peerId)
         except CancelledError as exc:
-          trace "Dialing canceled", err = exc.msg, peerId = peerId.get(default(PeerId))
+          trace "Dialing canceled",
+            description = exc.msg, peerId = peerId.get(default(PeerId))
           raise exc
         except CatchableError as exc:
-          debug "Dialing failed", err = exc.msg, peerId = peerId.get(default(PeerId))
+          debug "Dialing failed",
+            description = exc.msg, peerId = peerId.get(default(PeerId))
           libp2p_failed_dials.inc()
           return nil # Try the next address
 
@@ -87,7 +89,7 @@ proc dialAndUpgrade(
           # we won't succeeded through another - no use in trying again
           await dialed.close()
           debug "Connection upgrade failed",
-            err = exc.msg, peerId = peerId.get(default(PeerId))
+            description = exc.msg, peerId = peerId.get(default(PeerId))
           if dialed.dir == Direction.Out:
             libp2p_failed_upgrades_outgoing.inc()
           else:
@@ -200,7 +202,7 @@ proc internalConnect(
         PeerEvent(kind: PeerEventKind.Identified, initiator: true),
       )
     except CatchableError as exc:
-      trace "Failed to finish outgoung upgrade", err = exc.msg
+      trace "Failed to finish outgoung upgrade", description = exc.msg
       await muxed.close()
       raise exc
 
@@ -327,7 +329,7 @@ method dial*(
     await cleanup()
     raise exc
   except CatchableError as exc:
-    debug "Error dialing", conn, err = exc.msg
+    debug "Error dialing", conn, description = exc.msg
     await cleanup()
     raise exc
 

libp2p/discovery/rendezvousinterface.nim

@@ -64,7 +64,7 @@ method advertise*(self: RendezVousInterface) {.async.} =
       try:
         await self.rdv.advertise(toAdv, self.ttl)
       except CatchableError as error:
-        debug "RendezVous advertise error: ", msg = error.msg
+        debug "RendezVous advertise error: ", description = error.msg
 
     await sleepAsync(self.timeToAdvertise) or self.advertisementUpdated.wait()
 

libp2p/errors.nim

@@ -31,7 +31,7 @@ macro checkFutures*[F](futs: seq[F], exclude: untyped = []): untyped =
           # We still don't abort but warn
           debug "A future has failed, enable trace logging for details",
             error = exc.name
-          trace "Exception message", msg = exc.msg, stack = getStackTrace()
+          trace "Exception message", description = exc.msg, stack = getStackTrace()
   else:
     quote:
       for res in `futs`:
@@ -40,9 +40,9 @@ macro checkFutures*[F](futs: seq[F], exclude: untyped = []): untyped =
             let exc = res.readError()
             for i in 0 ..< `nexclude`:
               if exc of `exclude`[i]:
-                trace "A future has failed", error = exc.name, msg = exc.msg
+                trace "A future has failed", error = exc.name, description = exc.msg
                 break check
             # We still don't abort but warn
             debug "A future has failed, enable trace logging for details",
               error = exc.name
-            trace "Exception details", msg = exc.msg
+            trace "Exception details", description = exc.msg

libp2p/multistream.nim

@@ -212,7 +212,7 @@ proc handle*(
   except CancelledError as exc:
     raise exc
   except CatchableError as exc:
-    trace "Exception in multistream", conn, msg = exc.msg
+    trace "Exception in multistream", conn, description = exc.msg
   finally:
     await conn.close()
 

libp2p/muxers/mplex/lpchannel.nim

@@ -116,7 +116,7 @@ proc reset*(s: LPChannel) {.async: (raises: []).} =
         trace "sending reset message", s, conn = s.conn
         await noCancel s.conn.writeMsg(s.id, s.resetCode) # write reset
       except LPStreamError as exc:
-        trace "Can't send reset message", s, conn = s.conn, msg = exc.msg
+        trace "Can't send reset message", s, conn = s.conn, description = exc.msg
         await s.conn.close()
 
     asyncSpawn resetMessage()
@@ -145,7 +145,7 @@ method close*(s: LPChannel) {.async: (raises: []).} =
       # It's harmless that close message cannot be sent - the connection is
       # likely down already
       await s.conn.close()
-      trace "Cannot send close message", s, id = s.id, msg = exc.msg
+      trace "Cannot send close message", s, id = s.id, description = exc.msg
 
   await s.closeUnderlying() # maybe already eofed
 
@@ -256,7 +256,7 @@ proc completeWrite(
   except LPStreamEOFError as exc:
     raise exc
   except LPStreamError as exc:
-    trace "exception in lpchannel write handler", s, msg = exc.msg
+    trace "exception in lpchannel write handler", s, description = exc.msg
     await s.reset()
     await s.conn.close()
     raise newLPStreamConnDownError(exc)

libp2p/muxers/mplex/mplex.nim

@@ -70,7 +70,7 @@ proc cleanupChann(m: Mplex, chann: LPChannel) {.async: (raises: []), inline.} =
         labelValues = [$chann.initiator, $m.connection.peerId],
       )
   except CancelledError as exc:
-    warn "Error cleaning up mplex channel", m, chann, msg = exc.msg
+    warn "Error cleaning up mplex channel", m, chann, description = exc.msg
 
 proc newStreamInternal*(
     m: Mplex,
@@ -175,7 +175,7 @@ method handle*(m: Mplex) {.async: (raises: []).} =
         except LPStreamClosedError as exc:
           # Channel is being closed, but `cleanupChann` was not yet triggered.
           trace "pushing data to channel failed",
-            m, channel, len = data.len, msg = exc.msg
+            m, channel, len = data.len, description = exc.msg
           discard # Ignore message, same as if `cleanupChann` had completed.
       of MessageType.CloseIn, MessageType.CloseOut:
         await channel.pushEof()
@@ -185,11 +185,11 @@ method handle*(m: Mplex) {.async: (raises: []).} =
   except CancelledError:
     debug "Unexpected cancellation in mplex handler", m
   except LPStreamEOFError as exc:
-    trace "Stream EOF", m, msg = exc.msg
+    trace "Stream EOF", m, description = exc.msg
   except LPStreamError as exc:
-    debug "Unexpected stream exception in mplex read loop", m, msg = exc.msg
+    debug "Unexpected stream exception in mplex read loop", m, description = exc.msg
   except MuxerError as exc:
-    debug "Unexpected muxer exception in mplex read loop", m, msg = exc.msg
+    debug "Unexpected muxer exception in mplex read loop", m, description = exc.msg
   finally:
     await m.close()
   trace "Stopped mplex handler", m

libp2p/muxers/yamux/yamux.nim

@@ -513,9 +513,9 @@ method close*(m: Yamux) {.async: (raises: []).} =
   try:
     await m.connection.write(YamuxHeader.goAway(NormalTermination))
   except CancelledError as exc:
-    trace "cancelled sending goAway", msg = exc.msg
+    trace "cancelled sending goAway", description = exc.msg
   except LPStreamError as exc:
-    trace "failed to send goAway", msg = exc.msg
+    trace "failed to send goAway", description = exc.msg
   await m.connection.close()
   trace "Closed yamux"
 
@@ -601,7 +601,7 @@ method handle*(m: Yamux) {.async: (raises: []).} =
           if header.length > 0:
             var buffer = newSeqUninitialized[byte](header.length)
             await m.connection.readExactly(addr buffer[0], int(header.length))
-            trace "Msg Rcv", msg = shortLog(buffer)
+            trace "Msg Rcv", description = shortLog(buffer)
             await channel.gotDataFromRemote(buffer)
 
         if MsgFlags.Fin in header.flags:
@@ -611,19 +611,19 @@ method handle*(m: Yamux) {.async: (raises: []).} =
           trace "remote reset channel"
           await channel.reset()
   except CancelledError as exc:
-    debug "Unexpected cancellation in yamux handler", msg = exc.msg
+    debug "Unexpected cancellation in yamux handler", description = exc.msg
   except LPStreamEOFError as exc:
-    trace "Stream EOF", msg = exc.msg
+    trace "Stream EOF", description = exc.msg
   except LPStreamError as exc:
-    debug "Unexpected stream exception in yamux read loop", msg = exc.msg
+    debug "Unexpected stream exception in yamux read loop", description = exc.msg
   except YamuxError as exc:
-    trace "Closing yamux connection", error = exc.msg
+    trace "Closing yamux connection", description = exc.msg
     try:
       await m.connection.write(YamuxHeader.goAway(ProtocolError))
     except CancelledError, LPStreamError:
       discard
   except MuxerError as exc:
-    debug "Unexpected muxer exception in yamux read loop", msg = exc.msg
+    debug "Unexpected muxer exception in yamux read loop", description = exc.msg
     try:
       await m.connection.write(YamuxHeader.goAway(ProtocolError))
     except CancelledError, LPStreamError:

libp2p/nameresolving/dnsresolver.nim

@@ -41,7 +41,7 @@ proc questionToBuf(address: string, kind: QKind): seq[byte] =
     discard requestStream.readData(addr buf[0], dataLen)
     return buf
   except CatchableError as exc:
-    info "Failed to created DNS buffer", msg = exc.msg
+    info "Failed to created DNS buffer", description = exc.msg
     return newSeq[byte](0)
 
 proc getDnsResponse(

libp2p/protocols/connectivity/autonat/server.nim

@@ -84,13 +84,13 @@ proc tryDial(autonat: Autonat, conn: Connection, addrs: seq[MultiAddress]) {.asy
   except CancelledError as exc:
     raise exc
   except AllFuturesFailedError as exc:
-    debug "All dial attempts failed", addrs, exc = exc.msg
+    debug "All dial attempts failed", addrs, description = exc.msg
     await conn.sendResponseError(DialError, "All dial attempts failed")
   except AsyncTimeoutError as exc:
-    debug "Dial timeout", addrs, exc = exc.msg
+    debug "Dial timeout", addrs, description = exc.msg
     await conn.sendResponseError(DialError, "Dial timeout")
   except CatchableError as exc:
-    debug "Unexpected error", addrs, exc = exc.msg
+    debug "Unexpected error", addrs, description = exc.msg
     await conn.sendResponseError(DialError, "Unexpected error")
   finally:
     autonat.sem.release()
@@ -165,7 +165,7 @@ proc new*(
     except CancelledError as exc:
       raise exc
     except CatchableError as exc:
-      debug "exception in autonat handler", exc = exc.msg, conn
+      debug "exception in autonat handler", description = exc.msg, conn
     finally:
       trace "exiting autonat handler", conn
       await conn.close()

libp2p/protocols/connectivity/autonat/service.nim

@@ -146,13 +146,13 @@ proc askPeer(
       debug "dialMe answer is reachable"
       Reachable
     except AutonatUnreachableError as error:
-      debug "dialMe answer is not reachable", msg = error.msg
+      debug "dialMe answer is not reachable", description = error.msg
       NotReachable
     except AsyncTimeoutError as error:
-      debug "dialMe timed out", msg = error.msg
+      debug "dialMe timed out", description = error.msg
       Unknown
     except CatchableError as error:
-      debug "dialMe unexpected error", msg = error.msg
+      debug "dialMe unexpected error", description = error.msg
       Unknown
   let hasReachabilityOrConfidenceChanged = await self.handleAnswer(ans)
   if hasReachabilityOrConfidenceChanged:
@@ -194,7 +194,7 @@ proc addressMapper(
         processedMA = peerStore.guessDialableAddr(listenAddr)
           # handle manual port forwarding
     except CatchableError as exc:
-      debug "Error while handling address mapper", msg = exc.msg
+      debug "Error while handling address mapper", description = exc.msg
     addrs.add(processedMA)
   return addrs
 

libp2p/protocols/connectivity/dcutr/client.nim

@@ -88,23 +88,23 @@ proc startSync*(
     raise err
   except AllFuturesFailedError as err:
     debug "Dcutr initiator could not connect to the remote peer, all connect attempts failed",
-      peerDialableAddrs, msg = err.msg
+      peerDialableAddrs, description = err.msg
     raise newException(
       DcutrError,
       "Dcutr initiator could not connect to the remote peer, all connect attempts failed",
       err,
     )
   except AsyncTimeoutError as err:
     debug "Dcutr initiator could not connect to the remote peer, all connect attempts timed out",
-      peerDialableAddrs, msg = err.msg
+      peerDialableAddrs, description = err.msg
     raise newException(
       DcutrError,
       "Dcutr initiator could not connect to the remote peer, all connect attempts timed out",
       err,
     )
   except CatchableError as err:
     debug "Unexpected error when Dcutr initiator tried to connect to the remote peer",
-      err = err.msg
+      description = err.msg
     raise newException(
       DcutrError,
       "Unexpected error when Dcutr initiator tried to connect to the remote peer", err,

libp2p/protocols/connectivity/dcutr/server.nim

@@ -80,13 +80,13 @@ proc new*(
       raise err
     except AllFuturesFailedError as err:
       debug "Dcutr receiver could not connect to the remote peer, " &
-        "all connect attempts failed", peerDialableAddrs, msg = err.msg
+        "all connect attempts failed", peerDialableAddrs, description = err.msg
     except AsyncTimeoutError as err:
       debug "Dcutr receiver could not connect to the remote peer, " &
-        "all connect attempts timed out", peerDialableAddrs, msg = err.msg
+        "all connect attempts timed out", peerDialableAddrs, description = err.msg
     except CatchableError as err:
       warn "Unexpected error when Dcutr receiver tried to connect " &
-        "to the remote peer", msg = err.msg
+        "to the remote peer", description = err.msg
 
   let self = T()
   self.handler = handleStream

libp2p/protocols/connectivity/relay/client.nim

@@ -93,7 +93,7 @@ proc reserve*(
       except CancelledError as exc:
         raise exc
       except CatchableError as exc:
-        trace "error writing or reading reservation message", exc = exc.msg
+        trace "error writing or reading reservation message", description = exc.msg
         raise newException(ReservationError, exc.msg)
 
   if msg.msgType != HopMessageType.Status:
@@ -139,7 +139,7 @@ proc dialPeerV1*(
   except CancelledError as exc:
     raise exc
   except CatchableError as exc:
-    trace "error writing hop request", exc = exc.msg
+    trace "error writing hop request", description = exc.msg
     raise exc
 
   let msgRcvFromRelayOpt =
@@ -148,7 +148,7 @@ proc dialPeerV1*(
     except CancelledError as exc:
       raise exc
     except CatchableError as exc:
-      trace "error reading stop response", exc = exc.msg
+      trace "error reading stop response", description = exc.msg
       await sendStatus(conn, StatusV1.HopCantOpenDstStream)
       raise exc
 
@@ -190,13 +190,13 @@ proc dialPeerV2*(
     except CancelledError as exc:
       raise exc
     except CatchableError as exc:
-      trace "error reading stop response", exc = exc.msg
+      trace "error reading stop response", description = exc.msg
       raise newException(RelayV2DialError, exc.msg)
 
   if msgRcvFromRelay.msgType != HopMessageType.Status:
     raise newException(RelayV2DialError, "Unexpected stop response")
   if msgRcvFromRelay.status.get(UnexpectedMessage) != Ok:
-    trace "Relay stop failed", msg = msgRcvFromRelay.status
+    trace "Relay stop failed", description = msgRcvFromRelay.status
     raise newException(RelayV2DialError, "Relay stop failure")
   conn.limitDuration = msgRcvFromRelay.limit.duration
   conn.limitData = msgRcvFromRelay.limit.data
@@ -302,7 +302,7 @@ proc new*(
     except CancelledError as exc:
       raise exc
     except CatchableError as exc:
-      trace "exception in client handler", exc = exc.msg, conn
+      trace "exception in client handler", description = exc.msg, conn
     finally:
       trace "exiting client handler", conn
       await conn.close()