Use different log levels for local and remote errors. (#4785)

afck · web-flow · commit 3f12f83c4d8c · 2025-10-13T16:11:24.000Z
## Motivation Validators shouldn't produce ERROR-level logs just because a client sent them an invalid request. ## Proposal Distinguish between local and potentially remote errors, and log only the former at level ERROR. ## Test Plan CI Keep an eye on testnet logs: they should have fewer ERRORs now. ## Release Plan - These changes should be backported to `testnet_conway` and: - released in a validator hotfix. ## Links - [reviewer checklist](https://github.com/linera-io/linera-protocol/blob/main/CONTRIBUTING.md#reviewer-checklist)
diff --git a/linera-chain/src/lib.rs b/linera-chain/src/lib.rs
@@ -30,7 +30,6 @@ use linera_base::{
 };
 use linera_execution::ExecutionError;
 use linera_views::ViewError;
-use rand_distr::WeightedError;
 use thiserror::Error;
 
 #[derive(Error, Debug)]
@@ -144,8 +143,6 @@ pub enum ChainError {
     BlockProposalTooLarge(usize),
     #[error(transparent)]
     BcsError(#[from] bcs::Error),
-    #[error("Invalid owner weights: {0}")]
-    OwnerWeightError(#[from] WeightedError),
     #[error("Closed chains cannot have operations, accepted messages or empty blocks")]
     ClosedChain,
     #[error("Empty blocks are not allowed")]
@@ -162,6 +159,51 @@ pub enum ChainError {
     NotTimedOutYet(Timestamp),
 }
 
+impl ChainError {
+    /// Returns whether this error is caused by an issue in the local node.
+    ///
+    /// Returns `false` whenever the error could be caused by a bad message from a peer.
+    pub fn is_local(&self) -> bool {
+        match self {
+            ChainError::CryptoError(_)
+            | ChainError::ArithmeticError(_)
+            | ChainError::ViewError(ViewError::NotFound(_))
+            | ChainError::InactiveChain(_)
+            | ChainError::IncorrectMessageOrder { .. }
+            | ChainError::CannotRejectMessage { .. }
+            | ChainError::CannotSkipMessage { .. }
+            | ChainError::IncorrectBundleTimestamp { .. }
+            | ChainError::InvalidSigner
+            | ChainError::UnexpectedBlockHeight { .. }
+            | ChainError::UnexpectedPreviousBlockHash
+            | ChainError::BlockHeightOverflow
+            | ChainError::InvalidBlockTimestamp { .. }
+            | ChainError::InsufficientRound(_)
+            | ChainError::InsufficientRoundStrict(_)
+            | ChainError::WrongRound(_)
+            | ChainError::HasIncompatibleConfirmedVote(..)
+            | ChainError::MustBeNewerThanLockingBlock(..)
+            | ChainError::MissingEarlierBlocks { .. }
+            | ChainError::CertificateValidatorReuse
+            | ChainError::CertificateRequiresQuorum
+            | ChainError::BlockProposalTooLarge(_)
+            | ChainError::ClosedChain
+            | ChainError::EmptyBlock
+            | ChainError::AuthorizedApplications(_)
+            | ChainError::MissingMandatoryApplications(_)
+            | ChainError::MissingOracleResponseList
+            | ChainError::RoundDoesNotTimeOut
+            | ChainError::NotTimedOutYet(_)
+            | ChainError::MissingCrossChainUpdate { .. } => false,
+            ChainError::ViewError(_)
+            | ChainError::UnexpectedMessage { .. }
+            | ChainError::InternalError(_)
+            | ChainError::BcsError(_) => true,
+            ChainError::ExecutionError(execution_error, _) => execution_error.is_local(),
+        }
+    }
+}
+
 #[derive(Copy, Clone, Debug)]
 #[cfg_attr(with_testing, derive(Eq, PartialEq))]
 pub enum ChainExecutionContext {
diff --git a/linera-core/src/worker.rs b/linera-core/src/worker.rs
@@ -250,6 +250,44 @@ pub enum WorkerError {
     },
 }
 
+impl WorkerError {
+    /// Returns whether this error is caused by an issue in the local node.
+    ///
+    /// Returns `false` whenever the error could be caused by a bad message from a peer.
+    pub fn is_local(&self) -> bool {
+        match self {
+            WorkerError::CryptoError(_)
+            | WorkerError::ArithmeticError(_)
+            | WorkerError::InvalidOwner
+            | WorkerError::InvalidSigner(_)
+            | WorkerError::UnexpectedBlockHeight { .. }
+            | WorkerError::InvalidEpoch { .. }
+            | WorkerError::EventsNotFound(_)
+            | WorkerError::InvalidBlockChaining
+            | WorkerError::IncorrectOutcome { .. }
+            | WorkerError::InvalidTimestamp
+            | WorkerError::MissingCertificateValue
+            | WorkerError::InvalidLiteCertificate
+            | WorkerError::FastBlockUsingOracles
+            | WorkerError::BlobsNotFound(_)
+            | WorkerError::InvalidBlockProposal(_)
+            | WorkerError::UnexpectedBlob
+            | WorkerError::TooManyPublishedBlobs(_)
+            | WorkerError::ViewError(ViewError::NotFound(_)) => false,
+            WorkerError::InvalidCrossChainRequest
+            | WorkerError::ViewError(_)
+            | WorkerError::ConfirmedLogEntryNotFound { .. }
+            | WorkerError::PreprocessedBlocksEntryNotFound { .. }
+            | WorkerError::JoinError
+            | WorkerError::MissingNetworkDescription
+            | WorkerError::ChainActorSendError { .. }
+            | WorkerError::ChainActorRecvError { .. }
+            | WorkerError::ReadCertificatesError(_) => true,
+            WorkerError::ChainError(chain_error) => chain_error.is_local(),
+        }
+    }
+}
+
 impl From<ChainError> for WorkerError {
     #[instrument(level = "trace", skip(chain_error))]
     fn from(chain_error: ChainError) -> Self {
diff --git a/linera-execution/src/lib.rs b/linera-execution/src/lib.rs
@@ -322,6 +322,74 @@ pub enum ExecutionError {
     OutdatedUpdateStreams,
 }
 
+impl ExecutionError {
+    /// Returns whether this error is caused by an issue in the local node.
+    ///
+    /// Returns `false` whenever the error could be caused by a bad message from a peer.
+    pub fn is_local(&self) -> bool {
+        match self {
+            ExecutionError::ArithmeticError(_)
+            | ExecutionError::UserError(_)
+            | ExecutionError::DecompressionError(_)
+            | ExecutionError::InvalidPromise
+            | ExecutionError::CrossApplicationCallInFinalize { .. }
+            | ExecutionError::ReentrantCall(_)
+            | ExecutionError::ApplicationBytecodeNotFound(_)
+            | ExecutionError::UnsupportedDynamicApplicationLoad(_)
+            | ExecutionError::ExcessiveRead
+            | ExecutionError::ExcessiveWrite
+            | ExecutionError::MaximumFuelExceeded(_)
+            | ExecutionError::MaximumServiceOracleExecutionTimeExceeded
+            | ExecutionError::ServiceOracleResponseTooLarge
+            | ExecutionError::BlockTooLarge
+            | ExecutionError::HttpResponseSizeLimitExceeded { .. }
+            | ExecutionError::UnauthorizedApplication(_)
+            | ExecutionError::UnexpectedOracleResponse
+            | ExecutionError::JsonError(_)
+            | ExecutionError::BcsError(_)
+            | ExecutionError::OracleResponseMismatch
+            | ExecutionError::ServiceOracleQueryOperations(_)
+            | ExecutionError::AssertBefore { .. }
+            | ExecutionError::StreamNameTooLong
+            | ExecutionError::BlobTooLarge
+            | ExecutionError::BytecodeTooLarge
+            | ExecutionError::UnauthorizedHttpRequest(_)
+            | ExecutionError::InvalidUrlForHttpRequest(_)
+            | ExecutionError::InactiveChain(_)
+            | ExecutionError::BlobsNotFound(_)
+            | ExecutionError::EventsNotFound(_)
+            | ExecutionError::InvalidHeaderName(_)
+            | ExecutionError::InvalidHeaderValue(_)
+            | ExecutionError::InvalidEpoch { .. }
+            | ExecutionError::IncorrectTransferAmount
+            | ExecutionError::UnauthenticatedTransferOwner
+            | ExecutionError::InsufficientBalance { .. }
+            | ExecutionError::FeesExceedFunding { .. }
+            | ExecutionError::IncorrectClaimAmount
+            | ExecutionError::UnauthenticatedClaimOwner
+            | ExecutionError::AdminOperationOnNonAdminChain
+            | ExecutionError::InvalidCommitteeEpoch { .. }
+            | ExecutionError::InvalidCommitteeRemoval
+            | ExecutionError::MissingOracleResponse
+            | ExecutionError::UnprocessedStreams
+            | ExecutionError::OutdatedUpdateStreams
+            | ExecutionError::ViewError(ViewError::NotFound(_)) => false,
+            #[cfg(with_wasm_runtime)]
+            ExecutionError::WasmError(_) => false,
+            #[cfg(with_revm)]
+            ExecutionError::EvmError(..) => false,
+            ExecutionError::MissingRuntimeResponse
+            | ExecutionError::ViewError(_)
+            | ExecutionError::ReqwestError(_)
+            | ExecutionError::ContractModuleSend(_)
+            | ExecutionError::ServiceModuleSend(_)
+            | ExecutionError::NoNetworkDescriptionFound
+            | ExecutionError::InternalError(_)
+            | ExecutionError::IoError(_) => true,
+        }
+    }
+}
+
 /// The public entry points provided by the contract part of an application.
 pub trait UserContract {
     /// Instantiate the application state on the chain that owns the application.
diff --git a/linera-rpc/src/grpc/server.rs b/linera-rpc/src/grpc/server.rs
@@ -16,7 +16,7 @@ use linera_base::{
 use linera_core::{
     join_set_ext::JoinSet,
     node::NodeError,
-    worker::{NetworkActions, Notification, Reason, WorkerError, WorkerState},
+    worker::{NetworkActions, Notification, Reason, WorkerState},
     JoinSetExt as _, TaskHandle,
 };
 use linera_storage::Storage;
@@ -429,6 +429,15 @@ where
             }
         }
     }
+
+    fn log_error(&self, error: &linera_core::worker::WorkerError, context: &str) {
+        let nickname = self.state.nickname();
+        if error.is_local() {
+            error!(nickname, %error, "{}", context);
+        } else {
+            debug!(nickname, %error, "{}", context);
+        }
+    }
 }
 
 #[tonic::async_trait]
@@ -508,12 +517,7 @@ where
             }
             Err(error) => {
                 Self::log_request_outcome_and_latency(start, false, "handle_lite_certificate");
-                let nickname = self.state.nickname();
-                if let WorkerError::MissingCertificateValue = &error {
-                    debug!(nickname, %error, "Failed to handle lite certificate");
-                } else {
-                    error!(nickname, %error, "Failed to handle lite certificate");
-                }
+                self.log_error(&error, "Failed to handle lite certificate");
                 Ok(Response::new(NodeError::from(error).try_into()?))
             }
         }
@@ -557,8 +561,7 @@ where
             }
             Err(error) => {
                 Self::log_request_outcome_and_latency(start, false, "handle_confirmed_certificate");
-                let nickname = self.state.nickname();
-                error!(nickname, %error, "Failed to handle confirmed certificate");
+                self.log_error(&error, "Failed to handle confirmed certificate");
                 Ok(Response::new(NodeError::from(error).try_into()?))
             }
         }
