feat(p2p): log received messages with peer count

crates/net/p2p/src/gossipsub/handler.rs

@@ -26,9 +26,11 @@ pub async fn handle_gossipsub_message(server: &mut P2PServer, event: Event) {
     else {
         unreachable!("we already matched on Message variant in handle_swarm_event");
     };
+    let peer_count = server.connected_peers.len();
     let topic_kind = message.topic.as_str().split("/").nth(3);
     match topic_kind {
         Some(BLOCK_TOPIC_KIND) => {
+            info!(kind = "block", peer_count, "P2P message received");
             let Ok(uncompressed_data) = decompress_message(&message.data)
                 .inspect_err(|err| error!(%err, "Failed to decompress gossipped block"))
             else {
@@ -61,6 +63,7 @@ pub async fn handle_gossipsub_message(server: &mut P2PServer, event: Event) {
             }
         }
         Some(AGGREGATION_TOPIC_KIND) => {
+            info!(kind = "aggregation", peer_count, "P2P message received");
             let Ok(uncompressed_data) = decompress_message(&message.data)
                 .inspect_err(|err| error!(%err, "Failed to decompress gossipped aggregation"))
             else {
@@ -91,6 +94,7 @@ pub async fn handle_gossipsub_message(server: &mut P2PServer, event: Event) {
             }
         }
         Some(kind) if kind.starts_with(ATTESTATION_SUBNET_TOPIC_PREFIX) => {
+            info!(kind = "attestation", peer_count, "P2P message received");
             let Ok(uncompressed_data) = decompress_message(&message.data)
                 .inspect_err(|err| error!(%err, "Failed to decompress gossipped attestation"))
             else {

crates/net/p2p/src/req_resp/handlers.rs

@@ -28,31 +28,48 @@ pub async fn handle_req_resp_message(
         request_response::Event::Message { peer, message, .. } => match message {
             request_response::Message::Request {
                 request, channel, ..
-            } => match request {
-                Request::Status(status) => {
-                    handle_status_request(server, status, channel, peer).await;
-                }
-                Request::BlocksByRoot(request) => {
-                    handle_blocks_by_root_request(server, request, channel, peer).await;
+            } => {
+                let peer_count = server.connected_peers.len();
+                match request {
+                    Request::Status(status) => {
+                        info!(kind = "status_request", peer_count, "P2P message received");
+                        handle_status_request(server, status, channel, peer).await;
+                    }
+                    Request::BlocksByRoot(request) => {
+                        info!(
+                            kind = "blocks_by_root_request",
+                            peer_count, "P2P message received"
+                        );
+                        handle_blocks_by_root_request(server, request, channel, peer).await;
+                    }
                 }
-            },
+            }
             request_response::Message::Response {
                 request_id,
                 response,
-            } => match response {
-                Response::Success { payload } => match payload {
-                    ResponsePayload::Status(status) => {
-                        handle_status_response(status, peer).await;
-                    }
-                    ResponsePayload::BlocksByRoot(blocks) => {
-                        handle_blocks_by_root_response(server, blocks, peer, request_id, ctx).await;
+            } => {
+                let peer_count = server.connected_peers.len();
+                match response {
+                    Response::Success { payload } => match payload {
+                        ResponsePayload::Status(status) => {
+                            info!(kind = "status_response", peer_count, "P2P message received");
+                            handle_status_response(status, peer).await;
+                        }
+                        ResponsePayload::BlocksByRoot(blocks) => {
+                            info!(
+                                kind = "blocks_by_root_response",
+                                peer_count, "P2P message received"
+                            );
+                            handle_blocks_by_root_response(server, blocks, peer, request_id, ctx)
+                                .await;
+                        }
+                    },
+                    Response::Error { code, message } => {
+                        let error_str = String::from_utf8_lossy(&message);
+                        warn!(%peer, ?code, %error_str, "Received error response");
                     }
-                },
-                Response::Error { code, message } => {
-                    let error_str = String::from_utf8_lossy(&message);
-                    warn!(%peer, ?code, %error_str, "Received error response");
                 }
-            },
+            }
         },
         request_response::Event::OutboundFailure {
             peer,