mab122
/
radicle-heartwood-lfs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

node: downgrade `error!` logs 

Evaluate the `error!` logging in `radicle-node`.

The majority of cases, the `error!` is downgraded to `warn!`. These
cases are generally useful to know if there's an issue, but the
operator cannon necessarily do anything about it.

In a few cases, `debug!` was chosen. These are generally when an error
means that a result is not part of an accumulation, or the system will
eventually correct itself during another event or restart.
This commit is contained in:
Fintan Halpenny 2026-01-19 15:24:56 +00:00 committed by Lorenz Leutgeb
parent b020543c4b
commit 6d1abd2833
6 changed files with 29 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
crates/radicle-node/src/control.rs
View File

@ -50,7 +50,7 @@ where
thread::spawn(&nid, "control", move || {
if let Err((e, mut stream)) = command(stream, handle) {
log::error!(target: "control", "Command returned error: {e}");
log::debug!(target: "control", "Command returned error: {e}");
CommandResult::error(e).to_writer(&mut stream).ok();
@ -59,7 +59,7 @@ where
}
});
}
Err(e) => log::error!(target: "control", "Failed to accept incoming connection: {e}"),
Err(e) => log::warn!(target: "control", "Failed to accept incoming connection: {e}"),
}
}
log::debug!(target: "control", "Exiting control loop..");

6
crates/radicle-node/src/reactor.rs
View File

@ -399,7 +399,7 @@ impl<H: ReactionHandler> Runtime<H> {
}
if let Err(err) = res {
log::error!(target: "reactor", "Error during polling: {err}");
log::warn!(target: "reactor", "Failure during polling: {err}");
self.service.handle_error(Error::Poll(err));
}
@ -497,7 +497,7 @@ impl<H: ReactionHandler> Runtime<H> {
// Deadlock may happen here if the service will generate events over and over
// in the handle_* calls we may never get out of this loop
if let Err(err) = self.handle_action(action, instant) {
log::error!(target: "reactor", "Error: {err}");
log::warn!(target: "reactor", "Failure: {err}");
self.service.handle_error(err);
}
}
@ -558,7 +558,7 @@ impl<H: ReactionHandler> Runtime<H> {
}
}
} else {
log::error!(target: "reactor", token=token.0; "No transport with token {token:?} is known!");
log::debug!(target: "reactor", token=token.0; "No transport with token {token:?} is known!");
}
}
Action::SetTimer(duration) => {

2
crates/radicle-node/src/reactor/transport.rs
View File

@ -265,7 +265,7 @@ impl<S: Session> Transport<S> {
Ok(0)
},
_ => {
log::error!(target: "transport", "Resource {} failed write operation with message '{err}'", self.display());
log::warn!(target: "transport", "Resource {} failed write operation with message '{err}'", self.display());
Err(err)
},
}

34
crates/radicle-node/src/wire.rs
View File