@@ -593,8 +596,7 @@ where
             }
             Err(error) => {
                 Self::log_request_outcome_and_latency(start, false, "handle_validated_certificate");
-                let nickname = self.state.nickname();
-                error!(nickname, %error, "Failed to handle validated certificate");
+                self.log_error(&error, "Failed to handle validated certificate");
                 Ok(Response::new(NodeError::from(error).try_into()?))
             }
         }
@@ -628,8 +630,7 @@ where
             }
             Err(error) => {
                 Self::log_request_outcome_and_latency(start, false, "handle_timeout_certificate");
-                let nickname = self.state.nickname();
-                error!(nickname, %error, "Failed to handle timeout certificate");
+                self.log_error(&error, "Failed to handle timeout certificate");
                 Ok(Response::new(NodeError::from(error).try_into()?))
             }
         }
@@ -659,8 +660,7 @@ where
             }
             Err(error) => {
                 Self::log_request_outcome_and_latency(start, false, "handle_chain_info_query");
-                let nickname = self.state.nickname();
-                error!(nickname, %error, "Failed to handle chain info query");
+                self.log_error(&error, "Failed to handle chain info query");
                 Ok(Response::new(NodeError::from(error).try_into()?))
             }
         }
@@ -694,8 +694,7 @@ where
             }
             Err(error) => {
                 Self::log_request_outcome_and_latency(start, false, "download_pending_blob");
-                let nickname = self.state.nickname();
-                error!(nickname, %error, "Failed to download pending blob");
+                self.log_error(&error, "Failed to download pending blob");
                 Ok(Response::new(NodeError::from(error).try_into()?))
             }
         }
