Clean up and improve logs

modules/src/core/ics02_client/events.rs

@@ -100,16 +100,6 @@ impl From<Attributes> for Vec<Tag> {
     }
 }
 
-impl core::fmt::Display for Attributes {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
-        write!(
-            f,
-            "h: {}, cs_h: {}({})",
-            self.height, self.client_id, self.consensus_height
-        )
-    }
-}
-
 /// CreateClient event signals the creation of a new on-chain client (IBC client).
 #[derive(Debug, Serialize, Clone, PartialEq, Eq)]
 pub struct CreateClient(pub Attributes);
@@ -148,14 +138,8 @@ impl From<CreateClient> for AbciEvent {
     }
 }
 
-impl core::fmt::Display for CreateClient {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
-        write!(f, "{}", self.0)
-    }
-}
-
 /// UpdateClient event signals a recent update of an on-chain client (IBC Client).
-#[derive(Serialize, Clone, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct UpdateClient {
     pub common: Attributes,
     pub header: Option<AnyHeader>,
@@ -215,18 +199,6 @@ impl From<UpdateClient> for AbciEvent {
     }
 }
 
-impl core::fmt::Display for UpdateClient {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
-        write!(f, "{}", self.common)
-    }
-}
-
-impl core::fmt::Debug for UpdateClient {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "{}", self.common)
-    }
-}
-
 /// ClientMisbehaviour event signals the update of an on-chain client (IBC Client) with evidence of
 /// misbehaviour.
 #[derive(Debug, Serialize, Clone, PartialEq, Eq)]

modules/src/core/ics03_connection/events.rs

@@ -16,7 +16,7 @@ pub const CLIENT_ID_ATTRIBUTE_KEY: &str = "client_id";
 pub const COUNTERPARTY_CONN_ID_ATTRIBUTE_KEY: &str = "counterparty_connection_id";
 pub const COUNTERPARTY_CLIENT_ID_ATTRIBUTE_KEY: &str = "counterparty_client_id";
 
-#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Deserialize, Serialize)]
 pub struct Attributes {
     pub height: Height,
     pub connection_id: Option<ConnectionId>,
@@ -81,7 +81,7 @@ impl From<Attributes> for Vec<Tag> {
     }
 }
 
-#[derive(Debug, Serialize, Clone, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct OpenInit(Attributes);
 
 impl OpenInit {
@@ -121,7 +121,7 @@ impl From<OpenInit> for AbciEvent {
     }
 }
 
-#[derive(Debug, Serialize, Clone, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct OpenTry(Attributes);
 
 impl OpenTry {
@@ -161,7 +161,7 @@ impl From<OpenTry> for AbciEvent {
     }
 }
 
-#[derive(Debug, Serialize, Clone, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct OpenAck(Attributes);
 
 impl OpenAck {
@@ -201,7 +201,7 @@ impl From<OpenAck> for AbciEvent {
     }
 }
 
-#[derive(Debug, Serialize, Clone, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct OpenConfirm(Attributes);
 
 impl OpenConfirm {

modules/src/core/ics04_channel/events.rs

@@ -30,7 +30,7 @@ pub const PKT_TIMEOUT_HEIGHT_ATTRIBUTE_KEY: &str = "packet_timeout_height";
 pub const PKT_TIMEOUT_TIMESTAMP_ATTRIBUTE_KEY: &str = "packet_timeout_timestamp";
 pub const PKT_ACK_ATTRIBUTE_KEY: &str = "packet_ack";
 
-#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Deserialize, Serialize)]
 pub struct Attributes {
     pub height: Height,
     pub port_id: PortId,
@@ -183,7 +183,7 @@ pub trait EventType {
     fn event_type() -> IbcEventType;
 }
 
-#[derive(Debug, Serialize, Clone, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct OpenInit {
     pub height: Height,
     pub port_id: PortId,
@@ -233,7 +233,7 @@ impl EventType for OpenInit {
     }
 }
 
-#[derive(Debug, Serialize, Clone, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct OpenTry {
     pub height: Height,
     pub port_id: PortId,
@@ -282,7 +282,7 @@ impl EventType for OpenTry {
     }
 }
 
-#[derive(Debug, Serialize, Clone, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct OpenAck {
     pub height: Height,
     pub port_id: PortId,
@@ -336,7 +336,7 @@ impl EventType for OpenAck {
     }
 }
 
-#[derive(Debug, Serialize, Clone, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct OpenConfirm {
     pub height: Height,
     pub port_id: PortId,
@@ -386,7 +386,7 @@ impl EventType for OpenConfirm {
     }
 }
 
-#[derive(Debug, Serialize, Clone, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct CloseInit {
     pub height: Height,
     pub port_id: PortId,
@@ -459,25 +459,13 @@ impl From<CloseInit> for IbcEvent {
     }
 }
 
-impl core::fmt::Display for CloseInit {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
-        write!(
-            f,
-            "{} {} {:?}",
-            self.height(),
-            IbcEventType::CloseInitChannel.as_str(),
-            Attributes::from(self.clone())
-        )
-    }
-}
-
 impl EventType for CloseInit {
     fn event_type() -> IbcEventType {
         IbcEventType::CloseInitChannel
     }
 }
 
