Pre-create metrics registry before loop is started + administrative metrics (#848)

* administrative metrics

* fmt

* fix compilation

* fix compilation again

* and another one

* remove GenericLoopMetrics

* chttp -> isahc

* remove redundant marker

* not about price metrics

* fmt

bridges/relays/bin-substrate/src/cli/mod.rs

@@ -330,15 +330,16 @@ pub struct PrometheusParams {
 	pub prometheus_port: u16,
 }
 
-impl From<PrometheusParams> for Option<relay_utils::metrics::MetricsParams> {
-	fn from(cli_params: PrometheusParams) -> Option<relay_utils::metrics::MetricsParams> {
+impl From<PrometheusParams> for relay_utils::metrics::MetricsParams {
+	fn from(cli_params: PrometheusParams) -> relay_utils::metrics::MetricsParams {
 		if !cli_params.no_prometheus {
-			Some(relay_utils::metrics::MetricsParams {
+			Some(relay_utils::metrics::MetricsAddress {
 				host: cli_params.prometheus_host,
 				port: cli_params.prometheus_port,
 			})
+			.into()
 		} else {
-			None
+			None.into()
 		}
 	}
 }

bridges/relays/bin-substrate/src/cli/relay_headers.rs

@@ -15,6 +15,7 @@
 // along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
 
 use crate::cli::{PrometheusParams, SourceConnectionParams, TargetConnectionParams, TargetSigningParams};
+use crate::finality_pipeline::SubstrateFinalitySyncPipeline;
 use structopt::{clap::arg_enum, StructOpt};
 
 /// Start headers relayer process.
@@ -77,12 +78,13 @@ impl RelayHeaders {
 			let source_client = self.source.into_client::<Source>().await?;
 			let target_client = self.target.into_client::<Target>().await?;
 			let target_sign = self.target_sign.into_keypair::<Target>()?;
+			let metrics_params = Finality::customize_metrics(self.prometheus_params.into())?;
 
 			crate::finality_pipeline::run(
 				Finality::new(target_client.clone(), target_sign),
 				source_client,
 				target_client,
-				self.prometheus_params.into(),
+				metrics_params,
 			)
 			.await
 		})

bridges/relays/bin-substrate/src/finality_pipeline.rs

@@ -21,7 +21,7 @@ use crate::finality_target::SubstrateFinalityTarget;
 use bp_header_chain::justification::GrandpaJustification;
 use finality_relay::{FinalitySyncParams, FinalitySyncPipeline};
 use relay_substrate_client::{finality_source::FinalitySource, BlockNumberOf, Chain, Client, HashOf, SyncHeader};
-use relay_utils::BlockNumberBase;
+use relay_utils::{metrics::MetricsParams, BlockNumberBase};
 use sp_core::Bytes;
 use std::{fmt::Debug, marker::PhantomData, time::Duration};
 
@@ -41,6 +41,11 @@ pub trait SubstrateFinalitySyncPipeline: FinalitySyncPipeline {
 	/// Chain with GRANDPA bridge pallet.
 	type TargetChain: Chain;
 
+	/// Customize metrics exposed by headers sync loop.
+	fn customize_metrics(params: MetricsParams) -> anyhow::Result<MetricsParams> {
+		Ok(params)
+	}
+
 	/// Returns id of account that we're using to sign transactions at target chain.
 	fn transactions_author(&self) -> <Self::TargetChain as Chain>::AccountId;
 
@@ -107,7 +112,7 @@ pub async fn run<SourceChain, TargetChain, P>(
 	pipeline: P,
 	source_client: Client<SourceChain>,
 	target_client: Client<TargetChain>,
-	metrics_params: Option<relay_utils::metrics::MetricsParams>,
+	metrics_params: MetricsParams,
 ) -> anyhow::Result<()>
 where
 	P: SubstrateFinalitySyncPipeline<

bridges/relays/bin-substrate/src/rialto_millau/millau_messages_to_rialto.rs

@@ -29,7 +29,10 @@ use frame_support::dispatch::GetDispatchInfo;
 use messages_relay::message_lane::MessageLane;
 use relay_millau_client::{HeaderId as MillauHeaderId, Millau, SigningParams as MillauSigningParams};
 use relay_rialto_client::{HeaderId as RialtoHeaderId, Rialto, SigningParams as RialtoSigningParams};
-use relay_substrate_client::{Chain, TransactionSignScheme};
+use relay_substrate_client::{
+	metrics::{FloatStorageValueMetric, StorageProofOverheadMetric},
+	Chain, TransactionSignScheme,
+};
 use relay_utils::metrics::MetricsParams;
 use sp_core::{Bytes, Pair};
 use std::{ops::RangeInclusive, time::Duration};
@@ -135,7 +138,7 @@ pub async fn run(
 	rialto_client: RialtoClient,
 	rialto_sign: RialtoSigningParams,
 	lane_id: LaneId,
-	metrics_params: Option<MetricsParams>,
+	metrics_params: MetricsParams,
 ) -> Result<(), String> {
 	let stall_timeout = Duration::from_secs(5 * 60);
 	let relayer_id_at_millau = millau_sign.public().as_array_ref().clone().into();
@@ -185,9 +188,27 @@ pub async fn run(
 				max_messages_size_in_single_batch,
 			},
 		},
-		MillauSourceClient::new(millau_client, lane.clone(), lane_id, RIALTO_BRIDGE_INSTANCE),
+		MillauSourceClient::new(millau_client.clone(), lane.clone(), lane_id, RIALTO_BRIDGE_INSTANCE),
 		RialtoTargetClient::new(rialto_client, lane, lane_id, MILLAU_BRIDGE_INSTANCE),
-		metrics_params,
+		relay_utils::relay_metrics(
+			messages_relay::message_lane_loop::metrics_prefix::<MillauMessagesToRialto>(&lane_id),
+			metrics_params.address,
+		)
+		.standalone_metric(StorageProofOverheadMetric::new(
+			millau_client.clone(),
+			(bp_runtime::RIALTO_BRIDGE_INSTANCE, lane_id),
+			millau_runtime::rialto_messages::inbound_lane_data_key(&lane_id),
+			"millau_storage_proof_overhead".into(),
+			"Millau storage proof overhead".into(),
+		))?
+		.standalone_metric(FloatStorageValueMetric::<_, sp_runtime::FixedU128>::new(
+			millau_client,
+			sp_core::storage::StorageKey(millau_runtime::rialto_messages::RialtoToMillauConversionRate::key().to_vec()),
+			Some(millau_runtime::rialto_messages::INITIAL_RIALTO_TO_MILLAU_CONVERSION_RATE),
+			"millau_rialto_to_millau_conversion_rate".into(),
+			"Rialto to Millau tokens conversion rate (used by Rialto)".into(),
+		))?
+		.into_params(),
 		futures::future::pending(),
 	)
 	.await

bridges/relays/bin-substrate/src/rialto_millau/rialto_messages_to_millau.rs

@@ -29,7 +29,10 @@ use frame_support::dispatch::GetDispatchInfo;
 use messages_relay::message_lane::MessageLane;
 use relay_millau_client::{HeaderId as MillauHeaderId, Millau, SigningParams as MillauSigningParams};
 use relay_rialto_client::{HeaderId as RialtoHeaderId, Rialto, SigningParams as RialtoSigningParams};
-use relay_substrate_client::{Chain, TransactionSignScheme};
+use relay_substrate_client::{
+	metrics::{FloatStorageValueMetric, StorageProofOverheadMetric},
+	Chain, TransactionSignScheme,
+};
 use relay_utils::metrics::MetricsParams;
 use sp_core::{Bytes, Pair};
 use std::{ops::RangeInclusive, time::Duration};
@@ -135,7 +138,7 @@ pub async fn run(
 	millau_client: MillauClient,
 	millau_sign: MillauSigningParams,
 	lane_id: LaneId,
-	metrics_params: Option<MetricsParams>,
+	metrics_params: MetricsParams,
 ) -> Result<(), String> {
 	let stall_timeout = Duration::from_secs(5 * 60);
 	let relayer_id_at_rialto = rialto_sign.public().as_array_ref().clone().into();
@@ -184,9 +187,27 @@ pub async fn run(
 				max_messages_size_in_single_batch,
 			},
 		},
-		RialtoSourceClient::new(rialto_client, lane.clone(), lane_id, MILLAU_BRIDGE_INSTANCE),
+		RialtoSourceClient::new(rialto_client.clone(), lane.clone(), lane_id, MILLAU_BRIDGE_INSTANCE),
 		MillauTargetClient::new(millau_client, lane, lane_id, RIALTO_BRIDGE_INSTANCE),
-		metrics_params,
+		relay_utils::relay_metrics(
+			messages_relay::message_lane_loop::metrics_prefix::<RialtoMessagesToMillau>(&lane_id),
+			metrics_params.address,
+		)
+		.standalone_metric(StorageProofOverheadMetric::new(
+			rialto_client.clone(),
+			(bp_runtime::MILLAU_BRIDGE_INSTANCE, lane_id),
+			rialto_runtime::millau_messages::inbound_lane_data_key(&lane_id),
+			"rialto_storage_proof_overhead".into(),
+			"Rialto storage proof overhead".into(),
+		))?
+		.standalone_metric(FloatStorageValueMetric::<_, sp_runtime::FixedU128>::new(
+			rialto_client,
+			sp_core::storage::StorageKey(rialto_runtime::millau_messages::MillauToRialtoConversionRate::key().to_vec()),
+			Some(rialto_runtime::millau_messages::INITIAL_MILLAU_TO_RIALTO_CONVERSION_RATE),
+			"rialto_millau_to_rialto_conversion_rate".into(),
+			"Millau to Rialto tokens conversion rate (used by Millau)".into(),
+		))?
+		.into_params(),
 		futures::future::pending(),
 	)
 	.await

bridges/relays/bin-substrate/src/rialto_millau/westend_headers_to_millau.rs

@@ -22,6 +22,7 @@ use bp_header_chain::justification::GrandpaJustification;
 use codec::Encode;
 use relay_millau_client::{Millau, SigningParams as MillauSigningParams};
 use relay_substrate_client::{Chain, TransactionSignScheme};
+use relay_utils::metrics::{FloatJsonValueMetric, MetricsParams};
 use relay_westend_client::{SyncHeader as WestendSyncHeader, Westend};
 use sp_core::{Bytes, Pair};
 
@@ -33,6 +34,29 @@ impl SubstrateFinalitySyncPipeline for WestendFinalityToMillau {
 
 	type TargetChain = Millau;
 
+	fn customize_metrics(params: MetricsParams) -> anyhow::Result<MetricsParams> {
+		Ok(
+			relay_utils::relay_metrics(finality_relay::metrics_prefix::<Self>(), params.address)
+				// Polkadot/Kusama prices are added as metrics here, because atm we don't have Polkadot <-> Kusama
+				// relays, but we want to test metrics/dashboards in advance
+				.standalone_metric(FloatJsonValueMetric::new(
+					"https://api.coingecko.com/api/v3/simple/price?ids=Polkadot&vs_currencies=usd".into(),
+					"$.polkadot.usd".into(),
+					"polkadot_price".into(),
+					"Polkadot price in USD".into(),
+				))
+				.map_err(|e| anyhow::format_err!("{}", e))?
+				.standalone_metric(FloatJsonValueMetric::new(
+					"https://api.coingecko.com/api/v3/simple/price?ids=Kusama&vs_currencies=usd".into(),
+					"$.kusama.usd".into(),
+					"kusama_price".into(),
+					"Kusama price in USD".into(),
+				))
+				.map_err(|e| anyhow::format_err!("{}", e))?
+				.into_params(),
+		)
+	}
+
 	fn transactions_author(&self) -> bp_millau::AccountId {
 		self.target_sign.public().as_array_ref().clone().into()
 	}