gnosis/lighthouse
1
0
Fork 0
mirror of https://github.com/sigp/lighthouse.git synced 2026-03-10 20:22:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Integrate tracing (#6339)

Browse Source 
Tracing Integration
- [reference](5bbf1859e9/projects/project-ideas.md (L297))


  - [x] replace slog & log with tracing throughout the codebase
- [x] implement custom crit log
- [x] make relevant changes in the formatter
- [x] replace sloggers
- [x] re-write SSE logging components

cc: @macladson @eserilev
This commit is contained in:
ThreeHrSleep
2025-03-13 04:01:05 +05:30
committed by GitHub
parent f23f984f85
commit d60c24ef1c
241 changed files with 9485 additions and 9328 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
beacon_node/lighthouse_network/src/discovery/enr.rs
View File

@@ -9,13 +9,13 @@ use crate::NetworkConfig;
use alloy_rlp::bytes::Bytes;
use libp2p::identity::Keypair;
use lighthouse_version::{client_name, version};
use slog::{debug, warn};
use ssz::{Decode, Encode};
use ssz_types::BitVector;
use std::fs::File;
use std::io::prelude::*;
use std::path::Path;
use std::str::FromStr;
use tracing::{debug, warn};
use types::{ChainSpec, EnrForkId, EthSpec};
use super::enr_ext::{EnrExt, QUIC6_ENR_KEY, QUIC_ENR_KEY};
@@ -99,20 +99,19 @@ pub fn use_or_load_enr(
enr_key: &CombinedKey,
local_enr: &mut Enr,
config: &NetworkConfig,
log: &slog::Logger,
) -> Result<(), String> {
let enr_f = config.network_dir.join(ENR_FILENAME);
if let Ok(mut enr_file) = File::open(enr_f.clone()) {
let mut enr_string = String::new();
match enr_file.read_to_string(&mut enr_string) {
Err(_) => debug!(log, "Could not read ENR from file"),
Err(_) => debug!("Could not read ENR from file"),
Ok(_) => {
match Enr::from_str(&enr_string) {
Ok(disk_enr) => {
// if the same node id, then we may need to update our sequence number
if local_enr.node_id() == disk_enr.node_id() {
if compare_enr(local_enr, &disk_enr) {
debug!(log, "ENR loaded from disk"; "file" => ?enr_f);
debug!(file = ?enr_f,"ENR loaded from disk");
// the stored ENR has the same configuration, use it
*local_enr = disk_enr;
return Ok(());
@@ -125,18 +124,18 @@ pub fn use_or_load_enr(
local_enr.set_seq(new_seq_no, enr_key).map_err(|e| {
format!("Could not update ENR sequence number: {:?}", e)
})?;
debug!(log, "ENR sequence number increased"; "seq" => new_seq_no);
debug!(seq = new_seq_no, "ENR sequence number increased");
}
}
Err(e) => {
warn!(log, "ENR from file could not be decoded"; "error" => ?e);
warn!(error = ?e,"ENR from file could not be decoded");
}
}
}
}
}
save_enr_to_disk(&config.network_dir, local_enr, log);
save_enr_to_disk(&config.network_dir, local_enr);
Ok(())
}
@@ -150,7 +149,6 @@ pub fn build_or_load_enr<E: EthSpec>(
local_key: Keypair,
config: &NetworkConfig,
enr_fork_id: &EnrForkId,
log: &slog::Logger,
spec: &ChainSpec,
) -> Result<Enr, String> {
// Build the local ENR.
@@ -159,7 +157,7 @@ pub fn build_or_load_enr<E: EthSpec>(
let enr_key = CombinedKey::from_libp2p(local_key)?;
let mut local_enr = build_enr::<E>(&enr_key, config, enr_fork_id, spec)?;
use_or_load_enr(&enr_key, &mut local_enr, config, log)?;
use_or_load_enr(&enr_key, &mut local_enr, config)?;
Ok(local_enr)
}
@@ -314,18 +312,19 @@ pub fn load_enr_from_disk(dir: &Path) -> Result<Enr, String> {
}
/// Saves an ENR to disk
pub fn save_enr_to_disk(dir: &Path, enr: &Enr, log: &slog::Logger) {
pub fn save_enr_to_disk(dir: &Path, enr: &Enr) {
let _ = std::fs::create_dir_all(dir);
match File::create(dir.join(Path::new(ENR_FILENAME)))
.and_then(|mut f| f.write_all(enr.to_base64().as_bytes()))
{
Ok(_) => {
debug!(log, "ENR written to disk");
debug!("ENR written to disk");
}
Err(e) => {
warn!(
log,
"Could not write ENR to file"; "file" => format!("{:?}{:?}",dir, ENR_FILENAME), "error" => %e
file = format!("{:?}{:?}",dir, ENR_FILENAME),
error = %e,
"Could not write ENR to file"
);
}
}

228
beacon_node/lighthouse_network/src/discovery/mod.rs
View File

@@ -31,8 +31,8 @@ pub use libp2p::{
SubstreamProtocol, ToSwarm,
},
};
use logging::crit;
use lru::LruCache;
use slog::{crit, debug, error, info, trace, warn};
use ssz::Encode;
use std::num::NonZeroUsize;
use std::{
@@ -45,6 +45,7 @@ use std::{
time::{Duration, Instant},
};
use tokio::sync::mpsc;
use tracing::{debug, error, info, trace, warn};
use types::{ChainSpec, EnrForkId, EthSpec};
mod subnet_predicate;
@@ -192,8 +193,6 @@ pub struct Discovery<E: EthSpec> {
/// Specifies whether various port numbers should be updated after the discovery service has been started
update_ports: UpdatePorts,
/// Logger for the discovery behaviour.
log: slog::Logger,
spec: Arc<ChainSpec>,
}
@@ -203,11 +202,8 @@ impl<E: EthSpec> Discovery<E> {
local_key: Keypair,
config: &NetworkConfig,
network_globals: Arc<NetworkGlobals<E>>,
log: &slog::Logger,
spec: &ChainSpec,
) -> Result<Self, String> {
let log = log.clone();
let enr_dir = match config.network_dir.to_str() {
Some(path) => String::from(path),
None => String::from(""),
@@ -216,9 +212,11 @@ impl<E: EthSpec> Discovery<E> {
let local_enr = network_globals.local_enr.read().clone();
let local_node_id = local_enr.node_id();
info!(log, "ENR Initialised"; "enr" => local_enr.to_base64(), "seq" => local_enr.seq(), "id"=> %local_enr.node_id(),
"ip4" => ?local_enr.ip4(), "udp4"=> ?local_enr.udp4(), "tcp4" => ?local_enr.tcp4(), "tcp6" => ?local_enr.tcp6(), "udp6" => ?local_enr.udp6(),
"quic4" => ?local_enr.quic4(), "quic6" => ?local_enr.quic6()
info!(
enr = local_enr.to_base64(), seq = local_enr.seq(), id = %local_enr.node_id(),
ip4 = ?local_enr.ip4(), udp4= ?local_enr.udp4(), tcp4 = ?local_enr.tcp4(), tcp6 = ?local_enr.tcp6(), udp6 = ?local_enr.udp6(),
quic4 = ?local_enr.quic4(), quic6 = ?local_enr.quic6(),
"ENR Initialised"
);
// convert the keypair into an ENR key
@@ -234,22 +232,20 @@ impl<E: EthSpec> Discovery<E> {
continue;
}
debug!(
log,
"Adding node to routing table";
"node_id" => %bootnode_enr.node_id(),
"peer_id" => %bootnode_enr.peer_id(),
"ip" => ?bootnode_enr.ip4(),
"udp" => ?bootnode_enr.udp4(),
"tcp" => ?bootnode_enr.tcp4(),
"quic" => ?bootnode_enr.quic4()
node_id = %bootnode_enr.node_id(),
peer_id = %bootnode_enr.peer_id(),
ip = ?bootnode_enr.ip4(),
udp = ?bootnode_enr.udp4(),
tcp = ?bootnode_enr.tcp4(),
quic = bootnode_enr.quic4(),
"Adding node to routing table"
);
let repr = bootnode_enr.to_string();
let _ = discv5.add_enr(bootnode_enr).map_err(|e| {
error!(
log,
"Could not add peer to the local routing table";
"addr" => repr,
"error" => e.to_string(),
addr = repr,
error = e.to_string(),
"Could not add peer to the local routing table"
)
});
}
@@ -257,14 +253,14 @@ impl<E: EthSpec> Discovery<E> {
// Start the discv5 service and obtain an event stream
let event_stream = if !config.disable_discovery {
discv5.start().map_err(|e| e.to_string()).await?;
debug!(log, "Discovery service started");
debug!("Discovery service started");
EventStream::Awaiting(Box::pin(discv5.event_stream()))
} else {
EventStream::InActive
};
if !config.boot_nodes_multiaddr.is_empty() {
info!(log, "Contacting Multiaddr boot-nodes for their ENR");
info!("Contacting Multiaddr boot-nodes for their ENR");
}
// get futures for requesting the Enrs associated to these multiaddr and wait for their
@@ -286,26 +282,28 @@ impl<E: EthSpec> Discovery<E> {
match result {
Ok(enr) => {
debug!(
log,
"Adding node to routing table";
"node_id" => %enr.node_id(),
"peer_id" => %enr.peer_id(),
"ip" => ?enr.ip4(),
"udp" => ?enr.udp4(),
"tcp" => ?enr.tcp4(),
"quic" => ?enr.quic4()
node_id = %enr.node_id(),
peer_id = %enr.peer_id(),
ip4 = ?enr.ip4(),
udp4 = ?enr.udp4(),
tcp4 = ?enr.tcp4(),
quic4 = ?enr.quic4(),
"Adding node to routing table"
);
let _ = discv5.add_enr(enr).map_err(|e| {
error!(
log,
"Could not add peer to the local routing table";
"addr" => original_addr.to_string(),
"error" => e.to_string(),
addr = original_addr.to_string(),
error = e.to_string(),
"Could not add peer to the local routing table"
)
});
}
Err(e) => {
error!(log, "Error getting mapping to ENR"; "multiaddr" => original_addr.to_string(), "error" => e.to_string())
error!(
multiaddr = original_addr.to_string(),
error = e.to_string(),
"Error getting mapping to ENR"
)
}
}
}
@@ -327,7 +325,6 @@ impl<E: EthSpec> Discovery<E> {
event_stream,
started: !config.disable_discovery,
update_ports,
log,
enr_dir,
spec: Arc::new(spec.clone()),
})
@@ -358,7 +355,7 @@ impl<E: EthSpec> Discovery<E> {
}
// Immediately start a FindNode query
let target_peers = std::cmp::min(FIND_NODE_QUERY_CLOSEST_PEERS, target_peers);
debug!(self.log, "Starting a peer discovery request"; "target_peers" => target_peers );
debug!(target_peers, "Starting a peer discovery request");
self.find_peer_active = true;
self.start_query(QueryType::FindPeers, target_peers, |_| true);
}
@@ -370,9 +367,8 @@ impl<E: EthSpec> Discovery<E> {
return;
}
trace!(
self.log,
"Starting discovery query for subnets";
"subnets" => ?subnets_to_discover.iter().map(|s| s.subnet).collect::<Vec<_>>()
subnets = ?subnets_to_discover.iter().map(|s| s.subnet).collect::<Vec<_>>(),
"Starting discovery query for subnets"
);
for subnet in subnets_to_discover {
self.add_subnet_query(subnet.subnet, subnet.min_ttl, 0);
@@ -386,9 +382,8 @@ impl<E: EthSpec> Discovery<E> {
if let Err(e) = self.discv5.add_enr(enr) {
debug!(
self.log,
"Could not add peer to the local routing table";
"error" => %e
error = %e,
"Could not add peer to the local routing table"
)
}
}
@@ -427,7 +422,7 @@ impl<E: EthSpec> Discovery<E> {
// replace the global version
*self.network_globals.local_enr.write() = self.discv5.local_enr();
// persist modified enr to disk
enr::save_enr_to_disk(Path::new(&self.enr_dir), &self.local_enr(), &self.log);
enr::save_enr_to_disk(Path::new(&self.enr_dir), &self.local_enr());
Ok(true)
}
@@ -463,7 +458,7 @@ impl<E: EthSpec> Discovery<E> {
// replace the global version
*self.network_globals.local_enr.write() = self.discv5.local_enr();
// persist modified enr to disk
enr::save_enr_to_disk(Path::new(&self.enr_dir), &self.local_enr(), &self.log);
enr::save_enr_to_disk(Path::new(&self.enr_dir), &self.local_enr());
Ok(true)
}
@@ -475,7 +470,7 @@ impl<E: EthSpec> Discovery<E> {
const IS_TCP: bool = false;
if self.discv5.update_local_enr_socket(socket_addr, IS_TCP) {
// persist modified enr to disk
enr::save_enr_to_disk(Path::new(&self.enr_dir), &self.local_enr(), &self.log);
enr::save_enr_to_disk(Path::new(&self.enr_dir), &self.local_enr());
}
*self.network_globals.local_enr.write() = self.discv5.local_enr();
Ok(())
@@ -561,7 +556,7 @@ impl<E: EthSpec> Discovery<E> {
*self.network_globals.local_enr.write() = self.discv5.local_enr();
// persist modified enr to disk
enr::save_enr_to_disk(Path::new(&self.enr_dir), &self.local_enr(), &self.log);
enr::save_enr_to_disk(Path::new(&self.enr_dir), &self.local_enr());
Ok(())
}
@@ -575,10 +570,11 @@ impl<E: EthSpec> Discovery<E> {
format!("{:?}", enr_fork_id.next_fork_epoch)
};
info!(self.log, "Updating the ENR fork version";
"fork_digest" => ?enr_fork_id.fork_digest,
"next_fork_version" => ?enr_fork_id.next_fork_version,
"next_fork_epoch" => next_fork_epoch_log,
info!(
fork_digest = ?enr_fork_id.fork_digest,
next_fork_version = ?enr_fork_id.next_fork_version,
next_fork_epoch = next_fork_epoch_log,
"Updating the ENR fork version"
);
let _ = self
@@ -586,9 +582,8 @@ impl<E: EthSpec> Discovery<E> {
.enr_insert::<Bytes>(ETH2_ENR_KEY, &enr_fork_id.as_ssz_bytes().into())
.map_err(|e| {
warn!(
self.log,
"Could not update eth2 ENR field";
"error" => ?e
error = ?e,
"Could not update eth2 ENR field"
)
});
@@ -596,7 +591,7 @@ impl<E: EthSpec> Discovery<E> {
*self.network_globals.local_enr.write() = self.discv5.local_enr();
// persist modified enr to disk
enr::save_enr_to_disk(Path::new(&self.enr_dir), &self.local_enr(), &self.log);
enr::save_enr_to_disk(Path::new(&self.enr_dir), &self.local_enr());
}
// Bans a peer and it's associated seen IP addresses.
@@ -642,10 +637,7 @@ impl<E: EthSpec> Discovery<E> {
fn add_subnet_query(&mut self, subnet: Subnet, min_ttl: Option<Instant>, retries: usize) {
// remove the entry and complete the query if greater than the maximum search count
if retries > MAX_DISCOVERY_RETRY {
debug!(
self.log,
"Subnet peer discovery did not find sufficient peers. Reached max retry limit"
);
debug!("Subnet peer discovery did not find sufficient peers. Reached max retry limit");
return;
}
@@ -666,7 +658,7 @@ impl<E: EthSpec> Discovery<E> {
}
if !found {
// update the metrics and insert into the queue.
trace!(self.log, "Queuing subnet query"; "subnet" => ?subnet, "retries" => retries);
trace!(?subnet, retries, "Queuing subnet query");
self.queued_queries.push_back(SubnetQuery {
subnet,
min_ttl,
@@ -737,19 +729,21 @@ impl<E: EthSpec> Discovery<E> {
.count();
if peers_on_subnet >= TARGET_SUBNET_PEERS {
debug!(self.log, "Discovery ignored";
"reason" => "Already connected to desired peers",
"connected_peers_on_subnet" => peers_on_subnet,
"target_subnet_peers" => TARGET_SUBNET_PEERS,
debug!(
reason = "Already connected to desired peers",
connected_peers_on_subnet = peers_on_subnet,
target_subnet_peers = TARGET_SUBNET_PEERS,
"Discovery ignored"
);
return false;
}
let target_peers = TARGET_SUBNET_PEERS.saturating_sub(peers_on_subnet);
trace!(self.log, "Discovery query started for subnet";
"subnet_query" => ?subnet_query,
"connected_peers_on_subnet" => peers_on_subnet,
"peers_to_find" => target_peers,
trace!(
?subnet_query,
connected_peers_on_subnet = peers_on_subnet,
peers_to_find = target_peers,
"Discovery query started for subnet"
);
filtered_subnets.push(subnet_query.subnet);
@@ -760,13 +754,11 @@ impl<E: EthSpec> Discovery<E> {
// Only start a discovery query if we have a subnet to look for.
if !filtered_subnet_queries.is_empty() {
// build the subnet predicate as a combination of the eth2_fork_predicate and the subnet predicate
let subnet_predicate =
subnet_predicate::<E>(filtered_subnets, &self.log, self.spec.clone());
let subnet_predicate = subnet_predicate::<E>(filtered_subnets, self.spec.clone());
debug!(
self.log,
"Starting grouped subnet query";
"subnets" => ?filtered_subnet_queries,
subnets = ?filtered_subnet_queries,
"Starting grouped subnet query"
);
self.start_query(
QueryType::Subnet(filtered_subnet_queries),
@@ -790,7 +782,7 @@ impl<E: EthSpec> Discovery<E> {
let enr_fork_id = match self.local_enr().eth2() {
Ok(v) => v,
Err(e) => {
crit!(self.log, "Local ENR has no fork id"; "error" => e);
crit!(error = e, "Local ENR has no fork id");
return;
}
};
@@ -831,10 +823,10 @@ impl<E: EthSpec> Discovery<E> {
self.find_peer_active = false;
match query.result {
Ok(r) if r.is_empty() => {
debug!(self.log, "Discovery query yielded no results.");
debug!("Discovery query yielded no results.");
}
Ok(r) => {
debug!(self.log, "Discovery query completed"; "peers_found" => r.len());
debug!(peers_found = r.len(), "Discovery query completed");
let results = r
.into_iter()
.map(|enr| {
@@ -846,7 +838,7 @@ impl<E: EthSpec> Discovery<E> {
return Some(results);
}
Err(e) => {
warn!(self.log, "Discovery query failed"; "error" => %e);
warn!(error = %e, "Discovery query failed");
}
}
}
@@ -855,13 +847,20 @@ impl<E: EthSpec> Discovery<E> {
queries.iter().map(|query| query.subnet).collect();
match query.result {
Ok(r) if r.is_empty() => {
debug!(self.log, "Grouped subnet discovery query yielded no results."; "subnets_searched_for" => ?subnets_searched_for);
debug!(
?subnets_searched_for,
"Grouped subnet discovery query yielded no results."
);
queries.iter().for_each(|query| {
self.add_subnet_query(query.subnet, query.min_ttl, query.retries + 1);
})
}
Ok(r) => {
debug!(self.log, "Peer grouped subnet discovery request completed"; "peers_found" => r.len(), "subnets_searched_for" => ?subnets_searched_for);
debug!(
peers_found = r.len(),
?subnets_searched_for,
"Peer grouped subnet discovery request completed"
);
let mut mapped_results = HashMap::new();
@@ -888,11 +887,8 @@ impl<E: EthSpec> Discovery<E> {
self.add_subnet_query(query.subnet, query.min_ttl, query.retries + 1);
// Check the specific subnet against the enr
let subnet_predicate = subnet_predicate::<E>(
vec![query.subnet],
&self.log,
self.spec.clone(),
);
let subnet_predicate =
subnet_predicate::<E>(vec![query.subnet], self.spec.clone());
r.clone()
.into_iter()
@@ -941,7 +937,7 @@ impl<E: EthSpec> Discovery<E> {
}
}
Err(e) => {
warn!(self.log,"Grouped subnet discovery query failed"; "subnets_searched_for" => ?subnets_searched_for, "error" => %e);
warn!(?subnets_searched_for, error = %e,"Grouped subnet discovery query failed");
}
}
}
@@ -1020,11 +1016,11 @@ impl<E: EthSpec> NetworkBehaviour for Discovery<E> {
if let Poll::Ready(event_stream) = fut.poll_unpin(cx) {
match event_stream {
Ok(stream) => {
debug!(self.log, "Discv5 event stream ready");
debug!("Discv5 event stream ready");
self.event_stream = EventStream::Present(stream);
}
Err(e) => {
slog::crit!(self.log, "Discv5 event stream failed"; "error" => %e);
crit!(error = %e, "Discv5 event stream failed");
self.event_stream = EventStream::InActive;
}
}
@@ -1042,15 +1038,15 @@ impl<E: EthSpec> NetworkBehaviour for Discovery<E> {
// log these to see if we are unnecessarily dropping discovered peers
/*
if enr.eth2() == self.local_enr().eth2() {
trace!(self.log, "Peer found in process of query"; "peer_id" => format!("{}", enr.peer_id()), "tcp_socket" => enr.tcp_socket());
trace!( "Peer found in process of query"; "peer_id" => format!("{}", enr.peer_id()), "tcp_socket" => enr.tcp_socket());
} else {
// this is temporary warning for debugging the DHT
warn!(self.log, "Found peer during discovery not on correct fork"; "peer_id" => format!("{}", enr.peer_id()), "tcp_socket" => enr.tcp_socket());
warn!( "Found peer during discovery not on correct fork"; "peer_id" => format!("{}", enr.peer_id()), "tcp_socket" => enr.tcp_socket());
}
*/
}
discv5::Event::SocketUpdated(socket_addr) => {
info!(self.log, "Address updated"; "ip" => %socket_addr.ip(), "udp_port" => %socket_addr.port());
info!(ip = %socket_addr.ip(), udp_port = %socket_addr.port(),"Address updated");
metrics::inc_counter(&metrics::ADDRESS_UPDATE_COUNT);
// Discv5 will have updated our local ENR. We save the updated version
// to disk.
@@ -1062,7 +1058,7 @@ impl<E: EthSpec> NetworkBehaviour for Discovery<E> {
self.discv5.update_local_enr_socket(socket_addr, true);
}
let enr = self.discv5.local_enr();
enr::save_enr_to_disk(Path::new(&self.enr_dir), &enr, &self.log);
enr::save_enr_to_disk(Path::new(&self.enr_dir), &enr);
// update network globals
*self.network_globals.local_enr.write() = enr;
// A new UDP socket has been detected.
@@ -1086,7 +1082,11 @@ impl<E: EthSpec> NetworkBehaviour for Discovery<E> {
let addr = ev.addr;
let listener_id = ev.listener_id;
trace!(self.log, "Received NewListenAddr event from swarm"; "listener_id" => ?listener_id, "addr" => ?addr);
trace!(
?listener_id,
?addr,
"Received NewListenAddr event from swarm"
);
let mut addr_iter = addr.iter();
@@ -1094,7 +1094,7 @@ impl<E: EthSpec> NetworkBehaviour for Discovery<E> {
Some(Protocol::Ip4(_)) => match (addr_iter.next(), addr_iter.next()) {
(Some(Protocol::Tcp(port)), None) => {
if !self.update_ports.tcp4 {
debug!(self.log, "Skipping ENR update"; "multiaddr" => ?addr);
debug!(multiaddr = ?addr, "Skipping ENR update");
return;
}
@@ -1102,21 +1102,21 @@ impl<E: EthSpec> NetworkBehaviour for Discovery<E> {
}
(Some(Protocol::Udp(port)), Some(Protocol::QuicV1)) => {
if !self.update_ports.quic4 {
debug!(self.log, "Skipping ENR update"; "multiaddr" => ?addr);
debug!(?addr, "Skipping ENR update");
return;
}
self.update_enr_quic_port(port, false)
}
_ => {
debug!(self.log, "Encountered unacceptable multiaddr for listening (unsupported transport)"; "addr" => ?addr);
debug!(?addr, "Encountered unacceptable multiaddr for listening (unsupported transport)");
return;
}
},
Some(Protocol::Ip6(_)) => match (addr_iter.next(), addr_iter.next()) {
(Some(Protocol::Tcp(port)), None) => {
if !self.update_ports.tcp6 {
debug!(self.log, "Skipping ENR update"; "multiaddr" => ?addr);
debug!(?addr, "Skipping ENR update");
return;
}
@@ -1124,19 +1124,22 @@ impl<E: EthSpec> NetworkBehaviour for Discovery<E> {
}
(Some(Protocol::Udp(port)), Some(Protocol::QuicV1)) => {
if !self.update_ports.quic6 {
debug!(self.log, "Skipping ENR update"; "multiaddr" => ?addr);
debug!(?addr, "Skipping ENR update");
return;
}
self.update_enr_quic_port(port, true)
}
_ => {
debug!(self.log, "Encountered unacceptable multiaddr for listening (unsupported transport)"; "addr" => ?addr);
debug!(?addr, "Encountered unacceptable multiaddr for listening (unsupported transport)");
return;
}
},
_ => {
debug!(self.log, "Encountered unacceptable multiaddr for listening (no IP)"; "addr" => ?addr);
debug!(
?addr,
"Encountered unacceptable multiaddr for listening (no IP)"
);
return;
}
};
@@ -1145,10 +1148,10 @@ impl<E: EthSpec> NetworkBehaviour for Discovery<E> {
match attempt_enr_update {
Ok(true) => {
info!(self.log, "Updated local ENR"; "enr" => local_enr.to_base64(), "seq" => local_enr.seq(), "id"=> %local_enr.node_id(), "ip4" => ?local_enr.ip4(), "udp4"=> ?local_enr.udp4(), "tcp4" => ?local_enr.tcp4(), "tcp6" => ?local_enr.tcp6(), "udp6" => ?local_enr.udp6())
info!(enr = local_enr.to_base64(), seq = local_enr.seq(), id = %local_enr.node_id(), ip4 = ?local_enr.ip4(), udp4 = ?local_enr.udp4(), tcp4 = ?local_enr.tcp4(), tcp6 = ?local_enr.tcp6(), udp6 = ?local_enr.udp6(),"Updated local ENR")
}
Ok(false) => {} // Nothing to do, ENR already configured
Err(e) => warn!(self.log, "Failed to update ENR"; "error" => ?e),
Err(e) => warn!(error = ?e,"Failed to update ENR"),
}
}
_ => {
@@ -1171,7 +1174,7 @@ impl<E: EthSpec> Discovery<E> {
return;
}
// set peer as disconnected in discovery DHT
debug!(self.log, "Marking peer disconnected in DHT"; "peer_id" => %peer_id, "error" => %ClearDialError(error));
debug!(%peer_id, error = %ClearDialError(error),"Marking peer disconnected in DHT");
self.disconnect_peer(&peer_id);
}
DialError::LocalPeerId { .. }
@@ -1179,7 +1182,7 @@ impl<E: EthSpec> Discovery<E> {
| DialError::Transport(_)
| DialError::WrongPeerId { .. } => {
// set peer as disconnected in discovery DHT
debug!(self.log, "Marking peer disconnected in DHT"; "peer_id" => %peer_id, "error" => %ClearDialError(error));
debug!(%peer_id, error = %ClearDialError(error),"Marking peer disconnected in DHT");
self.disconnect_peer(&peer_id);
}
DialError::DialPeerConditionFalse(_) | DialError::Aborted => {}
@@ -1193,23 +1196,10 @@ mod tests {
use super::*;
use crate::rpc::methods::{MetaData, MetaDataV2};
use libp2p::identity::secp256k1;
use slog::{o, Drain};
use types::{BitVector, MinimalEthSpec, SubnetId};
type E = MinimalEthSpec;
pub fn build_log(level: slog::Level, enabled: bool) -> slog::Logger {
let decorator = slog_term::TermDecorator::new().build();
let drain = slog_term::FullFormat::new(decorator).build().fuse();
let drain = slog_async::Async::new(drain).build().fuse();
if enabled {
slog::Logger::root(drain.filter_level(level).fuse(), o!())
} else {
slog::Logger::root(drain.filter(|_| false).fuse(), o!())
}
}
async fn build_discovery() -> Discovery<E> {
let spec = Arc::new(ChainSpec::default());
let keypair = secp256k1::Keypair::generate();
@@ -1218,7 +1208,6 @@ mod tests {
let config = Arc::new(config);
let enr_key: CombinedKey = CombinedKey::from_secp256k1(&keypair);
let enr: Enr = build_enr::<E>(&enr_key, &config, &EnrForkId::default(), &spec).unwrap();
let log = build_log(slog::Level::Debug, false);
let globals = NetworkGlobals::new(
enr,
MetaData::V2(MetaDataV2 {
@@ -1228,12 +1217,11 @@ mod tests {
}),
vec![],
false,
&log,
config.clone(),
spec.clone(),
);
let keypair = keypair.into();
Discovery::new(keypair, &config, Arc::new(globals), &log, &spec)
Discovery::new(keypair, &config, Arc::new(globals), &spec)
.await
.unwrap()
}

10
beacon_node/lighthouse_network/src/discovery/subnet_predicate.rs
View File

@@ -1,22 +1,19 @@
//! The subnet predicate used for searching for a particular subnet.
use super::*;
use crate::types::{EnrAttestationBitfield, EnrSyncCommitteeBitfield};
use slog::trace;
use std::ops::Deref;
use tracing::trace;
use types::data_column_custody_group::compute_subnets_for_node;
use types::ChainSpec;
/// Returns the predicate for a given subnet.
pub fn subnet_predicate<E>(
subnets: Vec<Subnet>,
log: &slog::Logger,
spec: Arc<ChainSpec>,
) -> impl Fn(&Enr) -> bool + Send
where
E: EthSpec,
{
let log_clone = log.clone();
move |enr: &Enr| {
let attestation_bitfield: EnrAttestationBitfield<E> = match enr.attestation_bitfield::<E>()
{
@@ -48,9 +45,8 @@ where
if !predicate {
trace!(
log_clone,
"Peer found but not on any of the desired subnets";
"peer_id" => %enr.peer_id()
peer_id = %enr.peer_id(),
"Peer found but not on any of the desired subnets"
);
}
predicate