-#[derive(Debug, Serialize, Clone, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct CloseConfirm {
     pub height: Height,
     pub channel_id: Option<ChannelId>,
@@ -569,7 +557,7 @@ impl_from_ibc_to_abci_event!(
     CloseConfirm
 );
 
-#[derive(Serialize, Clone, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct SendPacket {
     pub height: Height,
     pub packet: Packet,
@@ -614,19 +602,7 @@ impl TryFrom<SendPacket> for AbciEvent {
     }
 }
 
-impl core::fmt::Display for SendPacket {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
-        write!(f, "SendPacket - h:{}, {}", self.height, self.packet)
-    }
-}
-
-impl core::fmt::Debug for SendPacket {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "SendPacket - h:{}, {}", self.height, self.packet)
-    }
-}
-
-#[derive(Debug, Serialize, Clone, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct ReceivePacket {
     pub height: Height,
     pub packet: Packet,
@@ -671,13 +647,7 @@ impl TryFrom<ReceivePacket> for AbciEvent {
     }
 }
 
-impl core::fmt::Display for ReceivePacket {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
-        write!(f, "ReceivePacket - h:{}, {}", self.height, self.packet)
-    }
-}
-
-#[derive(Serialize, Clone, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct WriteAcknowledgement {
     pub height: Height,
     pub packet: Packet,
@@ -732,27 +702,7 @@ impl TryFrom<WriteAcknowledgement> for AbciEvent {
     }
 }
 
-impl core::fmt::Display for WriteAcknowledgement {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
-        write!(
-            f,
-            "WriteAcknowledgement - h:{}, {}",
-            self.height, self.packet
-        )
-    }
-}
-
-impl core::fmt::Debug for WriteAcknowledgement {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(
-            f,
-            "WriteAcknowledgement - h:{}, {}",
-            self.height, self.packet
-        )
-    }
-}
-
-#[derive(Serialize, Clone, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct AcknowledgePacket {
     pub height: Height,
     pub packet: Packet,
@@ -791,19 +741,7 @@ impl TryFrom<AcknowledgePacket> for AbciEvent {
     }
 }
 
-impl core::fmt::Display for AcknowledgePacket {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
-        write!(f, "h:{}, {}", self.height, self.packet)
-    }
-}
-
-impl core::fmt::Debug for AcknowledgePacket {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "AcknowledgePacket - h:{}, {}", self.height, self.packet)
-    }
-}
-
-#[derive(Debug, Serialize, Clone, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct TimeoutPacket {
     pub height: Height,
     pub packet: Packet,
@@ -848,13 +786,7 @@ impl TryFrom<TimeoutPacket> for AbciEvent {
     }
 }
 
-impl core::fmt::Display for TimeoutPacket {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
-        write!(f, "TimeoutPacket - h:{}, {}", self.height, self.packet)
-    }
-}
-
-#[derive(Debug, Serialize, Clone, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct TimeoutOnClosePacket {
     pub height: Height,
     pub packet: Packet,
@@ -898,13 +830,3 @@ impl TryFrom<TimeoutOnClosePacket> for AbciEvent {
         })
     }
 }
-
-impl core::fmt::Display for TimeoutOnClosePacket {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
-        write!(
-            f,
-            "TimeoutOnClosePacket - h:{}, {}",
-            self.height, self.packet
-        )
-    }
-}

modules/src/events.rs

