Handling of conditionally unconsumed http.IncomingMessage

Question

I want to forward an upstream http.IncomingMessage to a client via a restify server. This is what I came up till now. It provides the forwarding capability. However I assume that this could cause a memory leak:

var server = restify.createServer()

server.get('/test', function(req, res, next) {
    var upstreamReq = createUpstreamReq() // just creates a http.ClientRequest

    upstreamReq.on('response', function(upstreamRes) {
        if (upstreamRes.statusCode === 404) {
            // (1) I guess this leaks the upstreamRes body ?
            return next(new restify.errors.NotFoundError())
        }
        if (upstreamRes.statusCode !== 200) {
            // (2) is there a better way than pipeing the response to /dev/null?
            // I guess the advantage of this approach is that we can reuse the connection (not closed) ?
            upstreamRes.pipe(fs.createWriteStream('/dev/null'))
            return next(new restify.errors.InternalServerError())
        }
        res.setHeader('Content-Type', upstreamRes.header('Content-Type'))
        res.setHeader('Content-Length', upstreamRes.header('Content-Length'))
        upstreamRes.pipe(res)
        return next()
    })

    upstreamReq.end()
})

• I assume that in the case of a upstream 404 this code leaks the upstreamRes body (1) because it is never consumed (no pipe(somewhere))?
• One obvious solution (2) that shouldn't leak the upstreamRes body is to pipe it to /dev/null. Is there an alternative/better solution for this problem?

Answer 1

It seems that I skipped over an important section in the documentation about http.ClientRequest:

If no 'response' handler is added, then the response will be entirely discarded. However, if you add a 'response' event handler, then you must consume the data from the response object, either by calling response.read() whenever there is a 'readable' event, or by adding a 'data' handler, or by calling the .resume() method. Until the data is consumed, the 'end' event will not fire. Also, until the data is read it will consume memory that can eventually lead to a 'process out of memory' error.

https://nodejs.org/api/http.html#http_class_http_clientrequest

So the correct answer seems to be:

• You need to consume the response (a http.IncomingMessage) for each http.ClientRequest
• If you aren't interested in the returned data the recommended approach is to call upstreamRes.resume(). This starts the flow of data even if no consumer is attached.