Update logs + do not downscore peers if WE time out (#1901)

## Issue Addressed

- RPC Errors were being logged twice: first in the peer manager and then again in the router, so leave just the peer manager's one 
- The "reduce peer count" warn message gets thrown to the user for every missed chunk, so instead print it when the request times out and also do not include there info that is not relevant to the user
- The processor didn't have the service tag so add it
- Impl `KV` for status message
- Do not downscore peers if we are the ones that timed out

Other small improvements

beacon_node/network/src/beacon_processor/chain_segment.rs

@@ -34,12 +34,12 @@ pub fn handle_chain_segment<T: BeaconChainTypes>(
 
             let result = match process_blocks(chain, downloaded_blocks.iter(), &log) {
                 (_, Ok(_)) => {
-                    debug!(log, "Batch processed"; "batch_epoch" => epoch, "first_block_slot" => start_slot,
+                    debug!(log, "Batch processed"; "batch_epoch" => epoch, "first_block_slot" => start_slot, "chain" => chain_id,
                         "last_block_slot" => end_slot, "processed_blocks" => sent_blocks, "service"=> "sync");
                     BatchProcessResult::Success(sent_blocks > 0)
                 }
                 (imported_blocks, Err(e)) => {
-                    debug!(log, "Batch processing failed"; "batch_epoch" => epoch, "first_block_slot" => start_slot,
+                    debug!(log, "Batch processing failed"; "batch_epoch" => epoch, "first_block_slot" => start_slot, "chain" => chain_id,
                         "last_block_slot" => end_slot, "error" => e, "imported_blocks" => imported_blocks, "service" => "sync");
                     BatchProcessResult::Failed(imported_blocks > 0)
                 }

beacon_node/network/src/router/mod.rs

@@ -11,8 +11,8 @@ use crate::error;
 use crate::service::NetworkMessage;
 use beacon_chain::{BeaconChain, BeaconChainTypes};
 use eth2_libp2p::{
-    rpc::{RPCError, RequestId},
-    MessageId, NetworkGlobals, PeerId, PeerRequestId, PubsubMessage, Request, Response,
+    rpc::RequestId, MessageId, NetworkGlobals, PeerId, PeerRequestId, PubsubMessage, Request,
+    Response,
 };
 use futures::prelude::*;
 use processor::Processor;
@@ -26,8 +26,6 @@ use types::EthSpec;
 /// passing them to the internal message processor. The message processor spawns a syncing thread
 /// which manages which blocks need to be requested and processed.
 pub struct Router<T: BeaconChainTypes> {
-    /// Access to the peer db for logging.
-    network_globals: Arc<NetworkGlobals<T::EthSpec>>,
     /// Processes validated and decoded messages from the network. Has direct access to the
     /// sync manager.
     processor: Processor<T>,
@@ -58,7 +56,6 @@ pub enum RouterMessage<T: EthSpec> {
     RPCFailed {
         peer_id: PeerId,
         request_id: RequestId,
-        error: RPCError,
     },
     /// A gossip message has been received. The fields are: message id, the peer that sent us this
     /// message, the message itself and a bool which indicates if the message should be processed
@@ -86,14 +83,13 @@ impl<T: BeaconChainTypes> Router<T> {
         let processor = Processor::new(
             executor.clone(),
             beacon_chain,
-            network_globals.clone(),
+            network_globals,
             network_send,
             &log,
         );
 
         // generate the Message handler
         let mut handler = Router {
-            network_globals,
             processor,
             log: message_handler_log,
         };
@@ -141,13 +137,7 @@ impl<T: BeaconChainTypes> Router<T> {
             RouterMessage::RPCFailed {
                 peer_id,
                 request_id,
-                error,
             } => {
-                debug!(self.log, "RPC Error";
-                    "peer_id" => peer_id.to_string(),
-                    "request_id" => request_id,
-                    "error" => error.to_string(),
-                    "client" => self.network_globals.client(&peer_id).to_string());
                 self.processor.on_rpc_error(peer_id, request_id);
             }
             RouterMessage::PubsubMessage(id, peer_id, gossip, should_process) => {

beacon_node/network/src/router/processor.rs

@@ -78,7 +78,7 @@ impl<T: BeaconChainTypes> Processor<T> {
             sync_send,
             network: HandlerNetworkContext::new(network_send, log.clone()),
             beacon_processor_send,
-            log: log.clone(),
+            log: log.new(o!("service" => "router")),
         }
     }
 
@@ -114,16 +114,7 @@ impl<T: BeaconChainTypes> Processor<T> {
     /// re-status.
     pub fn send_status(&mut self, peer_id: PeerId) {
         if let Ok(status_message) = status_message(&self.chain) {
-            debug!(
-                self.log,
-                "Sending Status Request";
-                "peer" => peer_id.to_string(),
-                "fork_digest" => format!("{:?}", status_message.fork_digest),
-                "finalized_root" => format!("{:?}", status_message.finalized_root),
-                "finalized_epoch" => format!("{:?}", status_message.finalized_epoch),
-                "head_root" => format!("{}", status_message.head_root),
-                "head_slot" => format!("{}", status_message.head_slot),
-            );
+            debug!(self.log, "Sending Status Request"; "peer" => %peer_id, &status_message);
             self.network
                 .send_processor_request(peer_id, Request::Status(status_message));
         }
@@ -138,16 +129,7 @@ impl<T: BeaconChainTypes> Processor<T> {
         request_id: PeerRequestId,
         status: StatusMessage,
     ) {
-        debug!(
-            self.log,
-            "Received Status Request";
-            "peer" => peer_id.to_string(),
-            "fork_digest" => format!("{:?}", status.fork_digest),
-            "finalized_root" => format!("{:?}", status.finalized_root),
-            "finalized_epoch" => format!("{:?}", status.finalized_epoch),
-            "head_root" => format!("{}", status.head_root),
-            "head_slot" => format!("{}", status.head_slot),
-        );
+        debug!(self.log, "Received Status Request"; "peer_id" => %peer_id, &status);
 
         // ignore status responses if we are shutting down
         if let Ok(status_message) = status_message(&self.chain) {
@@ -166,16 +148,7 @@ impl<T: BeaconChainTypes> Processor<T> {
 
     /// Process a `Status` response from a peer.
     pub fn on_status_response(&mut self, peer_id: PeerId, status: StatusMessage) {
-        debug!(
-            self.log,
-            "Received Status Response";
-            "peer_id" => peer_id.to_string(),
-            "fork_digest" => format!("{:?}", status.fork_digest),
-            "finalized_root" => format!("{:?}", status.finalized_root),
-            "finalized_epoch" => format!("{:?}", status.finalized_epoch),
-            "head_root" => format!("{}", status.head_root),
-            "head_slot" => format!("{}", status.head_slot),
-        );
+        debug!(self.log, "Received Status Response"; "peer_id" => %peer_id, &status);
 
         // Process the status message, without sending back another status.
         if let Err(e) = self.process_status(peer_id, status) {
@@ -292,7 +265,7 @@ impl<T: BeaconChainTypes> Processor<T> {
         debug!(
             self.log,
             "Received BlocksByRange Request";
-            "peer" => format!("{:?}", peer_id),
+            "peer_id" => %peer_id,
             "count" => req.count,
             "start_slot" => req.start_slot,
             "step" => req.step,

beacon_node/network/src/service.rs

@@ -484,10 +484,10 @@ fn spawn_service<T: BeaconChainTypes>(
                                     });
 
                             }
-                            BehaviourEvent::RPCFailed{id, peer_id, error} => {
+                            BehaviourEvent::RPCFailed{id, peer_id} => {
                                 let _ = service
                                     .router_send
-                                    .send(RouterMessage::RPCFailed{ peer_id, request_id: id, error })
+                                    .send(RouterMessage::RPCFailed{ peer_id, request_id: id})
                                     .map_err(|_| {
                                         debug!(service.log, "Failed to send RPC to router");
                                     });