@@ -726,8 +725,7 @@ where
             }
             Err(error) => {
                 Self::log_request_outcome_and_latency(start, false, "handle_pending_blob");
-                let nickname = self.state.nickname();
-                error!(nickname, %error, "Failed to handle pending blob");
+                self.log_error(&error, "Failed to handle pending blob");
                 Ok(Response::new(NodeError::from(error).try_into()?))
             }
         }
diff --git a/linera-rpc/src/simple/server.rs b/linera-rpc/src/simple/server.rs
@@ -15,7 +15,7 @@ use linera_core::{
 use linera_storage::Storage;
 use tokio::{sync::oneshot, task::JoinSet};
 use tokio_util::sync::CancellationToken;
-use tracing::{debug, error, info, instrument, warn};
+use tracing::{debug, error, info, instrument};
 
 use super::transport::{MessageHandler, ServerHandle, TransportProtocol};
 use crate::{
@@ -188,8 +188,7 @@ where
                         Ok(Some(RpcMessage::ChainInfoResponse(Box::new(info))))
                     }
                     Err(error) => {
-                        let nickname = self.server.state.nickname();
-                        warn!(nickname, %error, "Failed to handle block proposal");
+                        self.log_error(&error, "Failed to handle block proposal");
                         Err(error.into())
                     }
                 }
