diff --git a/doc/api/http.md b/doc/api/http.md
index 0588d7f408f194..0f095f579e341e 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -553,6 +553,15 @@ changes:
 The `request.aborted` property will be `true` if the request has
 been aborted.
 
+### request.closed
+<!-- YAML
+added: CHANGEME
+-->
+
+* {boolean}
+
+The `request.closed` property indicates whether the request has been closed.
+
 ### request.connection
 <!-- YAML
 added: v0.3.0
@@ -1130,6 +1139,15 @@ response.end();
 Attempting to set a header field name or value that contains invalid characters
 will result in a [`TypeError`][] being thrown.
 
+### response.closed
+<!-- YAML
+added: CHANGEME
+-->
+
+* {boolean}
+
+The `response.closed` property indicates whether the response has been closed.
+
 ### response.connection
 <!-- YAML
 added: v0.3.0
diff --git a/lib/_http_client.js b/lib/_http_client.js
index 4af23fa8c574f0..8ed20fe68084c8 100644
--- a/lib/_http_client.js
+++ b/lib/_http_client.js
@@ -191,6 +191,7 @@ function ClientRequest(input, options, cb) {
   this._ended = false;
   this.res = null;
   this.aborted = false;
+  this.closed = false;
   this.timeoutCb = null;
   this.upgradeOrConnect = false;
   this.parser = null;
@@ -297,6 +298,16 @@ function ClientRequest(input, options, cb) {
 Object.setPrototypeOf(ClientRequest.prototype, OutgoingMessage.prototype);
 Object.setPrototypeOf(ClientRequest, OutgoingMessage);
 
+Object.defineProperty(ClientRequest.prototype, 'complete', {
+  get() {
+    return Boolean(
+      this.finished ||
+      this.aborted ||
+      this.closed
+    );
+  }
+});
+
 ClientRequest.prototype._finish = function _finish() {
   DTRACE_HTTP_CLIENT_REQUEST(this, this.connection);
   OutgoingMessage.prototype._finish.call(this);
@@ -358,13 +369,16 @@ function socketCloseListener() {
       res.aborted = true;
       res.emit('aborted');
     }
+    req.closed = true;
     req.emit('close');
     if (res.readable) {
       res.on('end', function() {
+        this.closed = true;
         this.emit('close');
       });
       res.push(null);
     } else {
+      res.closed = true;
       res.emit('close');
     }
   } else {
@@ -375,6 +389,7 @@ function socketCloseListener() {
       req.socket._hadError = true;
       req.emit('error', connResetException('socket hang up'));
     }
+    req.closed = true;
     req.emit('close');
   }
 
@@ -487,6 +502,7 @@ function socketOnData(d) {
       socket.readableFlowing = null;
 
       req.emit(eventName, res, socket, bodyHead);
+      req.closed = true;
       req.emit('close');
     } else {
       // Requested Upgrade or used CONNECT method, but have no handler.
diff --git a/lib/_http_incoming.js b/lib/_http_incoming.js
index 3ec23616b15b02..4fc71ad0c55ca8 100644
--- a/lib/_http_incoming.js
+++ b/lib/_http_incoming.js
@@ -56,6 +56,7 @@ function IncomingMessage(socket) {
   this.readable = true;
 
   this.aborted = false;
+  this.closed = false;
 
   this.upgrade = null;
 
@@ -76,6 +77,16 @@ function IncomingMessage(socket) {
 Object.setPrototypeOf(IncomingMessage.prototype, Stream.Readable.prototype);
 Object.setPrototypeOf(IncomingMessage, Stream.Readable);
 
+Object.defineProperty(IncomingMessage.prototype, 'complete', {
+  get() {
+    return Boolean(
+      this.finished ||
+      this.aborted ||
+      this.closed
+    );
+  }
+});
+
 IncomingMessage.prototype.setTimeout = function setTimeout(msecs, callback) {
   if (callback)
     this.on('timeout', callback);
diff --git a/lib/_http_outgoing.js b/lib/_http_outgoing.js
index a4a2b3ab144400..03d16f9419cd56 100644
--- a/lib/_http_outgoing.js
+++ b/lib/_http_outgoing.js
@@ -96,6 +96,7 @@ function OutgoingMessage() {
   this._trailer = '';
 
   this.finished = false;
+  this.closed = false;
   this._headerSent = false;
   this[kIsCorked] = false;
 
@@ -109,6 +110,14 @@ function OutgoingMessage() {
 Object.setPrototypeOf(OutgoingMessage.prototype, Stream.prototype);
 Object.setPrototypeOf(OutgoingMessage, Stream);
 
+Object.defineProperty(OutgoingMessage.prototype, 'complete', {
+  get() {
+    return Boolean(
+      this.finished ||
+      this.closed
+    );
+  }
+});
 
 Object.defineProperty(OutgoingMessage.prototype, '_headers', {
   get: internalUtil.deprecate(function() {
diff --git a/lib/_http_server.js b/lib/_http_server.js
index f82685e2be4bcd..161460ced182ae 100644
--- a/lib/_http_server.js
+++ b/lib/_http_server.js
@@ -178,7 +178,10 @@ function onServerResponseClose() {
   // Ergo, we need to deal with stale 'close' events and handle the case
   // where the ServerResponse object has already been deconstructed.
   // Fortunately, that requires only a single if check. :-)
-  if (this._httpMessage) this._httpMessage.emit('close');
+  if (this._httpMessage) {
+    this._httpMessage.closed = true;
+    this._httpMessage.emit('close');
+  }
 }
 
 ServerResponse.prototype.assignSocket = function assignSocket(socket) {
@@ -468,6 +471,7 @@ function abortIncoming(incoming) {
   while (incoming.length) {
     var req = incoming.shift();
     req.aborted = true;
+    req.closed = true;
     req.emit('aborted');
     req.emit('close');
   }
@@ -609,6 +613,7 @@ function resOnFinish(req, res, socket, state, server) {
     req._dump();
 
   res.detachSocket(socket);
+  req.closed = true;
   req.emit('close');
   process.nextTick(emitCloseNT, res);
 
@@ -633,6 +638,7 @@ function resOnFinish(req, res, socket, state, server) {
 }
 
 function emitCloseNT(self) {
+  self.closed = true;
   self.emit('close');
 }
 
diff --git a/lib/internal/http2/compat.js b/lib/internal/http2/compat.js
index 516954587108a8..7ffaa64fe58e12 100644
--- a/lib/internal/http2/compat.js
+++ b/lib/internal/http2/compat.js
@@ -297,12 +297,17 @@ class Http2ServerRequest extends Readable {
     this.on('resume', onRequestResume);
   }
 
+  get closed() {
+    return this[kState].closed;
+  }
+
   get aborted() {
     return this[kAborted];
   }
 
   get complete() {
-    return this._readableState.ended ||
+    return this[kAborted] ||
+           this._readableState.ended ||
            this[kState].closed ||
            this[kStream].destroyed;
   }
@@ -446,6 +451,16 @@ class Http2ServerResponse extends Stream {
     stream.on('timeout', onStreamTimeout(kResponse));
   }
 
+  get closed() {
+    return this[kState].closed;
+  }
+
+  get complete() {
+    return this._writableState.ended ||
+           this[kState].closed ||
+           this[kStream].destroyed;
+  }
+
   // User land modules such as finalhandler just check truthiness of this
   // but if someone is actually trying to use this for more than that
   // then we simply can't support such use cases
diff --git a/test/parallel/test-http-client-close-event.js b/test/parallel/test-http-client-close-event.js
index 7573931ac48ef6..f533587c375396 100644
--- a/test/parallel/test-http-client-close-event.js
+++ b/test/parallel/test-http-client-close-event.js
@@ -23,6 +23,7 @@ server.listen(0, common.mustCall(() => {
 
   req.on('close', common.mustCall(() => {
     assert.strictEqual(errorEmitted, true);
+    assert.strictEqual(req.closed, true);
     server.close();
   }));
 
diff --git a/test/parallel/test-http-connect-req-res.js b/test/parallel/test-http-connect-req-res.js
index 893c621852be89..d92a5aea09012e 100644
--- a/test/parallel/test-http-connect-req-res.js
+++ b/test/parallel/test-http-connect-req-res.js
@@ -33,7 +33,9 @@ server.listen(0, common.mustCall(function() {
     path: 'example.com:443'
   }, common.mustNotCall());
 
-  req.on('close', common.mustCall());
+  req.on('close', common.mustCall(() => {
+    assert.strictEqual(req.closed, true);
+  }));
 
   req.on('connect', common.mustCall(function(res, socket, firstBodyChunk) {
     console.error('Client got CONNECT request');
diff --git a/test/parallel/test-http-req-res-close.js b/test/parallel/test-http-req-res-close.js
index daba55f43427c2..8f203dc2499ecf 100644
--- a/test/parallel/test-http-req-res-close.js
+++ b/test/parallel/test-http-req-res-close.js
@@ -5,16 +5,13 @@ const http = require('http');
 const assert = require('assert');
 
 const server = http.Server(common.mustCall((req, res) => {
-  let resClosed = false;
-
   res.end();
-  res.on('finish', common.mustCall(() => {
-    assert.strictEqual(resClosed, false);
-  }));
+  res.on('finish', common.mustCall());
   res.on('close', common.mustCall(() => {
-    resClosed = true;
+    assert.strictEqual(res.closed, true);
   }));
   req.on('close', common.mustCall(() => {
+    assert.strictEqual(req.closed, true);
     assert.strictEqual(req._readableState.ended, true);
   }));
   res.socket.on('close', () => server.close());
diff --git a/test/parallel/test-http-response-close.js b/test/parallel/test-http-response-close.js
index 4c36003357980b..f9db64cf52a5ac 100644
--- a/test/parallel/test-http-response-close.js
+++ b/test/parallel/test-http-response-close.js
@@ -22,6 +22,7 @@
 'use strict';
 const common = require('../common');
 const http = require('http');
+const assert = require('assert');
 
 {
   const server = http.createServer(
@@ -40,6 +41,7 @@ const http = require('http');
             res.destroy();
           }));
           res.on('close', common.mustCall(() => {
+            assert.strictEqual(res.closed, true);
             server.close();
           }));
         })