From 4a01aa8ab940b31de4585b201160c37cd184cdc5 Mon Sep 17 00:00:00 2001
From: Robert Nagy <ronagy@icloud.com>
Date: Sun, 14 Jul 2019 13:20:19 +0200
Subject: [PATCH] http: bytesWritten for http/1

---
 doc/api/fs.md                                 |  6 ++--
 doc/api/http.md                               | 10 ++++++
 doc/api/http2.md                              | 10 ++++++
 doc/api/stream.md                             | 10 ++++++
 lib/_http_outgoing.js                         |  5 +++
 lib/_stream_duplex.js                         | 10 ++++++
 lib/_stream_writable.js                       | 14 +++++++++
 lib/internal/fs/streams.js                    |  3 --
 lib/internal/http2/compat.js                  |  5 +++
 .../test-http-outgoing-bytes-written.js       | 25 +++++++++++++++
 ...tp2-compat-serverresponse-bytes-written.js | 26 ++++++++++++++++
 .../test-stream-writable-bytes-written.js     | 31 +++++++++++++++++++
 12 files changed, 150 insertions(+), 5 deletions(-)
 create mode 100644 test/parallel/test-http-outgoing-bytes-written.js
 create mode 100644 test/parallel/test-http2-compat-serverresponse-bytes-written.js
 create mode 100644 test/parallel/test-stream-writable-bytes-written.js

diff --git a/doc/api/fs.md b/doc/api/fs.md
index 58b17c3b21902a..736de6476f3d53 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -892,8 +892,10 @@ Fires immediately after `'open'`.
 added: v0.4.7
 -->
 
-The number of bytes written so far. Does not include data that is still queued
-for writing.
+{integer}
+
+Integer value that indicates how many bytes has been written to
+the response body (not the amount flushed).
 
 ### writeStream.path
 <!-- YAML
diff --git a/doc/api/http.md b/doc/api/http.md
index c2ec3a7fd03770..b82d0ad5a8fde8 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -1166,6 +1166,16 @@ response.end();
 Attempting to set a header field name or value that contains invalid characters
 will result in a [`TypeError`][] being thrown.
 
+### response.bytesWritten
+<!-- YAML
+added: CHANGEME
+-->
+
+* {integer}
+
+Integer value that indicates how many bytes has been written to
+the response body (not the amount flushed).
+
 ### response.connection
 <!-- YAML
 added: v0.3.0
diff --git a/doc/api/http2.md b/doc/api/http2.md
index 4dac23b0395a3a..8a0a4b8c230eba 100644
--- a/doc/api/http2.md
+++ b/doc/api/http2.md
@@ -2977,6 +2977,16 @@ message) to the response.
 Attempting to set a header field name or value that contains invalid characters
 will result in a [`TypeError`][] being thrown.
 
+#### response.bytesWritten
+<!-- YAML
+added: CHANGEME
+-->
+
+* {integer}
+
+Integer value that indicates how many bytes has been written to
+the response body (not the amount flushed).
+
 #### response.connection
 <!-- YAML
 added: v8.4.0
