chore: refactored ledger metrics

node/src/extensions.rs

@@ -17,23 +17,17 @@ use midnight_primitives_ledger::{
 use sc_client_api::execution_extensions::ExtensionsFactory as ExtensionsFactoryT;
 use sp_externalities::Extensions;
 use sp_runtime::traits::{Block as BlockT, NumberFor};
-use std::{
-	marker::PhantomData,
-	sync::{Arc, Mutex},
-};
+use std::{marker::PhantomData, sync::Arc};
 
 /// Extensions factory
 pub struct ExtensionsFactory<Block> {
-	ledger_metrics: Arc<Mutex<Option<LedgerMetrics>>>,
+	ledger_metrics: Arc<Option<LedgerMetrics>>,
 	ledger_storage: LedgerStorage,
 	_marker: PhantomData<Block>,
 }
 
 impl<Block> ExtensionsFactory<Block> {
-	pub fn new(
-		ledger_metrics: Arc<Mutex<Option<LedgerMetrics>>>,
-		ledger_storage: LedgerStorage,
-	) -> Self {
+	pub fn new(ledger_metrics: Arc<Option<LedgerMetrics>>, ledger_storage: LedgerStorage) -> Self {
 		Self { ledger_metrics, ledger_storage, _marker: Default::default() }
 	}
 }

node/src/service.rs

@@ -53,11 +53,7 @@ use sp_runtime::{
 	traits::{Block as BlockT, Hash as HashT, HashingFor, Header as HeaderT, Zero},
 };
 use sp_runtime::{Digest, DigestItem};
-use std::{
-	marker::PhantomData,
-	sync::{Arc, Mutex},
-	time::Duration,
-};
+use std::{marker::PhantomData, sync::Arc, time::Duration};
 use time_source::SystemTimeSource;
 
 pub struct StorageInit {
@@ -206,6 +202,24 @@ type MidnightService = sc_service::PartialComponents<
 	),
 >;
 
+fn register_ledger_metrics(
+	prometheus_registry: Option<&prometheus_endpoint::Registry>,
+) -> Arc<Option<LedgerMetrics>> {
+	let metrics = prometheus_registry.and_then(|registry| {
+		LedgerMetrics::register(registry)
+			.map(|metrics| {
+				log::debug!(target: "prometheus", "Registered Ledger metrics");
+				metrics
+			})
+			.map_err(|err| {
+				log::warn!(target: "prometheus", "Failed to register Ledger metrics: {err:?}");
+			})
+			.ok()
+	});
+
+	Arc::new(metrics)
+}
+
 #[allow(clippy::result_large_err)]
 pub fn new_partial(
 	config: &Configuration,
@@ -285,29 +299,13 @@ pub fn new_partial(
 	let client = Arc::new(client);
 
 	// Register Prometheus Ledger Metrics
-	let ledger_metrics =
-		config
-			.prometheus_registry()
-			.map(LedgerMetrics::register)
-			.and_then(|result| match result {
-				Ok(metrics) => {
-					log::debug!(target: "prometheus", "Registered Ledger metrics");
-					Some(metrics)
-				},
-				Err(_err) => {
-					log::error!(target: "prometheus", "Failed to register Ledger metrics");
-					None
-				},
-			});
+	let ledger_metrics = register_ledger_metrics(config.prometheus_registry());
 
 	let ledger_storage = LedgerStorage::new(parity_db_path, storage_config.cache_size);
 
 	client
 		.execution_extensions()
-		.set_extensions_factory(ExtensionsFactory::<Block>::new(
-			Arc::new(Mutex::new(ledger_metrics)),
-			ledger_storage,
-		));
+		.set_extensions_factory(ExtensionsFactory::<Block>::new(ledger_metrics, ledger_storage));
 
 	let telemetry = telemetry.map(|(worker, telemetry)| {
 		task_manager.spawn_handle().spawn("telemetry", None, worker.run());

primitives/ledger/src/lib.rs

@@ -14,12 +14,8 @@
 use prometheus_endpoint::{
 	self as prometheus, HistogramOpts, HistogramVec, PrometheusError, Registry,
 };
-use std::{
-	path::PathBuf,
-	sync::{Arc, Mutex},
-};
+use std::{path::PathBuf, sync::Arc};
 
-const LOG_TARGET: &str = "ledger::primitives";
 /// Ledger metrics exposed through Prometheus
 #[derive(Clone, Debug)]
 pub struct LedgerMetrics {
@@ -156,27 +152,20 @@ impl LedgerMetrics {
 sp_externalities::decl_extension! {
 	/// The `LedgerMetrics`` extension to register/retrieve from the externalities.
 	#[derive(Debug)]
-	pub struct LedgerMetricsExt(Arc<Mutex<Option<LedgerMetrics>>>);
+	pub struct LedgerMetricsExt(Arc<Option<LedgerMetrics>>);
 }
 
 impl LedgerMetricsExt {
-	pub fn new(metrics: Arc<Mutex<Option<LedgerMetrics>>>) -> Self {
+	pub fn new(metrics: Arc<Option<LedgerMetrics>>) -> Self {
 		LedgerMetricsExt(metrics)
 	}
 
 	fn observe<F>(&mut self, op: F)
 	where
 		F: FnOnce(&LedgerMetrics),
 	{
-		let metrics = self.0.clone();
-		let metrics_result = metrics.lock();
-
-		if let Ok(write_metrics) = metrics_result {
-			if let Some(m) = write_metrics.as_ref() {
-				op(m);
-			}
-		} else {
-			log::error!(target: LOG_TARGET, "Ledger Metrics's lock is already held by the current thread");
+		if let Some(m) = self.0.as_ref() {
+			op(m);
 		}
 	}