A testcase that demonstrates callback function leaks from request.js library

request-agent-pool-leak-test.js

var request = require('./index');
const http = require('http');
const Promise = require('bluebird');
const v8 = require('v8');
const memwatch = require('memwatch-next');
const _ = require('lodash');

var triggerResponseSend;
const readyToRespond = new Promise( (resolve) => {
    triggerResponseSend = resolve;
});
                                

const responses = [];

function sendResponse(response) {
    response.statusCode = 200;
    response.setHeader('Content-Type', 'text/plain');
    response.end('Hello World\n');
}

const server = http.createServer((req, res) => {
    readyToRespond.then( () => {
        sendResponse(res);
    });
});

function LeakingClass() {
}

LeakingClass.prototype.doSomething = function () {
};

var request = request.defaults({
	agentOptions: {
        keepAlive: true
    }
});

function makeRequestWithLeak() {
    var leak = new LeakingClass();

    return new Promise( (resolve) => {
        request.get('http://127.0.0.1:3000', (error, res, body) => {
            leak.doSomething();
            resolve();
        });
    });
}

function writeLeakDiff(diff) {
    const leaks = _.filter(diff.change.details, {what: 'LeakingClass'});
    console.log('leak changes', leaks);
}

const port = 3000;
server.listen(port, () => {
    console.log(`Server running at http://${server.hostname}:${port}/`);

    var before = new memwatch.HeapDiff();

    var allRequestsDone = [];
    for (var i=0;i<10;i++) {
        allRequestsDone.push(makeRequestWithLeak());
    }


    var beforeDiff = before.end();
    writeLeakDiff(beforeDiff);
    var after = new memwatch.HeapDiff();
    triggerResponseSend();

    Promise.all(allRequestsDone)
        .then( () => {
            setImmediate( () => {
                var afterDiff = after.end();
                writeLeakDiff(afterDiff);
                process.exit();
            });
        });
    
});