diff --git a/doc/api/stream.md b/doc/api/stream.md
index d670c7bc6fe381..4b0edb343a8ff4 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -348,6 +348,16 @@ writer.on('unpipe', (src) => {
 reader.pipe(writer);
 reader.unpipe(writer);
 ```
+##### writable.bytesWritten
+<!-- YAML
+added: CHANGEME
+-->
+
+* {integer}
+
+Integer value that indicates how many bytes has been written to
+the stream (not the amount flushed). In `objectMode` this
+value represents the number of objects written.
 
 ##### writable.cork()
 <!-- YAML
diff --git a/lib/_http_outgoing.js b/lib/_http_outgoing.js
index 32a51d120bad2b..253841d8ba9c95 100644
--- a/lib/_http_outgoing.js
+++ b/lib/_http_outgoing.js
@@ -83,6 +83,8 @@ function OutgoingMessage() {
   // TCP socket and HTTP Parser and thus handle the backpressure.
   this.outputSize = 0;
 
+  this.bytesWritten = 0;
+
   this.writable = true;
 
   this._last = false;
@@ -646,9 +648,12 @@ function write_(msg, chunk, encoding, callback, fromEnd) {
     msg._send(chunk, encoding, null);
     ret = msg._send(crlf_buf, null, callback);
   } else {
+    len = chunk.length;
     ret = msg._send(chunk, encoding, callback);
   }
 
+  msg.bytesWritten += len;
+
   debug('write ret = ' + ret);
   return ret;
 }
diff --git a/lib/_stream_duplex.js b/lib/_stream_duplex.js
index b96a0439f785fa..8a648d41739c52 100644
--- a/lib/_stream_duplex.js
+++ b/lib/_stream_duplex.js
@@ -118,6 +118,16 @@ Object.defineProperty(Duplex.prototype, 'writableEnded', {
   }
 });
 
+Object.defineProperty(Duplex.prototype, 'bytesWritten', {
+  // Making it explicit this property is not enumerable
+  // because otherwise some prototype manipulation in
+  // userland will fail
+  enumerable: false,
+  get() {
+    return this._writableState ? this._writableState.written : null;
+  }
+});
+
 // The no-half-open enforcer
 function onend() {
   // If the writable side ended, then we're ok.
diff --git a/lib/_stream_writable.js b/lib/_stream_writable.js
index e212881c4ac555..fcf16cde2305d2 100644
--- a/lib/_stream_writable.js
+++ b/lib/_stream_writable.js
@@ -132,6 +132,9 @@ function WritableState(options, stream, isDuplex) {
   // The callback that the user supplies to write(chunk,encoding,cb)
   this.writecb = null;
 
+  // The amount that has been written.
+  this.written = 0;
+
   // The amount that is being written when _write is called.
   this.writelen = 0;
 
@@ -373,6 +376,16 @@ Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
   }
 });
 
+Object.defineProperty(Writable.prototype, 'bytesWritten', {
+  // Making it explicit this property is not enumerable
+  // because otherwise some prototype manipulation in
+  // userland will fail
+  enumerable: false,
+  get: function() {
+    return this._writableState.written;
+  }
+});
+
 // If we're already writing something, then just put this
 // in the queue, and wait our turn.  Otherwise, call _write
 // If we return false, then we need a drain event, so set that flag.
@@ -388,6 +401,7 @@ function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
   const len = state.objectMode ? 1 : chunk.length;
 
   state.length += len;
+  state.written += len;
 
   const ret = state.length < state.highWaterMark;
   // We must ensure that previous needDrain will not be reset to false.
diff --git a/lib/internal/fs/streams.js b/lib/internal/fs/streams.js
index 87d58a8be55f80..aaeec015232c1f 100644
--- a/lib/internal/fs/streams.js
+++ b/lib/internal/fs/streams.js
@@ -250,7 +250,6 @@ function WriteStream(path, options) {
   this.start = options.start;
   this.autoClose = options.autoClose === undefined ? true : !!options.autoClose;
   this.pos = undefined;
-  this.bytesWritten = 0;
   this.closed = false;
 
   if (this.start !== undefined) {
@@ -312,7 +311,6 @@ WriteStream.prototype._write = function(data, encoding, cb) {
       }
       return cb(er);
     }
-    this.bytesWritten += bytes;
     cb();
   });
 
@@ -345,7 +343,6 @@ WriteStream.prototype._writev = function(data, cb) {
       self.destroy();
       return cb(er);
     }
-    self.bytesWritten += bytes;
     cb();
   });
 
diff --git a/lib/internal/http2/compat.js b/lib/internal/http2/compat.js
index 9cf19250a8a3b0..a45e3c9c59cff3 100644
--- a/lib/internal/http2/compat.js
+++ b/lib/internal/http2/compat.js
@@ -454,6 +454,11 @@ class Http2ServerResponse extends Stream {
     return this.headersSent;
   }
 
+  get bytesWritten () {
+    const stream = this[kStream];
+    return stream.bytesWritten;
+  }
+
   get writableEnded() {
     const state = this[kState];
     return state.ending;
diff --git a/test/parallel/test-http-outgoing-bytes-written.js b/test/parallel/test-http-outgoing-bytes-written.js
new file mode 100644
index 00000000000000..42491a91d1eaee
--- /dev/null
+++ b/test/parallel/test-http-outgoing-bytes-written.js
@@ -0,0 +1,25 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const server = http.createServer(common.mustCall(function(req, res) {
+  res.setHeader('test-header', 'header');
+  assert.strictEqual(res.bytesWritten, 0);
+  res.write('hello');
+  assert.strictEqual(res.bytesWritten, 5);
+  res.end('world');
+  assert.strictEqual(res.bytesWritten, 10);
+  server.close();
+}));
+
+server.listen(0);
+
+server.on('listening', common.mustCall(function() {
+  const clientRequest = http.request({
+    port: server.address().port,
+    method: 'GET',
+    path: '/'
+  });
+  clientRequest.end();
+}));
diff --git a/test/parallel/test-http2-compat-serverresponse-bytes-written.js b/test/parallel/test-http2-compat-serverresponse-bytes-written.js
new file mode 100644
index 00000000000000..078b795aae56c8
--- /dev/null
+++ b/test/parallel/test-http2-compat-serverresponse-bytes-written.js
@@ -0,0 +1,26 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const h2 = require('http2');
+
+const server = h2.createServer(common.mustCall(function(req, res) {
+  res.setHeader('test-header', 'header');
+  assert.strictEqual(res.bytesWritten, 0);
+  res.write('hello');
+  assert.strictEqual(res.bytesWritten, 5);
+  res.end('world');
+  assert.strictEqual(res.bytesWritten, 10);
+  server.close();
+}));
+
+server.listen(0);
+
+server.on('listening', common.mustCall(function() {
+  const url = `http://localhost:${server.address().port}`;
+  const client = h2.connect(url, common.mustCall(() => {
+    const request = client.request();
+    request.end();
+  }));
+}));
diff --git a/test/parallel/test-stream-writable-bytes-written.js b/test/parallel/test-stream-writable-bytes-written.js
new file mode 100644
index 00000000000000..607cc0cecd9b49
--- /dev/null
+++ b/test/parallel/test-stream-writable-bytes-written.js
@@ -0,0 +1,31 @@
+'use strict';
+const common = require('../common');
+const { Writable } = require('stream');
+const assert = require('assert');
+
+{
+  const writable = new Writable({
+    write: (buf, enc, cb) => {
+      cb();
+    }
+  });
+  assert.strictEqual(writable.bytesWritten, 0);
+  writable.write('hello');
+  assert.strictEqual(writable.bytesWritten, 5);
+  writable.end('world');
+  assert.strictEqual(writable.bytesWritten, 10);
+}
+
+{
+  const writable = new Writable({
+    objectMode: true,
+    write: (buf, enc, cb) => {
+      cb();
+    }
+  });
+  assert.strictEqual(writable.bytesWritten, 0);
+  writable.write({});
+  assert.strictEqual(writable.bytesWritten, 1);
+  writable.end({});
+  assert.strictEqual(writable.bytesWritten, 2);
+}