fix: cleaned up logging

* Related #14

[ci skip]

Author: tegefaulkes

src/QUICStream.ts

@@ -54,9 +54,6 @@ class QUICStream
   // This resolves when `streamRecv` results in a `StreamReset(u64)` or a fin flag indicating receiving has ended
   protected recvFinishedProm = utils.promise<void>();
 
-  protected sentBytes: number = 0;
-  protected recvBytes: number = 0;
-
   /**
    * For `reasonToCode`, return 0 means "unknown reason"
    * It is the catch-all for codes.
@@ -131,13 +128,6 @@ class QUICStream
     this.reasonToCode = reasonToCode;
     this.codeToReason = codeToReason;
 
-    this.sendFinishedProm.p.finally(() =>
-      logger.info('sendFinishedProm resolved'),
-    );
-    this.recvFinishedProm.p.finally(() =>
-      logger.info('recvFinishedProm resolved'),
-    );
-
     this.readable = new ReadableStream(
       {
         type: 'bytes',
@@ -146,7 +136,6 @@ class QUICStream
           this.readableController = controller;
         },
         pull: async () => {
-          this.logger.info('doing pull');
           this._recvPaused = false;
         },
         cancel: async (reason) => {
@@ -173,7 +162,7 @@ class QUICStream
           // with the `fin` set to true
           // If this itself results in an error, we can continue
           // But continue to do the below
-          this.logger.info('sending fin frame');
+          this.logger.debug('sending fin frame');
           // This.sendFinishedProm.resolveP();
           await this.streamSend(Buffer.from([0]), true).catch((e) => {
             // Ignore send error if stream is already closed
@@ -350,15 +339,13 @@ class QUICStream
           void this.closeSend(true, err).catch(() => {});
         }
       });
-      this.logger.debug('send FINISHED');
       return true;
     }
   }
 
   protected async streamRecv(): Promise<void> {
     const buf = Buffer.alloc(1024);
     let recvLength: number, fin: boolean;
-    this.logger.debug('trying receiving');
     while (true) {
       try {
         [recvLength, fin] = this.conn.streamRecv(this.streamId, buf);
@@ -374,7 +361,7 @@ class QUICStream
           // This should never be reported... (this branch should be dead code)
           return;
         } else {
-          this.logger.info(`Stream recv reported: error ${e.message}`);
+          this.logger.debug(`Stream recv reported: error ${e.message}`);
           // Signal receiving has ended
           this.recvFinishedProm.resolveP();
           if (!this._recvClosed) {
@@ -394,27 +381,20 @@ class QUICStream
           return;
         }
       }
-      this.recvBytes += recvLength;
-      this.logger.info(`recv bytes ${this.recvBytes}`);
-      this.logger.info(`fin? ${fin}`);
       // If fin is true, then that means, the stream is CLOSED
       if (!fin) {
         // Send the data normally
         if (!this._recvClosed) {
           this.readableController.enqueue(buf.subarray(0, recvLength));
         }
       } else {
-        this.logger.info('finishing');
         // Strip the end message, removing the null byte
         if (!this._recvClosed && recvLength > 1) {
-          this.logger.info('finish contained message');
           this.readableController.enqueue(buf.subarray(0, recvLength - 1));
         }
         // This will render `stream.cancel` a noop
-        this.logger.info('closing');
         if (!this._recvClosed) this.readableController.close();
         await this.closeRecv();
-        this.logger.info('closed');
         // Signal receiving has ended
         this.recvFinishedProm.resolveP();
         return;
@@ -472,8 +452,6 @@ class QUICStream
         }
       }
     }
-    if (sentLength > 0) this.sentBytes += sentLength;
-    this.logger.info(`sent bytes ${this.sentBytes}`);
     if (sentLength < chunk.length) {
       const { p: writableP, resolveP: resolveWritableP } = utils.promise();
       this.resolveWritableP = resolveWritableP;
@@ -495,10 +473,10 @@ class QUICStream
     isError: boolean = false,
     reason?: any,
   ): Promise<void> {
-    if (isError) this.logger.info(`recv closed with error ${reason.message}`);
+    if (isError) this.logger.debug(`recv closed with error ${reason.message}`);
     // Further closes are NOPs
     if (this._recvClosed) return;
-    this.logger.info(`Close Recv`);
+    this.logger.debug(`Close Recv`);
     // Indicate that the receiving side is closed
     this._recvClosed = true;
     const code = isError ? await this.reasonToCode('send', reason) : 0;
@@ -530,10 +508,10 @@ class QUICStream
     isError: boolean = false,
     reason?: any,
   ): Promise<void> {
-    if (isError) this.logger.info(`send closed with error ${reason.message}`);
+    if (isError) this.logger.debug(`send closed with error ${reason.message}`);
     // Further closes are NOPs
     if (this._sendClosed) return;
-    this.logger.info(`Close Send`);
+    this.logger.debug(`Close Send`);
     // Indicate that the sending side is closed
     this._sendClosed = true;
     // If the QUIC stream is already closed
@@ -580,39 +558,6 @@ class QUICStream
     }
     return null;
   }
-
-  static checkStreamStates(
-    conn: Connection,
-    streamId: number,
-    message: string,
-    logger: Logger,
-  ) {
-    const fin = conn.streamFinished(streamId);
-    const read = conn.streamReadable(streamId);
-    let write: boolean | string;
-    try {
-      write = conn.streamWritable(streamId, 0);
-    } catch (e) {
-      write = e.message;
-    }
-    let cap: number | string;
-    try {
-      cap = conn.streamCapacity(streamId);
-    } catch (e) {
-      cap = e.message;
-    }
-    let readIter = false;
-    for (const id of conn.readable()) {
-      if (streamId === id) readIter = true;
-    }
-    let writeIter = false;
-    for (const id of conn.writable()) {
-      if (streamId === id) writeIter = true;
-    }
-    logger.info(
-      `Stream states (${message}) iterRW(${readIter}, ${writeIter}),finished(${fin}), read(${read}), write(${write}), capacity(${cap})`,
-    );
-  }
 }
 
 export default QUICStream;