diff --git a/packages/connection-encrypter-plaintext/src/index.ts b/packages/connection-encrypter-plaintext/src/index.ts
index cc4c2d3a6e..d809f2b9fa 100644
--- a/packages/connection-encrypter-plaintext/src/index.ts
+++ b/packages/connection-encrypter-plaintext/src/index.ts
@@ -104,8 +104,8 @@ class Plaintext implements ConnectionEncrypter {
         throw new InvalidCryptoExchangeError('Public key did not match id')
       }
     } catch (err: any) {
-      log.error(err)
-      throw new InvalidCryptoExchangeError('Invalid public key - ' + err.message)
+      log.error('invalid public key - %e', err)
+      throw new InvalidCryptoExchangeError(`Invalid public key - ${err.message}`)
     }
 
     if (options?.remotePeer != null && !peerId.equals(options?.remotePeer)) {
diff --git a/packages/connection-encrypter-tls/src/tls.ts b/packages/connection-encrypter-tls/src/tls.ts
index c76eba7eac..1931ea4d56 100644
--- a/packages/connection-encrypter-tls/src/tls.ts
+++ b/packages/connection-encrypter-tls/src/tls.ts
@@ -179,7 +179,7 @@ export class TLS implements ConnectionEncrypter {
 
               if (streamMuxer == null) {
                 const err = new InvalidCryptoExchangeError(`Selected muxer ${socket.alpnProtocol} did not exist`)
-                log.error(`Selected muxer ${socket.alpnProtocol} did not exist - %e`, err)
+                log.error('selected muxer %s did not exist - %e', socket.alpnProtocol, err)
 
                 connection.abort(err)
                 reject(err)
diff --git a/packages/floodsub/src/floodsub.ts b/packages/floodsub/src/floodsub.ts
index dcea815579..d6ec49bdd0 100644
--- a/packages/floodsub/src/floodsub.ts
+++ b/packages/floodsub/src/floodsub.ts
@@ -341,7 +341,7 @@ export class FloodSub extends TypedEventEmitter<FloodSubEvents> implements Flood
 
           await this.processMessage(peerStream.peerId, msg)
         } catch (err: any) {
-          this.log.error(err)
+          this.log.error('failed to queue messages from %p - %e', peerStream.peerId, err)
         }
       }))
         .catch(err => { this.log(err) })