@@ -242,8 +241,7 @@ where
                         Ok(Some(RpcMessage::ChainInfoResponse(Box::new(info))))
                     }
                     Err(error) => {
-                        let nickname = self.server.state.nickname();
-                        error!(nickname, %error, "Failed to handle timeout certificate");
+                        self.log_error(&error, "Failed to handle timeout certificate");
                         Err(error.into())
                     }
                 }
@@ -262,10 +260,7 @@ where
                         Ok(Some(RpcMessage::ChainInfoResponse(Box::new(info))))
                     }
                     Err(error) => {
-                        error!(
-                            nickname = self.server.state.nickname(), %error,
-                            "Failed to handle validated certificate"
-                        );
+                        self.log_error(&error, "Failed to handle validated certificate");
                         Err(error.into())
                     }
                 }
@@ -293,8 +288,7 @@ where
                         Ok(Some(RpcMessage::ChainInfoResponse(Box::new(info))))
                     }
                     Err(error) => {
-                        let nickname = self.server.state.nickname();
-                        error!(nickname, %error, "Failed to handle confirmed certificate");
+                        self.log_error(&error, "Failed to handle confirmed certificate");
                         Err(error.into())
                     }
                 }
@@ -308,8 +302,7 @@ where
                         Ok(Some(RpcMessage::ChainInfoResponse(Box::new(info))))
                     }
                     Err(error) => {
-                        let nickname = self.server.state.nickname();
-                        error!(nickname, %error, "Failed to handle chain info query");
+                        self.log_error(&error, "Failed to handle chain info query");
                         Err(error.into())
                     }
                 }
@@ -320,8 +313,7 @@ where
                         self.handle_network_actions(actions);
                     }
                     Err(error) => {
-                        let nickname = self.server.state.nickname();
-                        error!(nickname, %error, "Failed to handle cross-chain request");
+                        self.log_error(&error, "Failed to handle cross-chain request");
                     }
                 }
                 // No user to respond to.
