trivial: debug logging cleanup

src/handshake/client.rs

@@ -71,7 +71,7 @@ impl ClientHandshake {
             }
         };
 
-        debug!("Client handshake initiated.");
+        trace!("Client handshake initiated.");
         MidHandshake { role: client, machine: machine }
     }
 }

src/handshake/machine.rs

@@ -39,6 +39,7 @@ impl<Stream> HandshakeMachine<Stream> {
 impl<Stream: Read + Write> HandshakeMachine<Stream> {
     /// Perform a single handshake round.
     pub fn single_round<Obj: TryParse>(mut self) -> Result<RoundResult<Obj, Stream>> {
+        trace!("Doing handshake round.");
         Ok(match self.state {
             HandshakeState::Reading(mut buf) => {
                 buf.reserve(MIN_READ, usize::max_value()) // TODO limit size

src/handshake/server.rs

@@ -62,6 +62,7 @@ pub struct ServerHandshake;
 impl ServerHandshake {
     /// Start server handshake.
     pub fn start<Stream>(stream: Stream) -> MidHandshake<Stream, Self> {
+        trace!("Server handshake initiated.");
         MidHandshake {
             machine: HandshakeMachine::start_read(stream),
             role: ServerHandshake,
@@ -83,6 +84,7 @@ impl HandshakeRole for ServerHandshake {
                 ProcessingResult::Continue(HandshakeMachine::start_write(stream, response))
             }
             StageResult::DoneWriting(stream) => {
+                debug!("Server handshake done.");
                 ProcessingResult::Done(WebSocket::from_raw_socket(stream, Role::Server))
             }
         })

src/protocol/frame/mod.rs

@@ -46,7 +46,7 @@ impl<Stream> FrameSocket<Stream>
     pub fn read_frame(&mut self) -> Result<Option<Frame>> {
         loop {
             if let Some(frame) = Frame::parse(&mut self.in_buffer.out_mut())? {
-                debug!("received frame {}", frame);
+                trace!("received frame {}", frame);
                 return Ok(Some(frame));
             }
             // No full frames in buffer.
@@ -54,7 +54,7 @@ impl<Stream> FrameSocket<Stream>
                 .map_err(|_| Error::Capacity("Incoming TCP buffer is full".into()))?;
             let size = self.in_buffer.read_from(&mut self.stream)?;
             if size == 0 {
-                debug!("no frame received");
+                trace!("no frame received");
                 return Ok(None)
             }
         }
@@ -71,7 +71,7 @@ impl<Stream> FrameSocket<Stream>
     /// There is no need to resend the frame. In order to handle WouldBlock or Incomplete,
     /// call write_pending() afterwards.
     pub fn write_frame(&mut self, frame: Frame) -> Result<()> {
-        debug!("writing frame {}", frame);
+        trace!("writing frame {}", frame);
         self.out_buffer.reserve(frame.len());
         frame.format(&mut self.out_buffer).expect("Bug: can't write to vector");
         self.write_pending()

src/protocol/mod.rs

@@ -77,7 +77,7 @@ impl<Stream: Read + Write> WebSocket<Stream> {
             // If we get here, either write blocks or we have nothing to write.
             // Thus if read blocks, just let it return WouldBlock.
             if let Some(message) = self.read_message_frame()? {
-                debug!("Received message {}", message);
+                trace!("Received message {}", message);
                 return Ok(message)
             }
         }