@@ -466,15 +466,15 @@ export class FloodSub extends TypedEventEmitter<FloodSubEvents> implements Flood
    * Send an rpc object to a peer
    */
   sendRpc (peer: PeerId, rpc: PubSubRPC): void {
-    const peerStream = this.peers.get(peer)
+    const peerStreams = this.peers.get(peer)
 
-    if (peerStream == null) {
-      this.log.error('Cannot send RPC to %p as there are no streams to it available', peer)
+    if (peerStreams == null) {
+      this.log.error('cannot send RPC to %p as there are no streams to it available', peer)
 
       return
     }
 
-    peerStream.write(rpc)
+    peerStreams.write(rpc)
   }
 
   /**
diff --git a/packages/kad-dht/src/content-fetching/index.ts b/packages/kad-dht/src/content-fetching/index.ts
index b7e919d24d..c858c2dda0 100644
--- a/packages/kad-dht/src/content-fetching/index.ts
+++ b/packages/kad-dht/src/content-fetching/index.ts
@@ -106,7 +106,7 @@ export class ContentFetching {
           this.log(`Storing corrected record for key ${dsKey.toString()}`)
           await this.components.datastore.put(dsKey, fixupRec.subarray(), options)
         } catch (err: any) {
-          this.log.error('Failed error correcting self', err)
+          this.log.error('failed error correcting self - %e', err)
         }
 
         continue
@@ -132,7 +132,7 @@ export class ContentFetching {
         throw new QueryError('Could not send correction')
       }
 
-      this.log.error('Failed error correcting entry')
+      this.log.error('failed error correcting entry')
     }
   }
 
diff --git a/packages/kad-dht/src/content-routing/index.ts b/packages/kad-dht/src/content-routing/index.ts
index 6e30bdba06..8039c7c968 100644
--- a/packages/kad-dht/src/content-routing/index.ts
+++ b/packages/kad-dht/src/content-routing/index.ts
@@ -115,7 +115,7 @@ export class ContentRouting {
           yield addProviderEvent
         }
       } catch (err: any) {
-        self.log.error('error sending provide record to peer %p', event.peer.id, err)
+        self.log.error('error sending provide record to peer %p - %e', event.peer.id, err)
         yield queryErrorEvent({
           from: event.peer.id,
           error: err,
diff --git a/packages/kad-dht/src/kad-dht.ts b/packages/kad-dht/src/kad-dht.ts
index 7c2b355afe..6ab6d68e40 100644
--- a/packages/kad-dht/src/kad-dht.ts
+++ b/packages/kad-dht/src/kad-dht.ts
@@ -298,7 +298,7 @@ export class KadDHT extends TypedEventEmitter<PeerDiscoveryEvents> implements Ka
       const peerData = evt.detail
 
       this.onPeerConnect(peerData).catch(err => {
-        this.log.error('could not add %p to routing table', peerData.id, err)
+        this.log.error('could not add %p to routing table - %e', peerData.id, err)
       })
 
       this.dispatchEvent(new CustomEvent('peer', {
@@ -321,7 +321,7 @@ export class KadDHT extends TypedEventEmitter<PeerDiscoveryEvents> implements Ka
 
         await this.onPeerConnect(peerData)
       }).catch(err => {
-        this.log.error('could not add %p to routing table - %e - %e', peerId, err)
+        this.log.error('could not add %p to routing table - %e', peerId, err)
       })
     })
 
@@ -350,7 +350,7 @@ export class KadDHT extends TypedEventEmitter<PeerDiscoveryEvents> implements Ka
           }
         })
           .catch(err => {
-            this.log.error('error setting dht server mode', err)
+            this.log.error('error setting dht server mode - %e', err)
           })
       })
     }
@@ -407,7 +407,7 @@ export class KadDHT extends TypedEventEmitter<PeerDiscoveryEvents> implements Ka
         signal
       })
     } catch (err: any) {
-      this.log.error('could not add %p to routing table', peerData.id, err)
+      this.log.error('could not add %p to routing table - %e', peerData.id, err)
     }
   }
 
diff --git a/packages/kad-dht/src/network.ts b/packages/kad-dht/src/network.ts
index 7955bc07c3..5ea7c9f349 100644
--- a/packages/kad-dht/src/network.ts
+++ b/packages/kad-dht/src/network.ts
@@ -186,7 +186,7 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
 
       stream.close(options)
         .catch(err => {
-          this.log.error('error closing stream to %p', to, err)
+          this.log.error('error closing stream to %p - %e', to, err)
           stream?.abort(err)
         })
 
@@ -252,7 +252,7 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
 
       stream.close(options)
         .catch(err => {
-          this.log.error('error closing stream to %p', to, err)
+          this.log.error('error closing stream to %p - %e', to, err)
           stream?.abort(err)
         })
 
diff --git a/packages/kad-dht/src/query-self.ts b/packages/kad-dht/src/query-self.ts
index 339994603d..ed2b8a884f 100644
--- a/packages/kad-dht/src/query-self.ts
+++ b/packages/kad-dht/src/query-self.ts
@@ -76,7 +76,7 @@ export class QuerySelf implements Startable {
     this.timeoutId = setTimeout(() => {
       this.querySelf()
         .catch(err => {
-          this.log.error('error running self-query', err)
+          this.log.error('error running self-query - %e', err)
         })
     }, this.initialInterval)
   }
@@ -146,7 +146,7 @@ export class QuerySelf implements Startable {
           }
         }))
       } catch (err: any) {
-        this.log.error('self-query error', err)
+        this.log.error('self-query error - %e', err)
       } finally {
         signal.clear()
 
@@ -167,7 +167,7 @@ export class QuerySelf implements Startable {
     this.timeoutId = setTimeout(() => {
       this.querySelf()
         .catch(err => {
-          this.log.error('error running self-query', err)
+          this.log.error('error running self-query - %e', err)
         })
     }, this.interval)
   }
diff --git a/packages/kad-dht/src/query/manager.ts b/packages/kad-dht/src/query/manager.ts
index 34b8a55ff0..681c682fcf 100644
--- a/packages/kad-dht/src/query/manager.ts
+++ b/packages/kad-dht/src/query/manager.ts
@@ -217,7 +217,7 @@ export class QueryManager implements Startable {
       // Execute the query along each disjoint path and yield their results as they become available
       for await (const event of merge(...paths)) {
         if (event.name === 'QUERY_ERROR') {
-          log.error('query error', event.error)
+          log.error('query error - %e', event.error)
         }
 
         if (event.name === 'PEER_RESPONSE') {
diff --git a/packages/kad-dht/src/reprovider.ts b/packages/kad-dht/src/reprovider.ts
index af09ae6701..a38e86164a 100644
--- a/packages/kad-dht/src/reprovider.ts
+++ b/packages/kad-dht/src/reprovider.ts
@@ -152,7 +152,7 @@ export class Reprovider extends TypedEventEmitter<ReprovideEvents> {
               })
           }
         } catch (err: any) {
-          this.log.error('error processing datastore key %s - %e', entry.key, err.message)
+          this.log.error('error processing datastore key %s - %s', entry.key, err.message)
         }
       }
 
diff --git a/packages/kad-dht/src/routing-table/refresh.ts b/packages/kad-dht/src/routing-table/refresh.ts
index 7758f9a63d..f740ed2211 100644
--- a/packages/kad-dht/src/routing-table/refresh.ts
+++ b/packages/kad-dht/src/routing-table/refresh.ts
@@ -107,16 +107,16 @@ export class RoutingTableRefresh {
               try {
                 await this._refreshCommonPrefixLength(n, lastRefresh, force, options)
               } catch (err: any) {
-                this.log.error(err)
+                this.log.error('failed to refresh entries with common prefix length %d - %e', n, err)
               }
             }
           }
         } catch (err: any) {
-          this.log.error(err)
+          this.log.error('failed to refresh entries with common prefix length - %e', err)
         }
       })
     ).catch(err => {
-      this.log.error(err)
+      this.log.error('failed to refresh table - %e', err)
     }).then(() => {
       this.refreshTimeoutId = setTimeout(this.refreshTable, this.refreshInterval)
 
@@ -124,7 +124,7 @@ export class RoutingTableRefresh {
         this.refreshTimeoutId.unref()
       }
     }).catch(err => {
-      this.log.error(err)
+      this.log.error('failed to set refresh timeout - %e', err)
     })
   }
 
diff --git a/packages/kad-dht/src/rpc/handlers/put-value.ts b/packages/kad-dht/src/rpc/handlers/put-value.ts
index 156e65da49..0cb9649bed 100644
--- a/packages/kad-dht/src/rpc/handlers/put-value.ts
+++ b/packages/kad-dht/src/rpc/handlers/put-value.ts
@@ -39,10 +39,8 @@ export class PutValueHandler implements DHTMessageHandler {
     this.log('%p asked us to store value for key %b', peerId, key)
 
     if (msg.record == null) {
-      const errMsg = `Empty record from: ${peerId.toString()}`
-
-      this.log.error(errMsg)
-      throw new InvalidMessageError(errMsg)
+      this.log.error('empty record from %p', peerId)
+      throw new InvalidMessageError(`Empty record from: ${peerId}`)
     }
 
     try {
diff --git a/packages/keychain/src/keychain.ts b/packages/keychain/src/keychain.ts
index 9f81151d46..97aed98ec6 100644
--- a/packages/keychain/src/keychain.ts
+++ b/packages/keychain/src/keychain.ts
@@ -175,7 +175,7 @@ export class Keychain implements KeychainInterface {
       return JSON.parse(uint8ArrayToString(res))
     } catch (err: any) {
       await randomDelay()
-      this.log.error(err)
+      this.log.error('could not read key from datastore - %e', err)
       throw new NotFoundError(`Key '${name}' does not exist.`)
     }
   }
diff --git a/packages/libp2p-daemon-client/src/index.ts b/packages/libp2p-daemon-client/src/index.ts
index f867b4b248..390414aef8 100644
--- a/packages/libp2p-daemon-client/src/index.ts
+++ b/packages/libp2p-daemon-client/src/index.ts
@@ -256,11 +256,11 @@ class Client implements DaemonClient {
       .finally(() => {
         connection.close()
           .catch(err => {
-            log.error(err)
+            log.error('error closing connection - %e', err)
           })
         listener.close()
           .catch(err => {
-            log.error(err)
+            log.error('error closing listener - %e', err)
           })
       })
   }
diff --git a/packages/libp2p-daemon-server/src/dht.ts b/packages/libp2p-daemon-server/src/dht.ts
index 57536dbc53..435a504de7 100644
--- a/packages/libp2p-daemon-server/src/dht.ts
+++ b/packages/libp2p-daemon-server/src/dht.ts
@@ -30,7 +30,7 @@ export class DHTOperations {
       await drain(this.dht.provide(cid))
       yield OkResponse()
     } catch (err: any) {
-      log.error(err)
+      log.error('failed to provide CID %s - %e', cid, err)
       yield ErrorResponse(err)
     }
   }
@@ -73,7 +73,7 @@ export class DHTOperations {
         }
       }
     } catch (err: any) {
-      log.error(err)
+      log.error('error getting value for key %b - %e', key, err)
       yield ErrorResponse(err)
     }
   }
@@ -84,7 +84,7 @@ export class DHTOperations {
 
       yield OkResponse()
     } catch (err: any) {
-      log.error(err)
+      log.error('error putting value %b for key %b - %e', value, key, err)
       yield ErrorResponse(err)
     }
   }
@@ -107,7 +107,7 @@ export class DHTOperations {
 
       throw new Error('Peer not found')
     } catch (err: any) {
-      log.error(err)
+      log.error('peer not found %p - %e', peerId, err)
       yield ErrorResponse(err)
     }
   }
diff --git a/packages/libp2p-daemon-server/src/index.ts b/packages/libp2p-daemon-server/src/index.ts
index e354645c11..509a639929 100644
--- a/packages/libp2p-daemon-server/src/index.ts
+++ b/packages/libp2p-daemon-server/src/index.ts
@@ -179,7 +179,7 @@ export class Server implements Libp2pServer {
           stream
         )
       } catch (err: any) {
-        log.error(err)
+        log.error('error handling stream handler - %e', err)
 
         conn?.abort(err)
       } finally {
@@ -206,7 +206,7 @@ export class Server implements Libp2pServer {
 
   _onExit (): void {
     void this.stop({ exit: true }).catch(err => {
-      log.error(err)
+      log.error('failed to stop daemon during exit - %e', err)
     })
   }
 
@@ -262,7 +262,7 @@ export class Server implements Libp2pServer {
           throw new Error('ERR_INVALID_REQUEST_TYPE')
       }
     } catch (err: any) {
-      log.error(err)
+      log.error('error handling peerstore request - %e', err)
       yield ErrorResponse(err)
     }
   }
@@ -305,7 +305,7 @@ export class Server implements Libp2pServer {
           throw new Error('ERR_INVALID_REQUEST_TYPE')
       }
     } catch (err: any) {
-      log.error(err)
+      log.error('error handling pubsub request - %e', err)
       yield ErrorResponse(err)
     }
   }
@@ -373,7 +373,7 @@ export class Server implements Libp2pServer {
           throw new Error('ERR_INVALID_REQUEST_TYPE')
       }
     } catch (err: any) {
-      log.error(err)
+      log.error('error handling DHT request - %e', err)
       yield ErrorResponse(err)
     }
   }
@@ -521,7 +521,7 @@ export class Server implements Libp2pServer {
             throw new Error('ERR_INVALID_REQUEST_TYPE')
         }
       } catch (err: any) {
-        log.error(err)
+        log.error('error handling incoming connection - %e', err)
 
         // recreate pb stream in case the original was unwrapped already
         const conn = pb.unwrap()
@@ -547,7 +547,7 @@ export class Server implements Libp2pServer {
       }
     })
       .catch(err => {
-        log.error('error handling incoming connection', err)
+        log.error('error handling incoming connection - %e', err)
       })
   }
 }
diff --git a/packages/libp2p-daemon-server/src/pubsub.ts b/packages/libp2p-daemon-server/src/pubsub.ts
index 849132e8ee..05f41e3594 100644
--- a/packages/libp2p-daemon-server/src/pubsub.ts
+++ b/packages/libp2p-daemon-server/src/pubsub.ts
@@ -34,7 +34,7 @@ export class PubSubOperations {
         }
       })
     } catch (err: any) {
-      log.error(err)
+      log.error('failed to get pubsub topics - %e', err)
       yield ErrorResponse(err)
     }
   }
@@ -71,7 +71,7 @@ export class PubSubOperations {
       yield OkResponse()
       yield * onMessage
     } catch (err: any) {
-      log.error(err)
+      log.error('failed to subscribe to topic %s - %e', topic, err)
       yield ErrorResponse(err)
     }
   }
@@ -81,7 +81,7 @@ export class PubSubOperations {
       await this.pubsub.publish(topic, data)
       yield OkResponse()
     } catch (err: any) {
-      log.error(err)
+      log.error('failed to publish message to topic %s - %e', topic, err)
       yield ErrorResponse(err)
     }
   }
@@ -95,7 +95,7 @@ export class PubSubOperations {
         }
       })
     } catch (err: any) {
-      log.error(err)
+      log.error('failed to list peers for topic %s - %e', topic, err)
       yield ErrorResponse(err)
     }
   }
diff --git a/packages/libp2p/src/address-manager/index.ts b/packages/libp2p/src/address-manager/index.ts
index fd64b94fd3..bbe210a7c6 100644
--- a/packages/libp2p/src/address-manager/index.ts
+++ b/packages/libp2p/src/address-manager/index.ts
@@ -186,7 +186,7 @@ export class AddressManager implements AddressManagerInterface {
       multiaddrs: addrs
     })
       .catch(err => {
-        this.log.error('error updating addresses', err)
+        this.log.error('error updating addresses - %e', err)
       })
   }
 
diff --git a/packages/libp2p/src/connection-manager/connection-pruner.ts b/packages/libp2p/src/connection-manager/connection-pruner.ts
index c4d937cf95..f29e5d970c 100644
--- a/packages/libp2p/src/connection-manager/connection-pruner.ts
+++ b/packages/libp2p/src/connection-manager/connection-pruner.ts
@@ -48,7 +48,7 @@ export class ConnectionPruner {
   maybePruneConnections (): void {
     this._maybePruneConnections()
       .catch(err => {
-        this.log.error('error while pruning connections %e', err)
+        this.log.error('error while pruning connections - %e', err)
       })
   }
 
@@ -88,7 +88,7 @@ export class ConnectionPruner {
         }, 0))
       } catch (err: any) {
         if (err.name !== 'NotFoundError') {
-          this.log.error('error loading peer tags', err)
+          this.log.error('error loading peer tags - %e', err)
         }
       }
     }
diff --git a/packages/libp2p/src/connection-manager/dial-queue.ts b/packages/libp2p/src/connection-manager/dial-queue.ts
index fe9c669bc6..7ef478e27c 100644
--- a/packages/libp2p/src/connection-manager/dial-queue.ts
+++ b/packages/libp2p/src/connection-manager/dial-queue.ts
@@ -299,13 +299,13 @@ export class DialQueue {
               }
             })
           } catch (err: any) {
-            this.log.error('could not update last dial failure key for %p', peerId, err)
+            this.log.error('could not update last dial failure key for %p - %e', peerId, err)
           }
 
           // dial successful, return the connection
           return conn
         } catch (err: any) {
-          this.log.error('dial failed to %a', address.multiaddr, err)
+          this.log.error('dial failed to %a - %e', address.multiaddr, err)
 
           // ensure we don't dial it again in this attempt
           failedMultiaddrs.add(address.multiaddr.toString())
@@ -319,7 +319,7 @@ export class DialQueue {
                 }
               })
             } catch (err: any) {
-              this.log.error('could not update last dial failure key for %p', peerId, err)
+              this.log.error('could not update last dial failure key for %p - %e', peerId, err)
             }
           }
 
diff --git a/packages/libp2p/src/connection-manager/index.ts b/packages/libp2p/src/connection-manager/index.ts
index 8d0c49df0b..6dab30fa23 100644
--- a/packages/libp2p/src/connection-manager/index.ts
+++ b/packages/libp2p/src/connection-manager/index.ts
@@ -440,7 +440,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
 
   onConnect (evt: CustomEvent<Connection>): void {
     void this._onConnect(evt).catch(err => {
-      this.log.error(err)
+      this.log.error('could not connect - %e', err)
     })
   }
 
diff --git a/packages/libp2p/src/connection-manager/reconnect-queue.ts b/packages/libp2p/src/connection-manager/reconnect-queue.ts
index 5158f6ee73..70a0d6562a 100644
--- a/packages/libp2p/src/connection-manager/reconnect-queue.ts
+++ b/packages/libp2p/src/connection-manager/reconnect-queue.ts
@@ -139,13 +139,13 @@ export class ReconnectQueue implements Startable {
           keepAlivePeers.map(async peer => {
             await this.connectionManager.openConnection(peer.id)
               .catch(err => {
-                this.log.error(err)
+                this.log.error('could not open connection to keepalive peer - %e', err)
               })
           })
         )
       })
       .catch(err => {
-        this.log.error(err)
+        this.log.error('error reconnect to peers after start - %e', err)
       })
   }
 
diff --git a/packages/libp2p/src/connection-monitor.ts b/packages/libp2p/src/connection-monitor.ts
index f599b27093..1cf9cb010b 100644
--- a/packages/libp2p/src/connection-monitor.ts
+++ b/packages/libp2p/src/connection-monitor.ts
@@ -135,7 +135,7 @@ export class ConnectionMonitor implements Startable {
           }
         })
           .catch(err => {
-            this.log.error('error during heartbeat', err)
+            this.log.error('error during heartbeat - %e', err)
 
             if (this.abortConnectionOnPingFailure) {
               this.log.error('aborting connection due to ping failure')
diff --git a/packages/libp2p/src/libp2p.ts b/packages/libp2p/src/libp2p.ts
index 598f3e3c97..1530e965ca 100644
--- a/packages/libp2p/src/libp2p.ts
+++ b/packages/libp2p/src/libp2p.ts
@@ -239,7 +239,7 @@ export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter
       this.safeDispatchEvent('start', { detail: this })
       this.log('libp2p has started with peer id %p', this.peerId)
     } catch (err: any) {
-      this.log.error('An error occurred starting libp2p', err)
+      this.log.error('an error occurred starting libp2p - %e', err)
       // set status to 'started' so this.stop() will stop any running components
       this.status = 'started'
       await this.stop()
@@ -428,6 +428,6 @@ export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter
     void this.components.peerStore.merge(peer.id, {
       multiaddrs: peer.multiaddrs
     })
-      .catch(err => { this.log.error(err) })
+      .catch(err => { this.log.error('could not update multiaddrs of discovered peer - %e', err) })
   }
 }
diff --git a/packages/libp2p/src/peer-routing.ts b/packages/libp2p/src/peer-routing.ts
index 6cf435b86e..ad765e64ba 100644
--- a/packages/libp2p/src/peer-routing.ts
+++ b/packages/libp2p/src/peer-routing.ts
@@ -78,7 +78,7 @@ export class DefaultPeerRouting implements PeerRouting {
           try {
             yield await router.findPeer(id, options)
           } catch (err) {
-            self.log.error(err)
+            self.log.error('router failed to find peer - %e', err)
           }
         })())
     )
@@ -130,7 +130,7 @@ export class DefaultPeerRouting implements PeerRouting {
                   useCache: false
                 })
               } catch (err) {
-                self.log.error('could not find peer multiaddrs', err)
+                self.log.error('could not find peer multiaddrs - %e', err)
                 return
               }
             }
diff --git a/packages/libp2p/src/random-walk.ts b/packages/libp2p/src/random-walk.ts
index 8d1e353279..40777776f6 100644
--- a/packages/libp2p/src/random-walk.ts
+++ b/packages/libp2p/src/random-walk.ts
@@ -144,7 +144,7 @@ export class RandomWalk extends TypedEventEmitter<RandomWalkEvents> implements R
 
           this.log('walk iteration for %b and %d walkers finished, found %d peers', data, this.walkers, found)
         } catch (err) {
-          this.log.error('random walk errored', err)
+          this.log.error('random walk errored - %e', err)
 
           this.safeDispatchEvent('walk:error', {
             detail: err
@@ -155,7 +155,7 @@ export class RandomWalk extends TypedEventEmitter<RandomWalkEvents> implements R
       this.log('no walkers left, ended walk')
     })
       .catch(err => {
-        this.log.error('random walk errored', err)
+        this.log.error('random walk errored - %e', err)
       })
       .finally(() => {
         this.log('finished walk, found %d peers after %dms', found, Date.now() - start)
diff --git a/packages/libp2p/src/upgrader.ts b/packages/libp2p/src/upgrader.ts
index 1b7c6b84bb..8ec9692698 100644
--- a/packages/libp2p/src/upgrader.ts
+++ b/packages/libp2p/src/upgrader.ts
@@ -463,7 +463,7 @@ export class Upgrader implements UpgraderInterface {
       maConn.log('selected %s as muxer protocol', protocol)
       return muxerFactory
     } catch (err: any) {
-      maConn.log.error('error multiplexing outbound connection', err)
+      maConn.log.error('error multiplexing outbound connection - %e', err)
       throw new MuxerUnavailableError(String(err))
     }
   }
@@ -487,7 +487,7 @@ export class Upgrader implements UpgraderInterface {
       maConn.log('selected %s as muxer protocol', protocol)
       return muxerFactory
     } catch (err: any) {
-      maConn.log.error('error multiplexing inbound connection', err)
+      maConn.log.error('error multiplexing inbound connection - %e', err)
       throw err
     }
   }
diff --git a/packages/logger/README.md b/packages/logger/README.md
index a0dc2e07dd..32be65374b 100644
--- a/packages/logger/README.md
+++ b/packages/logger/README.md
@@ -37,7 +37,7 @@ try {
   // an operation
   log('something happened: %s', 'it was ok')
 } catch (err) {
-  log.error('something bad happened: %o', err)
+  log.error('something bad happened: %e', err)
 }
 
 log('with this peer: %p', {})
diff --git a/packages/logger/src/index.ts b/packages/logger/src/index.ts
index ff20b41673..13428fbed6 100644
--- a/packages/logger/src/index.ts
+++ b/packages/logger/src/index.ts
@@ -14,7 +14,7 @@
  *   // an operation
  *   log('something happened: %s', 'it was ok')
  * } catch (err) {
- *   log.error('something bad happened: %o', err)
+ *   log.error('something bad happened: %e', err)
  * }
  *
  * log('with this peer: %p', {})
diff --git a/packages/metrics-simple/src/index.ts b/packages/metrics-simple/src/index.ts
index b2064e2721..8215bbc84e 100644
--- a/packages/metrics-simple/src/index.ts
+++ b/packages/metrics-simple/src/index.ts
@@ -397,7 +397,7 @@ class SimpleMetrics implements Metrics, Startable {
       this.onMetrics(structuredClone(output))
     })
       .catch(err => {
-        log.error('could not invoke onMetrics callback', err)
+        log.error('could not invoke onMetrics callback - %e', err)
       })
   }
 
diff --git a/packages/peer-discovery-bootstrap/src/index.ts b/packages/peer-discovery-bootstrap/src/index.ts
index 607b506323..bed4c9e259 100644
--- a/packages/peer-discovery-bootstrap/src/index.ts
+++ b/packages/peer-discovery-bootstrap/src/index.ts
@@ -107,14 +107,14 @@ class Bootstrap extends TypedEventEmitter<PeerDiscoveryEvents> implements PeerDi
       .map(str => multiaddr(str))
       .filter(ma => {
         if (!P2P.matches(ma)) {
-          this.log.error('Invalid multiaddr')
+          this.log.error('invalid multiaddr %a', ma)
           return false
         }
 
         const peerIdStr = ma.getComponents().findLast(c => c.code === CODE_P2P)?.value
 
         if (peerIdStr == null) {
-          this.log.error('Invalid bootstrap multiaddr without peer id')
+          this.log.error('invalid bootstrap multiaddr without peer id')
           return false
         }
 
@@ -154,7 +154,7 @@ class Bootstrap extends TypedEventEmitter<PeerDiscoveryEvents> implements PeerDi
     this.timer = setTimeout(() => {
       void this._discoverBootstrapPeers()
         .catch(err => {
-          this.log.error(err)
+          this.log.error('failed to discover bootstrap peers - %e', err)
         })
     }, this.timeout)
   }
@@ -186,7 +186,7 @@ class Bootstrap extends TypedEventEmitter<PeerDiscoveryEvents> implements PeerDi
       this.safeDispatchEvent('peer', { detail: peerData })
       this.components.connectionManager.openConnection(peerData.id)
         .catch(err => {
-          this.log.error('could not dial bootstrap peer %p', peerData.id, err)
+          this.log.error('could not dial bootstrap peer %p - %e', peerData.id, err)
         })
     }
   }
diff --git a/packages/peer-discovery-mdns/src/mdns.ts b/packages/peer-discovery-mdns/src/mdns.ts
index b3f5228943..d34fb22300 100644
--- a/packages/peer-discovery-mdns/src/mdns.ts
+++ b/packages/peer-discovery-mdns/src/mdns.ts
@@ -122,16 +122,16 @@ export class MulticastDNS extends TypedEventEmitter<PeerDiscoveryEvents> impleme
         }))
       }
     } catch (err) {
-      this.log.error('Error processing peer response', err)
+      this.log.error('error processing peer response - %e', err)
     }
   }
 
   _onMdnsWarning (err: Error): void {
-    this.log.error('mdns warning', err)
+    this.log.error('mdns warning - %e', err)
   }
 
   _onMdnsError (err: Error): void {
-    this.log.error('mdns error', err)
+    this.log.error('mdns error - %e', err)
   }
 
   /**
diff --git a/packages/peer-discovery-mdns/src/query.ts b/packages/peer-discovery-mdns/src/query.ts
index 6d7c93e3d9..72c5974231 100644
--- a/packages/peer-discovery-mdns/src/query.ts
+++ b/packages/peer-discovery-mdns/src/query.ts
@@ -74,8 +74,8 @@ export function gotResponse (rsp: ResponsePacket, localPeerName: string, service
       id: peerIdFromString(peerId),
       multiaddrs: multiaddrs.map(addr => addr.decapsulateCode(CODE_P2P))
     }
-  } catch (e) {
-    options?.log.error('failed to parse mdns response', e)
+  } catch (err) {
+    options?.log.error('failed to parse mdns response - %e', err)
   }
 }
 
diff --git a/packages/protocol-autonat-v2/src/server.ts b/packages/protocol-autonat-v2/src/server.ts
index b2fb8381d5..2c82385f55 100644
--- a/packages/protocol-autonat-v2/src/server.ts
+++ b/packages/protocol-autonat-v2/src/server.ts
@@ -183,7 +183,7 @@ export class AutoNATv2Server implements Startable {
         ...options
       })
     } catch (err: any) {
-      this.log.error('failed to open connection to %a - %e', err, ma)
+      this.log.error('failed to open connection to %a - %e', ma, err)
 
       return DialStatus.E_DIAL_ERROR
     }
diff --git a/packages/protocol-autonat/src/autonat.ts b/packages/protocol-autonat/src/autonat.ts
index 165d7504cf..974994eb8d 100644
--- a/packages/protocol-autonat/src/autonat.ts
+++ b/packages/protocol-autonat/src/autonat.ts
@@ -271,7 +271,7 @@ export class AutoNATService implements Startable {
     const peer = dialRequest.peer
 
     if (peer?.id == null) {
-      this.log.error('PeerId missing from message')
+      this.log.error('peerId missing from message')
 
       return {
         type: Message.MessageType.DIAL_RESPONSE,
diff --git a/packages/protocol-dcutr/src/dcutr.ts b/packages/protocol-dcutr/src/dcutr.ts
index 1b2faaec7d..777df0abb5 100644
--- a/packages/protocol-dcutr/src/dcutr.ts
+++ b/packages/protocol-dcutr/src/dcutr.ts
@@ -88,7 +88,7 @@ export class DefaultDCUtRService implements Startable {
 
         this.upgradeInbound(connection)
           .catch(err => {
-            this.log.error('error during outgoing DCUtR attempt', err)
+            this.log.error('error during outgoing DCUtR attempt - %e', err)
           })
       }
     })
@@ -204,7 +204,7 @@ export class DefaultDCUtRService implements Startable {
 
         break
       } catch (err: any) {
-        this.log.error('error while attempting DCUtR on attempt %d of %d', i + 1, this.retries, err)
+        this.log.error('error while attempting DCUtR on attempt %d of %d - %e', i + 1, this.retries, err)
         stream?.abort(err)
 
         if (i === this.retries) {
@@ -270,7 +270,7 @@ export class DefaultDCUtRService implements Startable {
 
         return true
       } catch (err) {
-        this.log.error('unilateral connection upgrade to %p on addresses %a failed', relayedConnection.remotePeer, publicAddresses, err)
+        this.log.error('unilateral connection upgrade to %p on addresses %a failed - %e', relayedConnection.remotePeer, publicAddresses, err)
       }
     } else {
       this.log('peer %p has no public addresses, not attempting unilateral connection upgrade', relayedConnection.remotePeer)
diff --git a/packages/transport-circuit-relay-v2/src/server/index.ts b/packages/transport-circuit-relay-v2/src/server/index.ts
index 313fc3f338..00e9380cff 100644
--- a/packages/transport-circuit-relay-v2/src/server/index.ts
+++ b/packages/transport-circuit-relay-v2/src/server/index.ts
@@ -136,7 +136,7 @@ export class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> imp
         request
       }, options)
     } catch (err: any) {
-      this.log.error('error while handling hop', err)
+      this.log.error('error while handling hop - %e', err)
       await pbstr.pb(HopMessage).write({
         type: HopMessage.Type.STATUS,
         status: Status.MALFORMED_MESSAGE
@@ -276,7 +276,7 @@ export class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> imp
       request.peer.addrs.forEach(multiaddr)
       dstPeer = peerIdFromMultihash(Digest.decode(request.peer.id))
     } catch (err) {
-      this.log.error('invalid hop connect request via peer %p %s', connection.remotePeer, err)
+      this.log.error('invalid hop connect request via peer %p - %e', connection.remotePeer, err)
       await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.MALFORMED_MESSAGE }, options)
       return
     }
@@ -355,7 +355,7 @@ export class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> imp
     try {
       response = await stopstr.read(options)
     } catch (err) {
-      this.log.error('error parsing stop message response from %p', connection.remotePeer)
+      this.log.error('error parsing stop message response from %p - %e', connection.remotePeer, err)
     }
 
     if (response == null) {
diff --git a/packages/transport-circuit-relay-v2/src/transport/discovery.ts b/packages/transport-circuit-relay-v2/src/transport/discovery.ts
index 4754bf132a..83975408b3 100644
--- a/packages/transport-circuit-relay-v2/src/transport/discovery.ts
+++ b/packages/transport-circuit-relay-v2/src/transport/discovery.ts
@@ -177,7 +177,7 @@ export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> impl
             signal: this.discoveryController.signal
           })
             .catch(err => {
-              this.log.error('error opening connection to random peer %p', peer.id, err)
+              this.log.error('error opening connection to random peer %p - %e', peer.id, err)
             })
         }
 
@@ -187,7 +187,7 @@ export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> impl
       })
       .catch(err => {
         if (!this.discoveryController.signal.aborted) {
-          this.log.error('failed when finding relays on the network', err)
+          this.log.error('failed when finding relays on the network - %e', err)
         }
       })
   }
@@ -245,7 +245,7 @@ export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> impl
       signal: this.discoveryController.signal
     })
       .catch(err => {
-        this.log.error('error opening connection to discovered peer %p', evt.detail.id, err)
+        this.log.error('error opening connection to discovered peer %p - %e', evt.detail.id, err)
       })
   }
 
diff --git a/packages/transport-circuit-relay-v2/src/transport/index.ts b/packages/transport-circuit-relay-v2/src/transport/index.ts
index a9893d74c0..3d3315aa43 100644
--- a/packages/transport-circuit-relay-v2/src/transport/index.ts
+++ b/packages/transport-circuit-relay-v2/src/transport/index.ts
@@ -72,7 +72,7 @@ export class CircuitRelayTransport implements Transport<CircuitRelayDialEvents>
       this.reservationStore.addRelay(evt.detail, 'discovered')
         .catch(err => {
           if (err.name !== 'HadEnoughRelaysError' && err.name !== 'RelayQueueFullError') {
-            this.log.error('could not add discovered relay %p', evt.detail, err)
+            this.log.error('could not add discovered relay %p - %e', evt.detail, err)
           }
         })
     })
@@ -214,7 +214,7 @@ export class CircuitRelayTransport implements Transport<CircuitRelayDialEvents>
 
       return conn
     } catch (err: any) {
-      this.log.error('circuit relay dial to destination %p via relay %p failed', destinationPeer, relayPeer, err)
+      this.log.error('circuit relay dial to destination %p via relay %p failed - %e', destinationPeer, relayPeer, err)
       stream?.abort(err)
 
       throw err
@@ -269,7 +269,7 @@ export class CircuitRelayTransport implements Transport<CircuitRelayDialEvents>
           await this.components.transportManager.listen([connection.remoteAddr.encapsulate('/p2p-circuit')])
         } catch (err: any) {
           // failed to refresh our hitherto unknown relay reservation but allow the connection attempt anyway
-          this.log.error('failed to listen on a relay peer we were dialed via but did not have a reservation on', err)
+          this.log.error('failed to listen on a relay peer we were dialed via but did not have a reservation on - %e', err)
         }
       }
 
diff --git a/packages/transport-circuit-relay-v2/src/transport/reservation-store.ts b/packages/transport-circuit-relay-v2/src/transport/reservation-store.ts
index fd7c7ac167..7910f8ff11 100644
--- a/packages/transport-circuit-relay-v2/src/transport/reservation-store.ts
+++ b/packages/transport-circuit-relay-v2/src/transport/reservation-store.ts
@@ -161,7 +161,7 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
         this.#checkReservationCount()
       })
       .catch(err => {
-        this.log.error(err)
+        this.log.error('failed to clean up and redial old relays during afterStart - %e', err)
       })
   }
 
diff --git a/packages/transport-tcp/src/listener.ts b/packages/transport-tcp/src/listener.ts
index a75859fa8d..cbb08e0cc4 100644
--- a/packages/transport-tcp/src/listener.ts
+++ b/packages/transport-tcp/src/listener.ts
@@ -171,7 +171,7 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
         log: this.context.logger.forComponent('libp2p:tcp:connection')
       })
     } catch (err: any) {
-      this.log.error('inbound connection failed', err)
+      this.log.error('inbound connection failed - %e', err)
       this.metrics.errors?.increment({ [`${this.addr} inbound_to_connection`]: true })
       socket.destroy()
       return
@@ -199,9 +199,9 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
             // resume() will be called again every time a connection is
             // dropped, which acts as an eventual retry mechanism.
             // onListenError allows the consumer act on this.
-            this.resume().catch(e => {
-              this.log.error('error attempting to listen server once connection count under limit', e)
-              this.context.closeServerOnMaxConnections?.onListenError?.(e as Error)
+            this.resume().catch(err => {
+              this.log.error('error attempting to listen server once connection count under limit - %e', err)
+              this.context.closeServerOnMaxConnections?.onListenError?.(err as Error)
             })
           }
         })
@@ -215,7 +215,7 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
         }
       })
       .catch(async err => {
-        this.log.error('inbound connection upgrade failed', err)
+        this.log.error('inbound connection upgrade failed - %e', err)
         this.metrics.errors?.increment({ [`${this.addr} inbound_upgrade`]: true })
         this.sockets.delete(socket)
         maConn.abort(err)
diff --git a/packages/transport-tcp/src/tcp.ts b/packages/transport-tcp/src/tcp.ts
index 8550396b19..156347579d 100644
--- a/packages/transport-tcp/src/tcp.ts
+++ b/packages/transport-tcp/src/tcp.ts
@@ -102,7 +102,7 @@ export class TCP implements Transport<TCPDialEvents> {
       return await options.upgrader.upgradeOutbound(maConn, options)
     } catch (err: any) {
       this.metrics?.errors.increment({ outbound_upgrade: true })
-      this.log.error('error upgrading outbound connection', err)
+      this.log.error('error upgrading outbound connection - %e', err)
       maConn.abort(err)
       throw err
     }
diff --git a/packages/transport-webrtc/src/private-to-private/initiate-connection.ts b/packages/transport-webrtc/src/private-to-private/initiate-connection.ts
index 323a860946..2e8d895fdc 100644
--- a/packages/transport-webrtc/src/private-to-private/initiate-connection.ts
+++ b/packages/transport-webrtc/src/private-to-private/initiate-connection.ts
@@ -128,7 +128,7 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
 
     // create an offer
     const offerSdp = await peerConnection.createOffer().catch(err => {
-      log.error('could not execute createOffer', err)
+      log.error('could not execute createOffer - %e', err)
       throw new SDPHandshakeFailedError('Failed to set createOffer')
     })
 
@@ -143,7 +143,7 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
 
     // set offer as local description
     await peerConnection.setLocalDescription(offerSdp).catch(err => {
-      log.error('could not execute setLocalDescription', err)
+      log.error('could not execute setLocalDescription - %e', err)
       throw new SDPHandshakeFailedError('Failed to set localDescription')
     })
 
@@ -164,7 +164,7 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
 
     const answerSdp = new RTCSessionDescription({ type: 'answer', sdp: answerMessage.data })
     await peerConnection.setRemoteDescription(answerSdp).catch(err => {
-      log.error('could not execute setRemoteDescription', err)
+      log.error('could not execute setRemoteDescription - %e', err)
       throw new SDPHandshakeFailedError('Failed to set remoteDescription')
     })
 
@@ -214,7 +214,7 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
       muxerFactory
     }
   } catch (err: any) {
-    log.error('outgoing signaling error', err)
+    log.error('outgoing signaling error - %e', err)
 
     peerConnection.close()
     stream.abort(err)
diff --git a/packages/transport-webrtc/src/private-to-private/signaling-stream-handler.ts b/packages/transport-webrtc/src/private-to-private/signaling-stream-handler.ts
index d844496516..41d7f616c3 100644
--- a/packages/transport-webrtc/src/private-to-private/signaling-stream-handler.ts
+++ b/packages/transport-webrtc/src/private-to-private/signaling-stream-handler.ts
@@ -69,13 +69,13 @@ export async function handleIncomingStream (stream: Stream, connection: Connecti
     })
 
     await peerConnection.setRemoteDescription(offer).catch(err => {
-      log.error('could not execute setRemoteDescription', err)
+      log.error('could not execute setRemoteDescription - %e', err)
       throw new SDPHandshakeFailedError('Failed to set remoteDescription')
     })
 
     // create and write an SDP answer
     const answer = await peerConnection.createAnswer().catch(err => {
-      log.error('could not execute createAnswer', err)
+      log.error('could not execute createAnswer - %e', err)
       throw new SDPHandshakeFailedError('Failed to create answer')
     })
 
@@ -87,7 +87,7 @@ export async function handleIncomingStream (stream: Stream, connection: Connecti
     })
 
     await peerConnection.setLocalDescription(answer).catch(err => {
-      log.error('could not execute setLocalDescription', err)
+      log.error('could not execute setLocalDescription - %e', err)
       throw new SDPHandshakeFailedError('Failed to set localDescription')
     })
 
@@ -101,7 +101,7 @@ export async function handleIncomingStream (stream: Stream, connection: Connecti
     })
   } catch (err: any) {
     if (peerConnection.connectionState !== 'connected') {
-      log.error('error while handling signaling stream from peer %a', connection.remoteAddr, err)
+      log.error('error while handling signaling stream from peer %a - %e', connection.remoteAddr, err)
 
       peerConnection.close()
       throw err
diff --git a/packages/transport-webrtc/src/private-to-private/transport.ts b/packages/transport-webrtc/src/private-to-private/transport.ts
index ee0cc470f0..ace1163d89 100644
--- a/packages/transport-webrtc/src/private-to-private/transport.ts
+++ b/packages/transport-webrtc/src/private-to-private/transport.ts
@@ -114,7 +114,7 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
 
       this._onProtocol(stream, connection, signal)
         .catch(err => {
-          this.log.error('failed to handle incoming connect from %p', connection.remotePeer, err)
+          this.log.error('failed to handle incoming connect from %p - %e', connection.remotePeer, err)
         })
         .finally(() => {
           signal.clear()
@@ -249,7 +249,7 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
       // @ts-expect-error https://github.com/murat-dogan/node-datachannel/pull/370
       this._closeOnShutdown(peerConnection, webRTCConn)
     } catch (err: any) {
-      this.log.error('incoming signaling error', err)
+      this.log.error('incoming signaling error - %e', err)
 
       peerConnection.close()
       stream.abort(err)
@@ -262,7 +262,7 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
     const shutDownListener = (): void => {
       webRTCConn.close()
         .catch(err => {
-          this.log.error('could not close WebRTCMultiaddrConnection', err)
+          this.log.error('could not close WebRTCMultiaddrConnection - %e', err)
         })
     }
 
diff --git a/packages/transport-webrtc/src/private-to-public/listener.ts b/packages/transport-webrtc/src/private-to-public/listener.ts
index 1111716014..ed1c99abe6 100644
--- a/packages/transport-webrtc/src/private-to-public/listener.ts
+++ b/packages/transport-webrtc/src/private-to-public/listener.ts
@@ -160,7 +160,7 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
 
             this.incomingConnection(ufrag, remoteHost, remotePort, signal)
               .catch(err => {
-                this.log.error('error processing incoming STUN request', err)
+                this.log.error('error processing incoming STUN request - %e', err)
               })
               .finally(() => {
                 signal.clear()
diff --git a/packages/transport-webrtc/src/private-to-public/utils/connect.ts b/packages/transport-webrtc/src/private-to-public/utils/connect.ts
index c76b54995d..4538362a35 100644
--- a/packages/transport-webrtc/src/private-to-public/utils/connect.ts
+++ b/packages/transport-webrtc/src/private-to-public/utils/connect.ts
@@ -141,7 +141,7 @@ export async function connect (peerConnection: RTCPeerConnection | DirectRTCPeer
         case 'disconnected':
         case 'closed':
           maConn.close().catch((err) => {
-            options.log.error('error closing connection', err)
+            options.log.error('error closing connection - %e', err)
             maConn.abort(err)
           })
           break
diff --git a/packages/transport-webrtc/src/stream.ts b/packages/transport-webrtc/src/stream.ts
index 4eb6f650e8..2b3c101063 100644
--- a/packages/transport-webrtc/src/stream.ts
+++ b/packages/transport-webrtc/src/stream.ts
@@ -96,7 +96,7 @@ export class WebRTCStream extends AbstractStream {
       }
     })
       .catch(err => {
-        this.log.error('error processing incoming data channel messages', err)
+        this.log.error('error processing incoming data channel messages - %e', err)
       })
 
     // close when both writable ends are closed or an error occurs
diff --git a/packages/transport-webrtc/src/util.ts b/packages/transport-webrtc/src/util.ts
index 774c9261c9..379c37a070 100644
--- a/packages/transport-webrtc/src/util.ts
+++ b/packages/transport-webrtc/src/util.ts
@@ -77,7 +77,7 @@ export function drainAndClose (channel: RTCDataChannel, direction: string, drain
       }
     })
     .catch(err => {
-      options.log.error('error closing outbound stream', err)
+      options.log.error('error closing outbound stream - %e', err)
     })
 }
 
diff --git a/packages/transport-websockets/src/listener.ts b/packages/transport-websockets/src/listener.ts
index e7e367c761..6e746c9951 100644
--- a/packages/transport-websockets/src/listener.ts
+++ b/packages/transport-websockets/src/listener.ts
@@ -208,7 +208,7 @@ export class WebSocketListener extends TypedEventEmitter<ListenerEvents> impleme
         bufferedAmountPollInterval: this.bufferedAmountPollInterval
       })
     } catch (err: any) {
-      this.log.error('inbound connection failed', err)
+      this.log.error('inbound connection failed - %e', err)
       this.metrics.errors?.increment({ [`${this.addr} inbound_to_connection`]: true })
       socket.close()
       return
diff --git a/packages/transport-webtransport/src/index.ts b/packages/transport-webtransport/src/index.ts
index c67317a473..75f05ff5c1 100644
--- a/packages/transport-webtransport/src/index.ts
+++ b/packages/transport-webtransport/src/index.ts
@@ -154,7 +154,7 @@ class WebTransportTransport implements Transport<WebTransportDialEvents> {
           this.metrics?.dialerEvents.increment({ [metric]: true })
           wt.close()
         } catch (err) {
-          this.log.error('error closing wt session', err)
+          this.log.error('error closing wt session - %e', err)
         } finally {
           // This is how we specify the connection is closed and shouldn't be used.
           if (maConn != null) {
@@ -190,7 +190,7 @@ class WebTransportTransport implements Transport<WebTransportDialEvents> {
 
       // this promise resolves/throws when the session is closed
       wt.closed.catch((err: Error) => {
-        this.log.error('error on remote wt session close', err)
+        this.log.error('error on remote wt session close - %e', err)
       })
         .finally(() => {
           cleanUpWTSession('remote_close')
@@ -225,7 +225,7 @@ class WebTransportTransport implements Transport<WebTransportDialEvents> {
         skipProtection: true
       })
     } catch (err: any) {
-      this.log.error('caught wt session err', err)
+      this.log.error('caught wt session err - %e', err)
 
       if (authenticated) {
         cleanUpWTSession('upgrade_error')
diff --git a/packages/utils/src/mock-muxer.ts b/packages/utils/src/mock-muxer.ts
index 7790faa17e..c653033fb9 100644
--- a/packages/utils/src/mock-muxer.ts
+++ b/packages/utils/src/mock-muxer.ts
@@ -242,7 +242,7 @@ class MockMuxer extends AbstractStreamMuxer<MockMuxedStream> {
     }
 
     if (stream == null) {
-      this.log.error(`No stream found for ${message.id}`)
+      this.log.error(`no stream found for ${message.id}`)
       return
     }