@@ -339,8 +331,7 @@ where
                         blob.into(),
                     )))),
                     Err(error) => {
-                        let nickname = self.server.state.nickname();
-                        error!(nickname, %error, "Failed to handle pending blob request");
+                        self.log_error(&error, "Failed to handle pending blob request");
                         Err(error.into())
                     }
                 }
@@ -355,8 +346,7 @@ where
                 {
                     Ok(info) => Ok(Some(RpcMessage::ChainInfoResponse(Box::new(info)))),
                     Err(error) => {
-                        let nickname = self.server.state.nickname();
-                        error!(nickname, %error, "Failed to handle pending blob");
+                        self.log_error(&error, "Failed to handle pending blob");
                         Err(error.into())
                     }
                 }
@@ -442,4 +432,13 @@ where
             }
         }
     }
+
+    fn log_error(&self, error: &WorkerError, context: &str) {
+        let nickname = self.server.state.nickname();
+        if error.is_local() {
+            error!(nickname, %error, "{}", context);
+        } else {
+            debug!(nickname, %error, "{}", context);
+        }
+    }
 }
diff --git a/linera-service/src/proxy/main.rs b/linera-service/src/proxy/main.rs

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ use linera_base::{`
`16`	`16`	`use linera_core::{`
`17`	`17`	`join_set_ext::JoinSet,`
`18`	`18`	`node::NodeError,`
`19`		`- worker::{NetworkActions, Notification, Reason, WorkerError, WorkerState},`
	`19`	`+ worker::{NetworkActions, Notification, Reason, WorkerState},`
`20`	`20`	`JoinSetExt as _, TaskHandle,`
`21`	`21`	`};`
`22`	`22`	`use linera_storage::Storage;`
`@@ -429,6 +429,15 @@ where`
`429`	`429`	`}`
`430`	`430`	`}`
`431`	`431`	`}`
	`432`	`+`
	`433`	`+ fn log_error(&self, error: &linera_core::worker::WorkerError, context: &str) {`
	`434`	`+ let nickname = self.state.nickname();`
	`435`	`+ if error.is_local() {`
	`436`	`+ error!(nickname, %error, "{}", context);`
	`437`	`+ } else {`
	`438`	`+ debug!(nickname, %error, "{}", context);`
	`439`	`+ }`
	`440`	`+ }`
`432`	`441`	`}`
`433`	`442`
`434`	`443`	`#[tonic::async_trait]`
`@@ -508,12 +517,7 @@ where`
`508`	`517`	`}`
`509`	`518`	`Err(error) => {`
`510`	`519`	`Self::log_request_outcome_and_latency(start, false, "handle_lite_certificate");`
`511`		`- let nickname = self.state.nickname();`
`512`		`- if let WorkerError::MissingCertificateValue = &error {`
`513`		`- debug!(nickname, %error, "Failed to handle lite certificate");`
`514`		`- } else {`
`515`		`- error!(nickname, %error, "Failed to handle lite certificate");`
`516`		`- }`
	`520`	`+ self.log_error(&error, "Failed to handle lite certificate");`
`517`	`521`	`Ok(Response::new(NodeError::from(error).try_into()?))`
`518`	`522`	`}`
`519`	`523`	`}`
`@@ -557,8 +561,7 @@ where`
`557`	`561`	`}`
`558`	`562`	`Err(error) => {`
`559`	`563`	`Self::log_request_outcome_and_latency(start, false, "handle_confirmed_certificate");`
`560`		`- let nickname = self.state.nickname();`
`561`		`- error!(nickname, %error, "Failed to handle confirmed certificate");`
	`564`	`+ self.log_error(&error, "Failed to handle confirmed certificate");`
`562`	`565`	`Ok(Response::new(NodeError::from(error).try_into()?))`
`563`	`566`	`}`
`564`	`567`	`}`
`@@ -593,8 +596,7 @@ where`
`593`	`596`	`}`
`594`	`597`	`Err(error) => {`
`595`	`598`	`Self::log_request_outcome_and_latency(start, false, "handle_validated_certificate");`
`596`		`- let nickname = self.state.nickname();`
`597`		`- error!(nickname, %error, "Failed to handle validated certificate");`
	`599`	`+ self.log_error(&error, "Failed to handle validated certificate");`