@ -362,7 +362,7 @@ where
}
Entry::Occupied(mut e) => match e.get_mut() {
Peer::Disconnecting { nid, link, .. } => {
log::error!(target: "wire", token=token.0; "Peer is already disconnecting");
log::debug!(target: "wire", token=token.0; "Peer is already disconnecting");
nid.map(|n| (n, *link))
}
@ -528,7 +528,7 @@ where
Ok((connection, peer)) => {
let remote = NetAddr::from(peer);
let InetHost::Ip(ip) = remote.host else {
log::error!(target: "wire", "Unexpected host type for inbound connection {remote}; dropping..");
log::debug!(target: "wire", "Unexpected host type for inbound connection {remote}; dropping..");
drop(connection);
return;
@ -552,7 +552,7 @@ where
let transport = match Transport::with_session(session, Link::Inbound) {
Ok(transport) => transport,
Err(err) => {
log::error!(target: "wire", "Failed to create transport for accepted connection: {err}");
log::warn!(target: "wire", "Failed to create transport for accepted connection: {err}");
return;
}
};
@ -593,7 +593,7 @@ where
let nid: NodeId = state.remote_static_key.unwrap();
// Make sure we don't try to connect to ourselves by mistake.
if &nid == self.signer.public_key() {
log::error!(target: "wire", "Self-connection detected, disconnecting..");
log::warn!(target: "wire", "Self-connection detected, disconnecting..");
self.disconnect(token, DisconnectReason::SelfConnection);
return;
@ -607,7 +607,7 @@ where
assert_eq!(nid, peer.nid);
(peer.addr, Link::Outbound)
} else {
log::error!(target: "wire", token=token.0; "Session for {nid} not found");
log::debug!(target: "wire", token=token.0; "Session for {nid} not found");
return;
};
log::debug!(
@ -702,8 +702,8 @@ where
metrics.received_bytes += data.len();
if inbox.input(&data).is_err() {
log::error!(target: "wire", "Maximum inbox size ({MAX_INBOX_SIZE}) reached for peer {nid}");
log::error!(target: "wire", "Unable to process messages fast enough for peer {nid}; disconnecting..");
log::warn!(target: "wire", "Maximum inbox size ({MAX_INBOX_SIZE}) reached for peer {nid}");
log::warn!(target: "wire", "Unable to process messages fast enough for peer {nid}; disconnecting..");
self.disconnect(
token,
DisconnectReason::Session(session::Error::Misbehavior),
@ -740,7 +740,7 @@ where
channels,
};
if let Err(e) = self.worker.try_send(task) {
log::error!(
log::warn!(
target: "wire",
"Worker pool failed to accept incoming fetch request: {e}"
);
@ -754,7 +754,7 @@ where
log::debug!(target: "wire", "Received `end-of-file` on stream {stream} from {nid}");
if s.channels.send(ChannelEvent::Eof).is_err() {
log::error!(target: "wire", "Worker is disconnected; cannot send `EOF`");
log::debug!(target: "wire", "Worker is disconnected; cannot send `EOF`");
}
} else {
log::debug!(target: "wire", "Ignoring frame on closed or unknown stream {stream}");
@ -791,7 +791,7 @@ where
metrics.received_git_bytes += data.len();
if s.channels.send(ChannelEvent::Data(data)).is_err() {
log::error!(target: "wire", "Worker is disconnected; cannot send data");
log::warn!(target: "wire", "Worker is disconnected; cannot send data");
}
} else {
log::debug!(target: "wire", "Ignoring frame on closed or unknown stream {stream}");
@ -802,7 +802,7 @@ where
break;
}
Err(e) => {
log::error!(target: "wire", "Invalid gossip message from {nid}: {e}");
log::warn!(target: "wire", "Invalid gossip message from {nid}: {e}");
if !inbox.is_empty() {
log::debug!(target: "wire", "Dropping read buffer for {nid} with {} bytes", inbox.len());
@ -875,7 +875,7 @@ where
}
fn handover_listener(&mut self, token: Token, _listener: Self::Listener) {
log::error!(target: "wire", token=token.0; "Listener handover is not supported");
log::warn!(target: "wire", token=token.0; "Listener handover is not supported");
}
fn handover_transport(&mut self, token: Token, transport: Self::Transport) {
@ -933,7 +933,7 @@ where
continue;
}
None => {
log::error!(target: "wire", "Dropping {} message(s) to {node_id}: unknown peer", msgs.len());
log::debug!(target: "wire", "Dropping {} message(s) to {node_id}: unknown peer", msgs.len());
continue;
}
};
@ -953,7 +953,7 @@ where
}
Io::Connect(node_id, addr) => {
if self.peers.connected().any(|(_, id)| id == &node_id) {
log::error!(
log::debug!(
target: "wire",
"Attempt to connect to already connected peer {node_id}"
);
@ -1029,7 +1029,7 @@ where
// is in the service's i/o buffer. Since the service may not purge the
// buffer on disconnect, we should just ignore i/o actions that don't
// have a connected peer.
log::error!(target: "wire", "Peer {remote} is not connected: dropping fetch");
log::debug!(target: "wire", "Peer {remote} is not connected: dropping fetch");
continue;
};
let (stream, channels) =
@ -1055,7 +1055,7 @@ where
);
}
if let Err(e) = self.worker.try_send(task) {
log::error!(
log::warn!(
target: "wire",
"Worker pool failed to accept outgoing fetch request: {e}"
);
@ -1232,7 +1232,7 @@ mod logger {
| NotConnected => {
log::info!(target: "wire", "Could not establish connection to {addr}: {err}")
}
_ => log::error!(target: "wire", "Error establishing connection to {addr}: {err}"),
_ => log::warn!(target: "wire", "Failed to establish connection to {addr}: {err}"),
}
}
}

10
crates/radicle-node/src/worker/fetch.rs
View File

@ -106,7 +106,7 @@ impl Handle {
validations,
} => {
for fail in validations.iter() {
log::error!(target: "worker", "Validation error: {fail}");
log::warn!(target: "worker", "Validation error: {fail}");
}
Err(error::Fetch::Validation {
threshold,
@ -207,7 +207,7 @@ fn notify(
if let RefUpdate::Skipped { .. } = update {
// Don't notify about skipped refs.
} else if let Err(e) = store.insert(rid, update, now) {
log::error!(
log::debug!(
target: "worker",
"Failed to update notification store for {rid}: {e}"
);
@ -227,7 +227,7 @@ where
let name = r.name();
let (namespace, qualified) = match radicle::git::parse_ref_namespaced(name) {
Err(e) => {
log::error!(target: "worker", "Git reference is invalid: {name:?}: {e}");
log::debug!(target: "worker", "Git reference is invalid: {name:?}: {e}");
log::debug!(target: "worker", "Skipping refs caching for fetch of {repo}");
break;
}
@ -247,7 +247,7 @@ where
};
if let Err(e) = result {
log::error!(target: "worker", "Error updating git refs cache for {name:?}: {e}");
log::debug!(target: "worker", "Failed to update git refs cache for {name:?}: {e}");
log::debug!(target: "worker", "Skipping refs caching for fetch of {repo}");
break;
}
@ -326,7 +326,7 @@ where
}
Err(e) => {
// Object was found, but failed to load. Fall-through.
log::error!(target: "fetch", "Error loading COB {tid} from storage: {e}");
log::debug!(target: "fetch", "Failed to load COB {tid} from storage: {e}");
}
}
// The object has either been removed entirely from the repository,

2
crates/radicle-node/src/worker/upload_pack.rs
View File

@ -137,7 +137,7 @@ where
}
}
Err(e) => {
log::error!(target: "worker", "Error on upload-pack channel read for {}: {e}", header.repo);
log::debug!(target: "worker", "Failure on upload-pack channel read for {}: {e}", header.repo);
emitter.emit(events::UploadPack::error(header.repo, remote, e).into());
break;
}