added: logs

libp2p/host/basic_host.py

@@ -5,7 +5,6 @@ from collections.abc import (
 from contextlib import (
     asynccontextmanager,
 )
-import logging
 from typing import (
     TYPE_CHECKING,
     Optional,
@@ -68,7 +67,10 @@ if TYPE_CHECKING:
 # telling it to listen on the given listen addresses.
 
 
-logger = logging.getLogger("libp2p.network.basic_host")
+# logger = logging.getLogger("libp2p.network.basic_host")
+from loguru import (
+    logger,
+)
 
 
 class BasicHost(IHost):
@@ -181,12 +183,15 @@ class BasicHost(IHost):
         :return: stream: new stream created
         """
         net_stream = await self._network.new_stream(peer_id)
-
+        logger.info("INETSTREAM CHECKING IN")
+        logger.info(protocol_ids)
         # Perform protocol muxing to determine protocol to use
         try:
+            logger.debug("PROTOCOLS TRYING TO GET SENT")
             selected_protocol = await self.multiselect_client.select_one_of(
                 list(protocol_ids), MultiselectCommunicator(net_stream)
             )
+            logger.info("PROTOCOLS GOT SENT")
         except MultiselectClientError as error:
             logger.debug("fail to open a stream to peer %s, error=%s", peer_id, error)
             await net_stream.reset()

libp2p/network/swarm.py

@@ -1,8 +1,11 @@
-import logging
 from typing import (
     Optional,
 )
 
+# logger = logging.getLogger("libp2p.network.swarm")
+from loguru import (
+    logger,
+)
 from multiaddr import (
     Multiaddr,
 )
@@ -55,8 +58,6 @@ from .exceptions import (
     SwarmException,
 )
 
-logger = logging.getLogger("libp2p.network.swarm")
-
 
 def create_default_stream_handler(network: INetworkService) -> StreamHandlerFn:
     async def stream_handler(stream: INetStream) -> None:
@@ -130,6 +131,7 @@ class Swarm(Service, INetworkService):
         :return: muxed connection
         """
         if peer_id in self.connections:
+            logger.info("WE ARE RETURNING, PEER ALREADAY EXISTS")
             # If muxed connection already exists for peer_id,
             # set muxed connection equal to existing muxed connection
             return self.connections[peer_id]
@@ -150,6 +152,7 @@ class Swarm(Service, INetworkService):
         # Try all known addresses
         for multiaddr in addrs:
             try:
+                logger.info("HANDSHAKE GOING TO HAPPEN")
                 return await self.dial_addr(multiaddr, peer_id)
             except SwarmException as e:
                 exceptions.append(e)
@@ -224,8 +227,11 @@ class Swarm(Service, INetworkService):
         logger.debug("attempting to open a stream to peer %s", peer_id)
 
         swarm_conn = await self.dial_peer(peer_id)
+        logger.info("INETCONN CREATED")
 
         net_stream = await swarm_conn.new_stream()
+        logger.info("INETSTREAM CREATED")
+
         logger.debug("successfully opened a stream to peer %s", peer_id)
         return net_stream
 

libp2p/protocol_muxer/multiselect_client.py

@@ -2,6 +2,10 @@ from collections.abc import (
     Sequence,
 )
 
+from loguru import (
+    logger,
+)
+
 from libp2p.abc import (
     IMultiselectClient,
     IMultiselectCommunicator,
@@ -36,11 +40,15 @@ class MultiselectClient(IMultiselectClient):
         try:
             await communicator.write(MULTISELECT_PROTOCOL_ID)
         except MultiselectCommunicatorError as error:
+            logger.error("WROTE FAIL")
             raise MultiselectClientError() from error
 
+        logger.info(f"WROTE SUC, {MULTISELECT_PROTOCOL_ID}")
         try:
             handshake_contents = await communicator.read()
+            logger.info(f"READ SUC, {handshake_contents}")
         except MultiselectCommunicatorError as error:
+            logger.error(f"READ FAIL, {error}")
             raise MultiselectClientError() from error
 
         if not is_valid_handshake(handshake_contents):
@@ -59,9 +67,12 @@ class MultiselectClient(IMultiselectClient):
         :return: selected protocol
         :raise MultiselectClientError: raised when protocol negotiation failed
         """
+        logger.info("TRYING TO GET THE HANDSHAKE HAPPENED")
         await self.handshake(communicator)
+        logger.info("HANDSHAKE HAPPENED")
 
         for protocol in protocols:
+            logger.info(protocol)
             try:
                 selected_protocol = await self.try_select(communicator, protocol)
                 return selected_protocol
@@ -113,11 +124,17 @@ class MultiselectClient(IMultiselectClient):
         """
         try:
             await communicator.write(protocol)
+            from loguru import (
+                logger,
+            )
+
+            logger.info(protocol)
         except MultiselectCommunicatorError as error:
             raise MultiselectClientError() from error
 
         try:
             response = await communicator.read()
+            logger.info("Response: ", response)
         except MultiselectCommunicatorError as error:
             raise MultiselectClientError() from error