Use avail-light-core for telemetry

bootstrap/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.5.0
+
+- Use telemetry from the avail-light-core 1.2.0
+
 ## [0.4.2](https://github.com/availproject/avail-light/releases/tag/avail-light-bootstrap-v0.4.2) - 2024-12-20
 
 - Temporary remove WebRTC support to reduce memory usage

bootstrap/Cargo.toml

@@ -1,15 +1,18 @@
 [package]
 name = "avail-light-bootstrap"
-version = "0.4.2"
+version = "0.5.0"
 build = "../build.rs"
 edition = "2021"
 description = "Avail network Bootstrap Node for p2p Light Client"
 
 [dependencies]
+avail-light-core = { workspace = true }
+
 anyhow = { workspace = true }
 async-std = { workspace = true }
 async-trait = { workspace = true }
 clap = { workspace = true }
+color-eyre = { workspace = true }
 confy = { workspace = true }
 hex = { workspace = true }
 libp2p = { workspace = true }

bootstrap/src/main.rs

@@ -1,10 +1,11 @@
 #![doc = include_str!("../README.md")]
 
-use crate::{
-	telemetry::{MetricValue, Metrics},
-	types::{network_name, LibP2PConfig},
-};
+use crate::types::{network_name, LibP2PConfig};
 use anyhow::{Context, Result};
+use avail_light_core::{
+	telemetry::{self, MetricCounter, MetricValue},
+	types::{Origin, ProjectName},
+};
 use clap::Parser;
 use libp2p::{multiaddr::Protocol, Multiaddr};
 use std::{net::Ipv4Addr, time::Duration};
@@ -18,7 +19,6 @@ use types::RuntimeConfig;
 
 mod p2p;
 mod server;
-mod telemetry;
 mod types;
 
 const CLIENT_ROLE: &str = "bootnode";
@@ -88,14 +88,22 @@ async fn run() -> Result<()> {
 
 	tokio::spawn(server::run((&cfg).into(), network_client.clone()));
 
-	let ot_metrics = telemetry::otlp::initialize(
-		cfg.ot_collector_endpoint,
-		peer_id,
-		CLIENT_ROLE.into(),
-		cfg.origin,
-		network_name(&cfg.genesis_hash),
+	let resource_attributes = vec![
+		("version", version.to_string()),
+		("role", CLIENT_ROLE.to_string()),
+		("peerID", peer_id.to_string()),
+		("origin", cfg.origin.clone()),
+		("network", network_name(&cfg.genesis_hash)),
+	];
+
+	let mut ot_metrics = telemetry::otlp::initialize(
+		ProjectName::new("avail".to_string()),
+		&Origin::Other(cfg.origin),
+		cfg.otel,
+		resource_attributes,
 	)
-	.context("Cannot initialize OpenTelemetry service.")?;
+	.map_err(anyhow::Error::msg)
+	.context("Unable to initialize OpenTelemetry service")?;
 
 	// Spawn the network task
 	let loop_handle = tokio::spawn(network_event_loop.run());
@@ -109,20 +117,11 @@ async fn run() -> Result<()> {
 		loop {
 			interval.tick().await;
 			// try and read current multiaddress
-			if let Ok(Some(addr)) = m_network_client.get_multiaddress().await {
-				// set Multiaddress
-				_ = ot_metrics.set_multiaddress(addr.to_string()).await;
-			}
 			if let Ok(counted_peers) = m_network_client.count_dht_entries().await {
 				debug!("Number of peers in the routing table: {}", counted_peers);
-				if let Err(err) = ot_metrics
-					.record(MetricValue::KadRoutingPeerNum(counted_peers))
-					.await
-				{
-					error!("Error recording network stats metric: {err}");
-				}
+				ot_metrics.record(MetricValue::DHTConnectedPeers(counted_peers));
 			};
-			_ = ot_metrics.record(MetricValue::HealthCheck()).await;
+			ot_metrics.count(MetricCounter::Up);
 		}
 	});
 

bootstrap/src/p2p/client.rs

@@ -84,15 +84,6 @@ impl Client {
 		response_receiver.await.context("Sender not to be dropped.")
 	}
 
-	pub async fn get_multiaddress(&self) -> Result<Option<Multiaddr>> {
-		let (response_sender, response_receiver) = oneshot::channel();
-		self.command_sender
-			.send(Command::GetMultiaddress { response_sender })
-			.await
-			.context("Command receiver not to be dropped.")?;
-		response_receiver.await.context("Sender not to be dropped.")
-	}
-
 	pub async fn get_local_peer_info(&self) -> Result<PeerInfo> {
 		let (response_sender, response_receiver) = oneshot::channel();
 		self.command_sender
@@ -122,9 +113,6 @@ pub enum Command {
 	CountDHTPeers {
 		response_sender: oneshot::Sender<usize>,
 	},
-	GetMultiaddress {
-		response_sender: oneshot::Sender<Option<Multiaddr>>,
-	},
 	GetLocalPeerInfo {
 		response_sender: oneshot::Sender<PeerInfo>,
 	},

bootstrap/src/p2p/event_loop.rs

@@ -259,10 +259,6 @@ impl EventLoop {
 				}
 				_ = response_sender.send(total_peers);
 			},
-			Command::GetMultiaddress { response_sender } => {
-				let last_address = self.swarm.external_addresses().last();
-				_ = response_sender.send(last_address.cloned());
-			},
 			Command::GetLocalPeerInfo { response_sender } => {
 				let local_listeners: Vec<String> =
 					self.swarm.listeners().map(ToString::to_string).collect();

bootstrap/src/types.rs

@@ -1,4 +1,5 @@
 use anyhow::{anyhow, Context, Error};
+use avail_light_core::telemetry::otlp::OtelConfig;
 use libp2p::{Multiaddr, PeerId, StreamProtocol};
 use semver::Version;
 use serde::{Deserialize, Serialize};
@@ -99,8 +100,8 @@ pub struct RuntimeConfig {
 	pub bootstraps: Vec<MultiaddrConfig>,
 	/// Defines a period of time in which periodic bootstraps will be repeated. (default: 300s)
 	pub bootstrap_period: u64,
-	/// OpenTelemetry Collector endpoint (default: http://127.0.0.1:4317)
-	pub ot_collector_endpoint: String,
+	#[serde(flatten)]
+	pub otel: OtelConfig,
 	/// Defines a period of time in which periodic metric network dump events will be repeated. (default: 15s)
 	pub metrics_network_dump_interval: u64,
 	/// Secret key used to generate keypair. Can be either set to `seed` or to `key`. (default: seed="1")
@@ -213,7 +214,7 @@ impl Default for RuntimeConfig {
 			kad_query_timeout: 60,
 			bootstraps: vec![],
 			bootstrap_period: 300,
-			ot_collector_endpoint: "http://127.0.0.1:4317".to_string(),
+			otel: Default::default(),
 			metrics_network_dump_interval: 15,
 			origin: "external".to_string(),
 			genesis_hash: "DEV".to_owned(),