@@ -264,33 +264,33 @@ impl fmt::Display for IbcEvent {
         match self {
             IbcEvent::NewBlock(ev) => write!(f, "NewBlock({})", ev.height),
 
-            IbcEvent::CreateClient(ev) => write!(f, "CreateClientEv({})", ev),
-            IbcEvent::UpdateClient(ev) => write!(f, "UpdateClientEv({})", ev),
-            IbcEvent::UpgradeClient(ev) => write!(f, "UpgradeClientEv({:?})", ev),
-            IbcEvent::ClientMisbehaviour(ev) => write!(f, "ClientMisbehaviourEv({:?})", ev),
-
-            IbcEvent::OpenInitConnection(ev) => write!(f, "OpenInitConnectionEv({:?})", ev),
-            IbcEvent::OpenTryConnection(ev) => write!(f, "OpenTryConnectionEv({:?})", ev),
-            IbcEvent::OpenAckConnection(ev) => write!(f, "OpenAckConnectionEv({:?})", ev),
-            IbcEvent::OpenConfirmConnection(ev) => write!(f, "OpenConfirmConnectionEv({:?})", ev),
-
-            IbcEvent::OpenInitChannel(ev) => write!(f, "OpenInitChannelEv({:?})", ev),
-            IbcEvent::OpenTryChannel(ev) => write!(f, "OpenTryChannelEv({:?})", ev),
-            IbcEvent::OpenAckChannel(ev) => write!(f, "OpenAckChannelEv({:?})", ev),
-            IbcEvent::OpenConfirmChannel(ev) => write!(f, "OpenConfirmChannelEv({:?})", ev),
-            IbcEvent::CloseInitChannel(ev) => write!(f, "CloseInitChannelEv({})", ev),
-            IbcEvent::CloseConfirmChannel(ev) => write!(f, "CloseConfirmChannelEv({:?})", ev),
-
-            IbcEvent::SendPacket(ev) => write!(f, "SendPacketEv({})", ev),
-            IbcEvent::ReceivePacket(ev) => write!(f, "ReceivePacketEv({})", ev),
-            IbcEvent::WriteAcknowledgement(ev) => write!(f, "WriteAcknowledgementEv({})", ev),
-            IbcEvent::AcknowledgePacket(ev) => write!(f, "AcknowledgePacketEv({})", ev),
-            IbcEvent::TimeoutPacket(ev) => write!(f, "TimeoutPacketEv({})", ev),
-            IbcEvent::TimeoutOnClosePacket(ev) => write!(f, "TimeoutOnClosePacketEv({})", ev),
-
-            IbcEvent::AppModule(ev) => write!(f, "AppModuleEv({:?})", ev),
-
-            IbcEvent::ChainError(ev) => write!(f, "ChainErrorEv({})", ev),
+            IbcEvent::CreateClient(ev) => write!(f, "CreateClient({:?})", ev),
+            IbcEvent::UpdateClient(ev) => write!(f, "UpdateClient({:?})", ev),
+            IbcEvent::UpgradeClient(ev) => write!(f, "UpgradeClient({:?})", ev),
+            IbcEvent::ClientMisbehaviour(ev) => write!(f, "ClientMisbehaviour({:?})", ev),
+
+            IbcEvent::OpenInitConnection(ev) => write!(f, "OpenInitConnection({:?})", ev),
+            IbcEvent::OpenTryConnection(ev) => write!(f, "OpenTryConnection({:?})", ev),
+            IbcEvent::OpenAckConnection(ev) => write!(f, "OpenAckConnection({:?})", ev),
+            IbcEvent::OpenConfirmConnection(ev) => write!(f, "OpenConfirmConnection({:?})", ev),
+
+            IbcEvent::OpenInitChannel(ev) => write!(f, "OpenInitChannel({:?})", ev),
+            IbcEvent::OpenTryChannel(ev) => write!(f, "OpenTryChannel({:?})", ev),
+            IbcEvent::OpenAckChannel(ev) => write!(f, "OpenAckChannel({:?})", ev),
+            IbcEvent::OpenConfirmChannel(ev) => write!(f, "OpenConfirmChannel({:?})", ev),
+            IbcEvent::CloseInitChannel(ev) => write!(f, "CloseInitChannel({:?})", ev),
+            IbcEvent::CloseConfirmChannel(ev) => write!(f, "CloseConfirmChannel({:?})", ev),
+
+            IbcEvent::SendPacket(ev) => write!(f, "SendPacket({:?})", ev),
+            IbcEvent::ReceivePacket(ev) => write!(f, "ReceivePacket({:?})", ev),
+            IbcEvent::WriteAcknowledgement(ev) => write!(f, "WriteAcknowledgement({:?})", ev),
+            IbcEvent::AcknowledgePacket(ev) => write!(f, "AcknowledgePacket({:?})", ev),
+            IbcEvent::TimeoutPacket(ev) => write!(f, "TimeoutPacket({:?})", ev),
+            IbcEvent::TimeoutOnClosePacket(ev) => write!(f, "TimeoutOnClosePacket({:?})", ev),
+
+            IbcEvent::AppModule(ev) => write!(f, "AppModule({:?})", ev),
+
+            IbcEvent::ChainError(ev) => write!(f, "ChainError({})", ev),
         }
     }
 }

relayer-cli/src/commands/health.rs

@@ -16,23 +16,21 @@ impl Runnable for HealthCheckCmd {
         let config = (*app_config()).clone();
 
         for ch in &config.chains {
-            info!("[{}] performing health check...", ch.id);
+            let _span = tracing::error_span!("health_check", chain = %ch.id).entered();
+
+            info!("performing health check...");
 
             let chain =
                 spawn_chain_runtime(&config, &ch.id).unwrap_or_else(exit_with_unrecoverable_error);
 
             match chain.health_check() {
-                Ok(Healthy) => info!(chain = %ch.id, "chain is healthy"),
+                Ok(Healthy) => info!("chain is healthy"),
                 Ok(Unhealthy(_)) => {
                     // No need to print the error here as it's already printed in `Chain::health_check`
                     // TODO(romac): Move the printing code here and in the supervisor/registry
-                    warn!("[{}] chain is unhealthy", ch.id)
+                    warn!("chain is not healthy")
                 }
-                Err(e) => error!(
-                    "[{}] failed to perform health check, reason: {}",
-                    ch.id,
-                    e.detail()
-                ),
+                Err(e) => error!("failed to perform health check, reason: {}", e.detail()),
             }
         }