http: add bytesWritten property

doc/api/http.md

@@ -1420,6 +1420,15 @@ 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: REPLACEME
+-->
+
+* {integer}
+
+Number of bytes written to response body.
+
 ### `response.connection`
 <!-- YAML
 added: v0.3.0

doc/api/http2.md

@@ -3271,6 +3271,15 @@ 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: REPLACEME
+-->
+
+* {integer}
+
+Number of bytes written to response body.
+
 #### `response.connection`
 <!-- YAML
 added: v8.4.0

lib/_http_outgoing.js

@@ -80,6 +80,7 @@ const HIGH_WATER_MARK = getDefaultHighWaterMark();
 const { CRLF, debug } = common;
 
 const kCorked = Symbol('corked');
+const kBytesWritten = Symbol('bytesWritten');
 
 const nop = FunctionPrototype;
 
@@ -132,6 +133,7 @@ function OutgoingMessage() {
   this.socket = null;
   this._header = null;
   this[kOutHeaders] = null;
+  this[kBytesWritten] = 0;
 
   this._keepAliveTimeout = 0;
 
@@ -140,6 +142,16 @@ function OutgoingMessage() {
 ObjectSetPrototypeOf(OutgoingMessage.prototype, Stream.prototype);
 ObjectSetPrototypeOf(OutgoingMessage, Stream);
 
+ObjectDefineProperty(OutgoingMessage.prototype, 'bytesWritten', {
+  get() {
+    return this[kBytesWritten];
+  },
+  set(value) {
+    // Compat
+    this[kBytesWritten] = value;
+  }
+});
+
 ObjectDefineProperty(OutgoingMessage.prototype, 'writableFinished', {
   get() {
     return (
@@ -683,7 +695,12 @@ OutgoingMessage.prototype.write = function write(chunk, encoding, callback) {
     encoding = null;
   }
 
-  const ret = write_(this, chunk, encoding, callback, false);
+  const buf = typeof chunk === 'string' ? Buffer.from(chunk, encoding) : chunk;
+
+  const ret = write_(this, buf, null, callback, false);
+
+  this[kBytesWritten] += buf.length;
+
   if (!ret)
     this[kNeedDrain] = true;
   return ret;

lib/internal/http2/compat.js

@@ -494,6 +494,10 @@ class Http2ServerResponse extends Stream {
     return this.headersSent;
   }
 
+  get bytesWritten() {
+    return this.stream.bytesWritten;
+  }
+
   get writableEnded() {
     const state = this[kState];
     return state.ending;

lib/internal/http2/core.js

@@ -130,6 +130,7 @@ const { onServerStream,
         Http2ServerRequest,
         Http2ServerResponse,
 } = require('internal/http2/compat');
+const { Buffer } = require('buffer');
 
 const {
   assertIsObject,
@@ -1906,7 +1907,8 @@ class Http2Stream extends Duplex {
       rstCode: NGHTTP2_NO_ERROR,
       writeQueueSize: 0,
       trailersReady: false,
-      endAfterHeaders: false
+      endAfterHeaders: false,
+      bytesWritten: 0,
     };
 
     // Fields used by the compat API to avoid megamorphisms.
@@ -1960,6 +1962,15 @@ class Http2Stream extends Duplex {
     return `Http2Stream ${format(obj)}`;
   }
 
+  get bytesWritten() {
+    return this[kState].bytesWritten;
+  }
+
+  set bytesWritten(value) {
+    // Compat
+    this[kState].bytesWritten = value;
+  }
+
   get bufferSize() {
     // `bufferSize` properties of `net.Socket` are `undefined` when
     // their `_handle` are falsy. Here we avoid the behavior.
@@ -2115,6 +2126,13 @@ class Http2Stream extends Duplex {
     trackWriteState(this, req.bytes);
   }
 
+  write(data, encoding, cb) {
+    const buf = typeof data === 'string' ? Buffer.from(data, encoding) : data;
+    const ret = super.write(data, null, cb);
+    this[kState].bytesWritten += buf.length;
+    return ret;
+  }
+
   _write(data, encoding, cb) {
     this[kWriteGeneric](false, data, encoding, cb);
   }

test/parallel/test-http-byteswritten.js

@@ -37,15 +37,21 @@ const httpServer = http.createServer(common.mustCall(function(req, res) {
 
   // Write 1.5mb to cause some requests to buffer
   // Also, mix up the encodings a bit.
+  let bytesWritten = 0;
   const chunk = '7'.repeat(1024);
   const bchunk = Buffer.from(chunk);
   for (let i = 0; i < 1024; i++) {
     res.write(chunk);
+    bytesWritten += chunk.length;
     res.write(bchunk);
+    bytesWritten += bchunk.length;
     res.write(chunk, 'hex');
+    bytesWritten += Buffer.byteLength(chunk, 'hex');
+
   }
   // Get .bytesWritten while buffer is not empty
   assert(res.connection.bytesWritten > 0);
+  assert.strictEqual(res.bytesWritten, bytesWritten);
 
   res.end(body);
 }));

test/parallel/test-http2-buffersize.js

@@ -40,9 +40,11 @@ const { once } = require('events');
     for (let j = 0; j < kSockets; j += 1) {
       const stream = client.request({ ':method': 'POST' });
       stream.on('data', () => {});
-
+      let bytesWritten = 0;
       for (let i = 0; i < kTimes; i += 1) {
         stream.write(Buffer.allocUnsafe(kBufferSize), mustSucceed());
+        bytesWritten += kBufferSize;
+        assert.strictEqual(stream.bytesWritten, bytesWritten);
         const expectedSocketBufferSize = kBufferSize * (i + 1);
         assert.strictEqual(stream.bufferSize, expectedSocketBufferSize);
       }

test/parallel/test-http2-compat-serverresponse-write.js

@@ -27,6 +27,7 @@ const assert = require('assert');
     server.once('request', mustCall((request, response) => {
       // response.write() returns true
       assert(response.write('muahaha', 'utf8', mustCall()));
+      assert.strictEqual(response.bytesWritten, Buffer.byteLength('muahaha'));
 
       response.stream.close(0, mustCall(() => {
         response.on('error', mustNotCall());