How do you implement a custom load testing tool in Node.js?

Question

Accepted Answer

**Load testing** — simulate high traffic to test performance.

```javascript
const http = require("http");

class LoadTester {
    constructor(url, options = {}) {
        this.url = url;
        this.concurrency = options.concurrency || 10;
        this.totalRequests = options.totalRequests || 100;
        this.results = [];
    }

async run() {
        const startTime = Date.now();
        const queue = Array.from({ length: this.totalRequests }, (_, i) => i);
        const executing = new Set();

while (queue.length > 0 || executing.size > 0) {
            while (executing.size < this.concurrency && queue.length > 0) {
                const task = queue.shift();
                const promise = this.makeRequest(task)
                    .then(result => {
                        this.results.push(result);
                        executing.delete(promise);
                    });
                executing.add(promise);
            }
            await Promise.race(executing);
        }

return this.getReport(Date.now() - startTime);
    }

makeRequest(id) {
        return new Promise((resolve) => {
            const start = Date.now();
            http.get(this.url, (res) => {
                let data = "";
                res.on("data", chunk => data += chunk);
                res.on("end", () => {
                    resolve({
                        id,
                        status: res.statusCode,
                        duration: Date.now() - start,
                    });
                });
            }).on("error", () => {
                resolve({ id, status: 0, duration: Date.now() - start });
            });
        });
    }

getReport(totalDuration) {
        const successful = this.results.filter(r => r.status === 200);
        const durations = this.results.map(r => r.duration);
        durations.sort((a, b) => a - b);

return {
            totalRequests: this.results.length,
            successful: successful.length,
            failed: this.results.length - successful.length,
            totalDuration,
            avgDuration: durations.reduce((a, b) => a + b, 0) / durations.length,
            p95Duration: durations[Math.floor(durations.length * 0.95)],
            p99Duration: durations[Math.floor(durations.length * 0.99)],
            rps: this.results.length / (totalDuration / 1000),
        };
    }
}

const tester = new LoadTester("http://localhost:3000/api", {
    concurrency: 50,
    totalRequests: 1000,
});

const report = await tester.run();
console.log(report);
```

Node.js: How do you implement a custom load testing tool in Node.js?