Add more labels to tx_latency_* metrics

Author: romac

relayer/src/link/pending.rs

@@ -242,7 +242,14 @@ impl<Chain: ChainHandle> PendingTxs<Chain> {
                         "transactions confirmed",
                     );
 
-                    telemetry!(tx_confirmed, &self.chain_id(), pending.tracking_id());
+                    telemetry!(
+                        tx_confirmed,
+                        pending.tracking_id(),
+                        &self.chain.id(),
+                        &self.channel_id,
+                        &self.port_id,
+                        &self.counterparty_chain_id
+                    );
 
                     // Convert the events to RelaySummary and return them.
                     let mut summary = RelaySummary::from_events(events);

relayer/src/link/relay_path.rs

@@ -682,17 +682,21 @@ impl<ChainA: ChainHandle, ChainB: ChainHandle> RelayPath<ChainA, ChainB> {
 
         let msgs = odata.assemble_msgs(self)?;
 
-        match odata.target {
-            OperationalDataTarget::Source => {
-                telemetry!(tx_submitted, &self.src_chain().id(), msgs.tracking_id);
-
-                S::submit(self.src_chain(), msgs)
-            }
-            OperationalDataTarget::Destination => {
-                telemetry!(tx_submitted, &self.dst_chain().id(), msgs.tracking_id);
+        telemetry!({
+            let (chain, counterparty, channel_id, port_id) = self.target_info(odata.target);
+
+            ibc_telemetry::global().tx_submitted(
+                msgs.tracking_id,
+                &chain,
+                channel_id,
+                port_id,
+                &counterparty,
+            );
+        });
 
-                S::submit(self.dst_chain(), msgs)
-            }
+        match odata.target {
+            OperationalDataTarget::Source => S::submit(self.src_chain(), msgs),
+            OperationalDataTarget::Destination => S::submit(self.dst_chain(), msgs),
         }
     }
 
@@ -1680,4 +1684,31 @@ impl<ChainA: ChainHandle, ChainB: ChainHandle> RelayPath<ChainA, ChainB> {
             self.src_chain().clone(),
         )
     }
+
+    // we need fully qualified ChainId to avoid unneeded imports warnings
+    #[cfg(feature = "telemetry")]
+    fn target_info(
+        &self,
+        target: OperationalDataTarget,
+    ) -> (
+        ibc::core::ics24_host::identifier::ChainId, // source chain
+        ibc::core::ics24_host::identifier::ChainId, // destination chain
+        &ChannelId,
+        &PortId,
+    ) {
+        match target {
+            OperationalDataTarget::Source => (
+                self.src_chain().id(),
+                self.dst_chain().id(),
+                &self.src_channel_id,
+                &self.src_port_id,
+            ),
+            OperationalDataTarget::Destination => (
+                self.dst_chain().id(),
+                self.src_chain().id(),
+                &self.dst_channel_id,
+                &self.dst_port_id,
+            ),
+        }
+    }
 }

telemetry/src/state.rs

@@ -226,30 +226,51 @@ impl TelemetryState {
             .insert(tracking_id.to_string(), Instant::now());
     }
 
-    pub fn tx_submitted(&self, chain_id: &ChainId, tracking_id: impl ToString) {
+    pub fn tx_submitted(
+        &self,
+
+        tracking_id: impl ToString,
+        chain_id: &ChainId,
+        channel_id: &ChannelId,
+        port_id: &PortId,
+        counterparty_chain_id: &ChainId,
+    ) {
         let tracking_id = tracking_id.to_string();
 
         if let Some(start) = self.in_flight_events.get(&tracking_id) {
             let latency = start.elapsed().as_millis() as u64;
 
             let labels = &[
-                KeyValue::new("chain", chain_id.to_string()),
                 KeyValue::new("tracking_id", tracking_id),
+                KeyValue::new("chain", chain_id.to_string()),
+                KeyValue::new("counterparty", counterparty_chain_id.to_string()),
+                KeyValue::new("channel", channel_id.to_string()),
+                KeyValue::new("port", port_id.to_string()),
             ];
 
             self.tx_latency_submitted.record(latency, labels);
         }
     }
 
-    pub fn tx_confirmed(&self, chain_id: &ChainId, tracking_id: impl ToString) {
+    pub fn tx_confirmed(
+        &self,
+        tracking_id: impl ToString,
+        chain_id: &ChainId,
+        channel_id: &ChannelId,
+        port_id: &PortId,
+        counterparty_chain_id: &ChainId,
+    ) {
         let tracking_id = tracking_id.to_string();
 
         if let Some(start) = self.in_flight_events.get(&tracking_id) {
             let latency = start.elapsed().as_millis() as u64;
 
             let labels = &[
-                KeyValue::new("chain", chain_id.to_string()),
                 KeyValue::new("tracking_id", tracking_id),
+                KeyValue::new("chain", chain_id.to_string()),
+                KeyValue::new("counterparty", counterparty_chain_id.to_string()),
+                KeyValue::new("channel", channel_id.to_string()),
+                KeyValue::new("port", port_id.to_string()),
             ];
 
             self.tx_latency_confirmed.record(latency, labels);