Reduce logging in the message reader

Sources/GRPC/ClientResponseChannelHandler.swift

@@ -169,7 +169,7 @@ internal class ClientResponseChannelHandler<ResponseMessage: Message>: ChannelIn
         return
       }
 
-      self.logger.info("received response headers: \(headers)")
+      self.logger.debug("received response headers: \(headers)")
 
       self.initialMetadataPromise.succeed(headers)
       self.inboundState = .expectingMessageOrStatus
@@ -184,7 +184,7 @@ internal class ClientResponseChannelHandler<ResponseMessage: Message>: ChannelIn
         return
       }
 
-      self.logger.info("received response message", metadata: [
+      self.logger.debug("received response message", metadata: [
         MetadataKey.responseType: "\(ResponseMessage.self)"
       ])
 
@@ -201,7 +201,7 @@ internal class ClientResponseChannelHandler<ResponseMessage: Message>: ChannelIn
         return
       }
 
-      self.logger.info("received response status: \(status.code)")
+      self.logger.debug("received response status: \(status.code)")
       self.observeStatus(status, trailingMetadata: trailers)
       // We don't expect any more requests/responses beyond this point and we don't need to close
       // the channel since NIO's HTTP/2 channel handlers will deal with this for us.

Sources/GRPC/LengthPrefixedMessageReader.swift

@@ -65,7 +65,7 @@ public class LengthPrefixedMessageReader {
   private var buffer: ByteBuffer!
   private var state: ParseState = .expectingCompressedFlag {
     didSet {
-      self.logger.debug("parse state changed from \(oldValue) to \(self.state)")
+      self.logger.trace("parse state changed from \(oldValue) to \(self.state)")
     }
   }
 
@@ -89,15 +89,15 @@ public class LengthPrefixedMessageReader {
     guard buffer.readableBytes > 0 else {
       return
     }
-    self.logger.info("appending \(buffer.readableBytes) bytes to buffer")
+    self.logger.trace("appending \(buffer.readableBytes) bytes to buffer")
 
     if self.buffer == nil {
-      self.logger.debug("creating new buffer from slice")
+      self.logger.trace("creating new buffer from slice")
       self.buffer = buffer.slice()
       // mark the bytes as "read"
       buffer.moveReaderIndex(forwardBy: buffer.readableBytes)
     } else {
-      self.logger.debug("copying bytes into existing buffer")
+      self.logger.trace("copying bytes into existing buffer")
       self.buffer.writeBuffer(&buffer)
     }
   }
@@ -117,7 +117,7 @@ public class LengthPrefixedMessageReader {
       return try nextMessage()
 
     case .message(let message):
-      self.logger.info("read length-prefixed message")
+      self.logger.trace("read length-prefixed message")
       self.nilBufferIfPossible()
       return message
     }
@@ -128,42 +128,42 @@ public class LengthPrefixedMessageReader {
   /// This allows the next call to `append` to avoid writing the contents of the appended buffer.
   private func nilBufferIfPossible() {
     if self.buffer?.readableBytes == 0 {
-      self.logger.debug("no readable bytes; nilling-out buffer")
+      self.logger.trace("no readable bytes; nilling-out buffer")
       self.buffer = nil
     }
   }
 
   private func processNextState() throws -> ParseResult {
     guard self.buffer != nil else {
-      self.logger.debug("no buffer to read from")
+      self.logger.trace("no buffer to read from")
       return .needMoreData
     }
 
     switch self.state {
     case .expectingCompressedFlag:
       guard let compressionFlag: Int8 = self.buffer.readInteger() else {
-        self.logger.debug("1 more byte needed to read compression flag")
+        self.logger.trace("1 more byte needed to read compression flag")
         return .needMoreData
       }
-      self.logger.debug("read 1 byte compression flag: \(compressionFlag)")
+      self.logger.trace("read 1 byte compression flag: \(compressionFlag)")
       try self.handleCompressionFlag(enabled: compressionFlag != 0)
       self.state = .expectingMessageLength
 
     case .expectingMessageLength:
       guard let messageLength: UInt32 = self.buffer.readInteger() else {
-        self.logger.debug("\(4 - buffer.readableBytes) more bytes needed to read message length")
+        self.logger.trace("\(4 - buffer.readableBytes) more bytes needed to read message length")
         return .needMoreData
       }
-      self.logger.debug("read 4 byte message length: \(messageLength)")
+      self.logger.trace("read 4 byte message length: \(messageLength)")
       self.state = .expectingMessage(messageLength)
 
     case .expectingMessage(let length):
       let signedLength: Int = numericCast(length)
       guard let message = self.buffer.readSlice(length: signedLength) else {
-        self.logger.debug("\(signedLength - buffer.readableBytes) more bytes needed to read message")
+        self.logger.trace("\(signedLength - buffer.readableBytes) more bytes needed to read message")
         return .needMoreData
       }
-      self.logger.debug("read \(message.readableBytes) byte message")
+      self.logger.trace("read \(message.readableBytes) byte message")
       self.state = .expectingCompressedFlag
       return .message(message)
     }
@@ -173,10 +173,10 @@ public class LengthPrefixedMessageReader {
 
   private func handleCompressionFlag(enabled flagEnabled: Bool) throws {
     guard flagEnabled else {
-      self.logger.debug("compression is not enabled for this message")
+      self.logger.trace("compression is not enabled for this message")
       return
     }
-    self.logger.info("compression is enabled for this message")
+    self.logger.trace("compression is enabled for this message")
 
     guard self.compressionMechanism.requiresFlag else {
       self.logger.error("compression flag was set but '\(self.compressionMechanism)' does not require it")