`598`	`600`	`Ok(Response::new(NodeError::from(error).try_into()?))`
`599`	`601`	`}`
`600`	`602`	`}`
`@@ -628,8 +630,7 @@ where`
`628`	`630`	`}`
`629`	`631`	`Err(error) => {`
`630`	`632`	`Self::log_request_outcome_and_latency(start, false, "handle_timeout_certificate");`
`631`		`- let nickname = self.state.nickname();`
`632`		`- error!(nickname, %error, "Failed to handle timeout certificate");`
	`633`	`+ self.log_error(&error, "Failed to handle timeout certificate");`
`633`	`634`	`Ok(Response::new(NodeError::from(error).try_into()?))`
`634`	`635`	`}`
`635`	`636`	`}`
`@@ -659,8 +660,7 @@ where`
`659`	`660`	`}`
`660`	`661`	`Err(error) => {`
`661`	`662`	`Self::log_request_outcome_and_latency(start, false, "handle_chain_info_query");`
`662`		`- let nickname = self.state.nickname();`
`663`		`- error!(nickname, %error, "Failed to handle chain info query");`
	`663`	`+ self.log_error(&error, "Failed to handle chain info query");`
`664`	`664`	`Ok(Response::new(NodeError::from(error).try_into()?))`
`665`	`665`	`}`
`666`	`666`	`}`
`@@ -694,8 +694,7 @@ where`
`694`	`694`	`}`
`695`	`695`	`Err(error) => {`
`696`	`696`	`Self::log_request_outcome_and_latency(start, false, "download_pending_blob");`
`697`		`- let nickname = self.state.nickname();`
`698`		`- error!(nickname, %error, "Failed to download pending blob");`
	`697`	`+ self.log_error(&error, "Failed to download pending blob");`
`699`	`698`	`Ok(Response::new(NodeError::from(error).try_into()?))`
`700`	`699`	`}`
`701`	`700`	`}`
`@@ -726,8 +725,7 @@ where`
`726`	`725`	`}`
`727`	`726`	`Err(error) => {`
`728`	`727`	`Self::log_request_outcome_and_latency(start, false, "handle_pending_blob");`
`729`		`- let nickname = self.state.nickname();`
`730`		`- error!(nickname, %error, "Failed to handle pending blob");`
	`728`	`+ self.log_error(&error, "Failed to handle pending blob");`
