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/utils/src/metrics/float_json_value.rs

@@ -0,0 +1,125 @@
+// Copyright 2019-2020 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity Bridges Common is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::metrics::{register, Gauge, Metrics, Registry, StandaloneMetrics, F64};
+
+use async_trait::async_trait;
+use std::time::Duration;
+
+/// Value update interval.
+const UPDATE_INTERVAL: Duration = Duration::from_secs(60);
+
+/// Metric that represents float value received from HTTP service as float gauge.
+#[derive(Debug, Clone)]
+pub struct FloatJsonValueMetric {
+	url: String,
+	json_path: String,
+	metric: Gauge<F64>,
+}
+
+impl FloatJsonValueMetric {
+	/// Create new metric instance with given name and help.
+	pub fn new(url: String, json_path: String, name: String, help: String) -> Self {
+		FloatJsonValueMetric {
+			url,
+			json_path,
+			metric: Gauge::new(name, help).expect(
+				"only fails if gauge options are customized;\
+					we use default options;\
+					qed",
+			),
+		}
+	}
+
+	/// Read value from HTTP service.
+	async fn read_value(&self) -> Result<f64, String> {
+		use isahc::{AsyncReadResponseExt, HttpClient, Request};
+
+		fn map_isahc_err(err: impl std::fmt::Display) -> String {
+			format!("Failed to fetch token price from remote server: {}", err)
+		}
+
+		let request = Request::get(&self.url)
+			.header("Accept", "application/json")
+			.body(())
+			.map_err(map_isahc_err)?;
+		let raw_response = HttpClient::new()
+			.map_err(map_isahc_err)?
+			.send_async(request)
+			.await
+			.map_err(map_isahc_err)?
+			.text()
+			.await
+			.map_err(map_isahc_err)?;
+
+		parse_service_response(&self.json_path, &raw_response)
+	}
+}
+
+impl Metrics for FloatJsonValueMetric {
+	fn register(&self, registry: &Registry) -> Result<(), String> {
+		register(self.metric.clone(), registry).map_err(|e| e.to_string())?;
+		Ok(())
+	}
+}
+
+#[async_trait]
+impl StandaloneMetrics for FloatJsonValueMetric {
+	fn update_interval(&self) -> Duration {
+		UPDATE_INTERVAL
+	}
+
+	async fn update(&self) {
+		crate::metrics::set_gauge_value(&self.metric, self.read_value().await.map(Some));
+	}
+}
+
+/// Parse HTTP service response.
+fn parse_service_response(json_path: &str, response: &str) -> Result<f64, String> {
+	let json = serde_json::from_str(response).map_err(|err| {
+		format!(
+			"Failed to parse HTTP service response: {:?}. Response: {:?}",
+			err, response,
+		)
+	})?;
+
+	let mut selector = jsonpath_lib::selector(&json);
+	let maybe_selected_value = selector(json_path).map_err(|err| {
+		format!(
+			"Failed to select value from response: {:?}. Response: {:?}",
+			err, response,
+		)
+	})?;
+	let selected_value = maybe_selected_value
+		.first()
+		.and_then(|v| v.as_f64())
+		.ok_or_else(|| format!("Missing required value from response: {:?}", response,))?;
+
+	Ok(selected_value)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn parse_service_response_works() {
+		assert_eq!(
+			parse_service_response("$.kusama.usd", r#"{"kusama":{"usd":433.05}}"#).map_err(drop),
+			Ok(433.05),
+		);
+	}
+}

bridges/relays/utils/src/metrics/global.rs

@@ -16,12 +16,11 @@
 
 //! Global system-wide Prometheus metrics exposed by relays.
 
-use crate::metrics::{Metrics, StandaloneMetrics};
+use crate::metrics::{register, Gauge, GaugeVec, Metrics, Opts, Registry, StandaloneMetrics, F64, U64};
 
 use async_std::sync::{Arc, Mutex};
 use async_trait::async_trait;
 use std::time::Duration;
-use substrate_prometheus_endpoint::{register, Gauge, GaugeVec, Opts, Registry, F64, U64};
 use sysinfo::{ProcessExt, RefreshKind, System, SystemExt};
 
 /// Global metrics update interval.
@@ -79,7 +78,7 @@ impl StandaloneMetrics for GlobalMetrics {
 			}
 			_ => {
 				log::warn!(
-					target: "bridge",
+					target: "bridge-metrics",
 					"Failed to refresh process information. Metrics may show obsolete values",
 				);
 			}