`731`	`729`	`Ok(Response::new(NodeError::from(error).try_into()?))`
`732`	`730`	`}`
`733`	`731`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ use linera_core::{`
`15`	`15`	`use linera_storage::Storage;`
`16`	`16`	`use tokio::{sync::oneshot, task::JoinSet};`
`17`	`17`	`use tokio_util::sync::CancellationToken;`
`18`		`-use tracing::{debug, error, info, instrument, warn};`
	`18`	`+use tracing::{debug, error, info, instrument};`
`19`	`19`
`20`	`20`	`use super::transport::{MessageHandler, ServerHandle, TransportProtocol};`
`21`	`21`	`use crate::{`
`@@ -188,8 +188,7 @@ where`
`188`	`188`	`Ok(Some(RpcMessage::ChainInfoResponse(Box::new(info))))`
`189`	`189`	`}`
`190`	`190`	`Err(error) => {`
`191`		`- let nickname = self.server.state.nickname();`
`192`		`- warn!(nickname, %error, "Failed to handle block proposal");`
	`191`	`+ self.log_error(&error, "Failed to handle block proposal");`
`193`	`192`	`Err(error.into())`
`194`	`193`	`}`
`195`	`194`	`}`
`@@ -242,8 +241,7 @@ where`
`242`	`241`	`Ok(Some(RpcMessage::ChainInfoResponse(Box::new(info))))`
`243`	`242`	`}`
`244`	`243`	`Err(error) => {`
`245`		`- let nickname = self.server.state.nickname();`
`246`		`- error!(nickname, %error, "Failed to handle timeout certificate");`
	`244`	`+ self.log_error(&error, "Failed to handle timeout certificate");`
`247`	`245`	`Err(error.into())`
`248`	`246`	`}`
`249`	`247`	`}`
`@@ -262,10 +260,7 @@ where`
`262`	`260`	`Ok(Some(RpcMessage::ChainInfoResponse(Box::new(info))))`
`263`	`261`	`}`
`264`	`262`	`Err(error) => {`
`265`		`- error!(`
`266`		`- nickname = self.server.state.nickname(), %error,`
`267`		`- "Failed to handle validated certificate"`
`268`		`- );`
	`263`	`+ self.log_error(&error, "Failed to handle validated certificate");`
`269`	`264`	`Err(error.into())`
`270`	`265`	`}`
`271`	`266`	`}`
`@@ -293,8 +288,7 @@ where`
`293`	`288`	`Ok(Some(RpcMessage::ChainInfoResponse(Box::new(info))))`
`294`	`289`	`}`
`295`	`290`	`Err(error) => {`
`296`		`- let nickname = self.server.state.nickname();`
`297`		`- error!(nickname, %error, "Failed to handle confirmed certificate");`
	`291`	`+ self.log_error(&error, "Failed to handle confirmed certificate");`
`298`	`292`	`Err(error.into())`
`299`	`293`	`}`
`300`	`294`	`}`
`@@ -308,8 +302,7 @@ where`
`308`	`302`	`Ok(Some(RpcMessage::ChainInfoResponse(Box::new(info))))`
`309`	`303`	`}`
`310`	`304`	`Err(error) => {`
`311`		`- let nickname = self.server.state.nickname();`
`312`		`- error!(nickname, %error, "Failed to handle chain info query");`
	`305`	`+ self.log_error(&error, "Failed to handle chain info query");`
`313`	`306`	`Err(error.into())`
`314`	`307`	`}`
`315`	`308`	`}`
`@@ -320,8 +313,7 @@ where`
`320`	`313`	`self.handle_network_actions(actions);`
`321`	`314`	`}`
`322`	`315`	`Err(error) => {`
`323`		`- let nickname = self.server.state.nickname();`
`324`		`- error!(nickname, %error, "Failed to handle cross-chain request");`
	`316`	`+ self.log_error(&error, "Failed to handle cross-chain request");`
`325`	`317`	`}`
`326`	`318`	`}`
`327`	`319`	`// No user to respond to.`
`@@ -339,8 +331,7 @@ where`
`339`	`331`	`blob.into(),`
`340`	`332`	`)))),`
`341`	`333`	`Err(error) => {`
`342`		`- let nickname = self.server.state.nickname();`
`343`		`- error!(nickname, %error, "Failed to handle pending blob request");`
	`334`	`+ self.log_error(&error, "Failed to handle pending blob request");`
`344`	`335`	`Err(error.into())`
`345`	`336`	`}`
`346`	`337`	`}`
`@@ -355,8 +346,7 @@ where`
`355`	`346`	`{`
`356`	`347`	`Ok(info) => Ok(Some(RpcMessage::ChainInfoResponse(Box::new(info)))),`
`357`	`348`	`Err(error) => {`
`358`		`- let nickname = self.server.state.nickname();`
`359`		`- error!(nickname, %error, "Failed to handle pending blob");`
	`349`	`+ self.log_error(&error, "Failed to handle pending blob");`
`360`	`350`	`Err(error.into())`
`361`	`351`	`}`
`362`	`352`	`}`
`@@ -442,4 +432,13 @@ where`
`442`	`432`	`}`
`443`	`433`	`}`
`444`	`434`	`}`
	`435`	`+`
	`436`	`+ fn log_error(&self, error: &WorkerError, context: &str) {`
	`437`	`+ let nickname = self.server.state.nickname();`
	`438`	`+ if error.is_local() {`
	`439`	`+ error!(nickname, %error, "{}", context);`
	`440`	`+ } else {`
	`441`	`+ debug!(nickname, %error, "{}", context);`
	`442`	`+ }`
	`443`	`+ }`
`445`	`444`	`}`