express-api-stress-tester 1.0.0

package/README.md

@@ -0,0 +1,250 @@
+# express-api-stress-tester
+
+High-performance API stress testing and load testing tool for Node.js.  
+Simulate up to **100,000 concurrent users** sending requests to your APIs.
+
+---
+
+## Features
+
+- **High concurrency** – powered by [undici](https://github.com/nodejs/undici) and `worker_threads`
+- **Dynamic payloads** – auto-generate names, emails, UUIDs, and more
+- **Bulk payload mode** – send different bodies across requests
+- **Detailed reports** – requests/sec, response times, error rates, CPU & memory
+- **CLI & programmatic API** – use from the terminal or inside your Node.js app
+- **Streaming architecture** – minimal memory footprint at scale
+
+---
+
+## Installation
+
+```bash
+npm install express-api-stress-tester
+```
+
+Or run directly with `npx`:
+
+```bash
+npx express-api-stress-tester config.json
+```
+
+---
+
+## CLI Usage
+
+Create a `config.json` file:
+
+```json
+{
+  "url": "https://api.example.com/users",
+  "method": "POST",
+  "concurrency": 5000,
+  "duration": 30,
+  "headers": {
+    "Content-Type": "application/json",
+    "Authorization": "Bearer YOUR_TOKEN"
+  },
+  "payload": {
+    "username": "{name}",
+    "email": "{email}"
+  }
+}
+```
+
+Run the test:
+
+```bash
+npx express-api-stress-tester config.json
+```
+
+The tool will print a summary to stdout and append it to `stress-test-report.txt`.
+
+---
+
+## Programmatic Usage
+
+```js
+import { stressTest } from "express-api-stress-tester";
+
+const summary = await stressTest({
+  url: "https://api.example.com/users",
+  method: "POST",
+  concurrency: 5000,
+  duration: 30,
+  headers: {
+    "Content-Type": "application/json",
+  },
+  payload: {
+    name: "{name}",
+    email: "{email}",
+  },
+});
+
+console.log(summary);
+// {
+//   totalRequests: 252000,
+//   requestsPerSec: 8400,
+//   avgResponseTime: 120,
+//   errorRate: 1.2,
+//   successRate: 98.8,
+//   cpuPercent: '45.0',
+//   memoryMB: '320.0',
+//   result: 'PASSED'
+// }
+```
+
+---
+
+## Configuration Options
+
+| Option        | Type     | Required | Default | Description                             |
+| ------------- | -------- | -------- | ------- | --------------------------------------- |
+| `url`         | string   | yes      | –       | Target API URL                          |
+| `method`      | string   | no       | `GET`   | HTTP method (GET, POST, PUT, PATCH, DELETE) |
+| `headers`     | object   | no       | `{}`    | Request headers                         |
+| `payload`     | object   | no       | –       | Single payload template (supports dynamic placeholders) |
+| `payloads`    | array    | no       | –       | Bulk payloads – array of payload objects distributed round-robin |
+| `concurrency` | number   | no       | `1`     | Number of concurrent users (up to 100k) |
+| `duration`    | number   | no       | `10`    | Test duration in seconds                |
+
+---
+
+## Dynamic Payload Placeholders
+
+Use placeholders in your payload values. They are replaced with fresh random data for every request.
+
+| Placeholder    | Example Output               |
+| -------------- | ---------------------------- |
+| `{name}`       | `Alice Johnson`              |
+| `{botName}`    | `AlphaBot`                   |
+| `{email}`      | `alice4231@example.com`      |
+| `{uuid}`       | `550e8400-e29b-41d4-a716-...`|
+| `{number}`     | `483291`                     |
+| `{timestamp}`  | `1710547200000`              |
+
+**Example:**
+
+```json
+{
+  "payload": {
+    "name": "{name}",
+    "botName": "{botName}",
+    "email": "{email}",
+    "uuid": "{uuid}",
+    "age": "{number}",
+    "createdAt": "{timestamp}"
+  }
+}
+```
+
+Placeholders also work inside larger strings:
+
+```json
+{ "greeting": "Hello {name}, your ID is {uuid}" }
+```
+
+---
+
+## Bulk Payload Mode
+
+Send multiple different payloads. They are distributed across requests in round-robin order.
+
+```json
+{
+  "url": "https://api.example.com/users",
+  "method": "POST",
+  "concurrency": 100,
+  "duration": 10,
+  "headers": { "Content-Type": "application/json" },
+  "payloads": [
+    { "name": "Alice" },
+    { "name": "Bob" },
+    { "name": "Charlie" }
+  ]
+}
+```
+
+---
+
+## Report Output
+
+After each test, a report is appended to `stress-test-report.txt`:
+
+```
+==================================================
+  API Stress Test Report
+==================================================
+API URL:            https://api.example.com/users
+Method:             POST
+Concurrent Users:   5000
+Duration (s):       30.0
+Total Requests:     252000
+Requests/sec:       8400
+Avg Response Time:  120ms
+Error Rate:         1.2%
+Success Rate:       98.8%
+CPU Usage:          45.0%
+Memory Usage:       320.0MB
+Result:             PASSED
+==================================================
+```
+
+**Result rules:**
+- `PASSED` → error rate < 5%
+- `FAILED` → error rate ≥ 5%
+
+---
+
+## Project Structure
+
+```
+api-stress-tester/
+├── src/
+│   ├── index.js             # Public API exports
+│   ├── runner.js            # Main orchestrator (spawns workers, collects metrics)
+│   ├── worker.js            # Worker thread – executes HTTP requests via undici
+│   ├── payloadParser.js     # Payload template resolver (single & bulk)
+│   ├── dynamicGenerators.js # Random data generators for placeholders
+│   ├── metrics.js           # MetricsCollector – aggregates counters
+│   ├── logger.js            # Streaming logger & report writer
+│   └── cli.js               # CLI entry point
+├── tests/
+│   ├── payload.test.js      # Payload & generator tests
+│   └── stress.test.js       # Metrics, report, and runner tests
+├── package.json
+├── example-config.json
+└── README.md
+```
+
+---
+
+## Running Tests
+
+```bash
+npm test
+```
+
+---
+
+## Performance Notes
+
+- Uses **undici** for HTTP – significantly faster than `axios` or `node-fetch`
+- **Worker threads** distribute load across CPU cores
+- Controlled **batch dispatching** prevents event loop starvation
+- Metrics use **aggregate counters** (not per-request arrays) to minimise memory
+- Report writing uses **appendFileSync** – no large in-memory buffers
+
+---
+
+## How to Publish
+
+```bash
+npm login --auth-type=web
+npm publish
+```
+
+---
+
+## License
+
+MIT

package/example-config.json

@@ -0,0 +1,14 @@
+{
+  "url": "https://jsonplaceholder.typicode.com/posts",
+  "method": "POST",
+  "concurrency": 10,
+  "duration": 5,
+  "headers": {
+    "Content-Type": "application/json"
+  },
+  "payload": {
+    "title": "{name}",
+    "body": "Stress test payload {uuid}",
+    "userId": "{number}"
+  }
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "express-api-stress-tester",
+  "version": "1.0.0",
+  "description": "High-performance API stress testing and load testing tool capable of simulating up to 100k concurrent users",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "bin": {
+    "express-api-stress-tester": "src/cli.js"
+  },
+  "scripts": {
+    "test": "node --experimental-vm-modules node_modules/.bin/jest --forceExit",
+    "stress": "node src/cli.js"
+  },
+  "keywords": [
+    "api",
+    "stress-test",
+    "load-test",
+    "performance",
+    "benchmark",
+    "http",
+    "concurrent",
+    "undici"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "undici": "^6.24.1",
+    "uuid": "^11.1.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@jest/test-sequencer": "^29.7.0",
+    "jest": "^29.7.0"
+  },
+  "jest": {
+    "transform": {},
+    "testEnvironment": "node",
+    "extensionsToTreatAsEsm": [],
+    "testMatch": [
+      "**/tests/**/*.test.js"
+    ]
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src/",
+    "README.md",
+    "example-config.json"
+  ]
+}

package/src/cli.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+/**
+ * CLI entry point for api-stress-tester.
+ *
+ * Usage:
+ *   npx express-api-stress-tester config.json
+ *   node src/cli.js config.json
+ */
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { runStressTest } from './runner.js';
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+    console.log(`
+  express-api-stress-tester – High-performance API stress testing tool
+
+  Usage:
+    express-api-stress-tester <config.json>
+
+  Options:
+    --help, -h    Show this help message
+
+  Example config.json:
+    {
+      "url": "https://api.example.com/users",
+      "method": "POST",
+      "concurrency": 5000,
+      "duration": 30,
+      "headers": { "Content-Type": "application/json" },
+      "payload": { "name": "{name}", "email": "{email}" }
+    }
+    `);
+    process.exit(0);
+  }
+
+  const configPath = resolve(args[0]);
+
+  let config;
+  try {
+    const raw = readFileSync(configPath, 'utf-8');
+    config = JSON.parse(raw);
+  } catch (err) {
+    console.error(`Error reading config file: ${err.message}`);
+    process.exit(1);
+  }
+
+  try {
+    const summary = await runStressTest(config);
+    process.exit(summary.result === 'PASSED' ? 0 : 1);
+  } catch (err) {
+    console.error(`Stress test failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/src/dynamicGenerators.js

@@ -0,0 +1,76 @@
+import { randomUUID } from 'node:crypto';
+
+// Pre-computed pools for fast random selection
+const FIRST_NAMES = [
+  'Alice', 'Bob', 'Charlie', 'Diana', 'Eve', 'Frank', 'Grace', 'Hank',
+  'Ivy', 'Jack', 'Karen', 'Leo', 'Mona', 'Nick', 'Olivia', 'Paul',
+  'Quinn', 'Rita', 'Sam', 'Tina', 'Uma', 'Vince', 'Wendy', 'Xander',
+  'Yara', 'Zane', 'Aria', 'Ben', 'Cleo', 'Derek'
+];
+
+const LAST_NAMES = [
+  'Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Garcia', 'Miller',
+  'Davis', 'Rodriguez', 'Martinez', 'Hernandez', 'Lopez', 'Gonzalez',
+  'Wilson', 'Anderson', 'Thomas', 'Taylor', 'Moore', 'Jackson', 'Martin'
+];
+
+const BOT_PREFIXES = [
+  'Alpha', 'Beta', 'Gamma', 'Delta', 'Sigma', 'Omega', 'Nova', 'Turbo',
+  'Hyper', 'Ultra', 'Mega', 'Giga', 'Nano', 'Cyber', 'Robo', 'Auto'
+];
+
+const BOT_SUFFIXES = [
+  'Bot', 'Agent', 'Helper', 'Runner', 'Worker', 'Pilot', 'Guard', 'Scout'
+];
+
+const EMAIL_DOMAINS = [
+  'example.com', 'test.io', 'mail.org', 'demo.net', 'sample.dev'
+];
+
+/**
+ * Pick a random element from an array.
+ * Uses Math.random for speed (no need for crypto-grade randomness here).
+ */
+const pick = (arr) => arr[Math.floor(Math.random() * arr.length)];
+
+/**
+ * Map of placeholder tokens to generator functions.
+ * Each generator returns a fresh random value on every call.
+ */
+export const generators = {
+  '{name}': () => `${pick(FIRST_NAMES)} ${pick(LAST_NAMES)}`,
+  '{botName}': () => `${pick(BOT_PREFIXES)}${pick(BOT_SUFFIXES)}`,
+  '{email}': () => {
+    const user = `${pick(FIRST_NAMES).toLowerCase()}${Math.floor(Math.random() * 10000)}`;
+    return `${user}@${pick(EMAIL_DOMAINS)}`;
+  },
+  '{uuid}': () => randomUUID(),
+  '{number}': () => Math.floor(Math.random() * 1_000_000),
+  '{timestamp}': () => Date.now(),
+};
+
+/**
+ * Resolve a single placeholder string.
+ * Returns the generator output if the entire value is a known token,
+ * otherwise replaces all occurrences within the string.
+ */
+export function resolveValue(value) {
+  if (typeof value !== 'string') return value;
+
+  // Fast path: value is exactly a token
+  if (generators[value] !== undefined) {
+    return generators[value]();
+  }
+
+  // Slow path: replace all embedded tokens
+  let result = value;
+  for (const [token, gen] of Object.entries(generators)) {
+    if (result.includes(token)) {
+      // Replace all occurrences – each gets a unique value
+      while (result.includes(token)) {
+        result = result.replace(token, String(gen()));
+      }
+    }
+  }
+  return result;
+}

package/src/index.js

@@ -0,0 +1,11 @@
+/**
+ * express-api-stress-tester – public API
+ *
+ * Usage:
+ *   import { stressTest } from 'express-api-stress-tester';
+ *   const result = await stressTest({ url: '...', concurrency: 5000, duration: 30 });
+ */
+export { runStressTest as stressTest } from './runner.js';
+export { parsePayload, getPayload } from './payloadParser.js';
+export { generators, resolveValue } from './dynamicGenerators.js';
+export { MetricsCollector } from './metrics.js';

package/src/logger.js

@@ -0,0 +1,51 @@
+import { appendFileSync } from 'node:fs';
+
+const REPORT_FILE = 'stress-test-report.txt';
+
+/**
+ * Write a structured log line to stdout.
+ */
+export function log(message) {
+  const ts = new Date().toISOString();
+  process.stdout.write(`[${ts}] ${message}\n`);
+}
+
+/**
+ * Write the final report to the report file and also to stdout.
+ */
+export function writeReport(config, summary, reportPath) {
+  const filePath = reportPath || REPORT_FILE;
+  const divider = '='.repeat(50);
+  const lines = [
+    divider,
+    `  API Stress Test Report`,
+    divider,
+    `API URL:            ${config.url}`,
+    `Method:             ${(config.method || 'GET').toUpperCase()}`,
+    `Concurrent Users:   ${config.concurrency || 1}`,
+    `Duration (s):       ${summary.elapsedSeconds}`,
+    `Total Requests:     ${summary.totalRequests}`,
+    `Requests/sec:       ${summary.requestsPerSec}`,
+    `Avg Response Time:  ${summary.avgResponseTime}ms`,
+    `Error Rate:         ${summary.errorRate}%`,
+    `Success Rate:       ${summary.successRate}%`,
+    `CPU Usage:          ${summary.cpuPercent}%`,
+    `Memory Usage:       ${summary.memoryMB}MB`,
+    `Result:             ${summary.result}`,
+    divider,
+    '',
+  ];
+  const report = lines.join('\n');
+
+  // Append to file
+  try {
+    appendFileSync(filePath, report + '\n');
+  } catch (err) {
+    process.stderr.write(`Failed to write report: ${err.message}\n`);
+  }
+
+  // Also print to stdout
+  process.stdout.write(report + '\n');
+
+  return report;
+}

package/src/metrics.js

@@ -0,0 +1,94 @@
+import { cpus } from 'node:os';
+
+/**
+ * Lightweight metrics collector.
+ * Stores only aggregate counters to avoid memory bloat at high concurrency.
+ */
+export class MetricsCollector {
+  constructor() {
+    this.totalRequests = 0;
+    this.successCount = 0;
+    this.errorCount = 0;
+    this.totalResponseTime = 0; // sum of ms
+    this.startTime = 0;
+    this.endTime = 0;
+  }
+
+  start() {
+    this.startTime = Date.now();
+  }
+
+  stop() {
+    this.endTime = Date.now();
+  }
+
+  /** Record one completed request */
+  record(responseTimeMs, isError) {
+    this.totalRequests++;
+    this.totalResponseTime += responseTimeMs;
+    if (isError) {
+      this.errorCount++;
+    } else {
+      this.successCount++;
+    }
+  }
+
+  /** Merge counters from a worker thread's partial result */
+  merge(partial) {
+    this.totalRequests += partial.totalRequests || 0;
+    this.successCount += partial.successCount || 0;
+    this.errorCount += partial.errorCount || 0;
+    this.totalResponseTime += partial.totalResponseTime || 0;
+  }
+
+  /** Capture current CPU & memory usage */
+  static getResourceUsage() {
+    const mem = process.memoryUsage();
+    // CPU usage averaged across cores (percentage over a brief sample)
+    const cpuArray = cpus();
+    let totalIdle = 0;
+    let totalTick = 0;
+    for (const cpu of cpuArray) {
+      const { user, nice, sys, idle, irq } = cpu.times;
+      totalTick += user + nice + sys + idle + irq;
+      totalIdle += idle;
+    }
+    const cpuPercent = ((1 - totalIdle / totalTick) * 100).toFixed(1);
+    const memoryMB = (mem.heapUsed / 1024 / 1024).toFixed(1);
+    return { cpuPercent, memoryMB };
+  }
+
+  /** Build the final summary object */
+  getSummary() {
+    const elapsed = (this.endTime - this.startTime) / 1000 || 1;
+    const rps = (this.totalRequests / elapsed).toFixed(0);
+    const avgResponse =
+      this.totalRequests > 0
+        ? (this.totalResponseTime / this.totalRequests).toFixed(0)
+        : 0;
+    const errorRate =
+      this.totalRequests > 0
+        ? ((this.errorCount / this.totalRequests) * 100).toFixed(1)
+        : '0.0';
+    const successRate =
+      this.totalRequests > 0
+        ? ((this.successCount / this.totalRequests) * 100).toFixed(1)
+        : '0.0';
+
+    const { cpuPercent, memoryMB } = MetricsCollector.getResourceUsage();
+
+    const passed = parseFloat(errorRate) < 5;
+
+    return {
+      totalRequests: this.totalRequests,
+      requestsPerSec: Number(rps),
+      avgResponseTime: Number(avgResponse),
+      errorRate: parseFloat(errorRate),
+      successRate: parseFloat(successRate),
+      cpuPercent,
+      memoryMB,
+      result: passed ? 'PASSED' : 'FAILED',
+      elapsedSeconds: elapsed.toFixed(1),
+    };
+  }
+}

package/src/payloadParser.js

@@ -0,0 +1,42 @@
+import { resolveValue } from './dynamicGenerators.js';
+
+/**
+ * Deep-clone a plain object/array and resolve every dynamic placeholder.
+ * Works recursively so nested payloads are supported.
+ */
+export function parsePayload(template) {
+  if (template === null || template === undefined) return template;
+
+  if (Array.isArray(template)) {
+    return template.map(parsePayload);
+  }
+
+  if (typeof template === 'object') {
+    const result = {};
+    for (const [key, value] of Object.entries(template)) {
+      result[key] = parsePayload(value);
+    }
+    return result;
+  }
+
+  return resolveValue(template);
+}
+
+/**
+ * Given a config, return a resolved payload for a single request.
+ * Supports both single payload and bulk payloads (round-robin).
+ */
+export function getPayload(config, requestIndex) {
+  // Bulk mode: config.payloads is an array of payload objects
+  if (Array.isArray(config.payloads) && config.payloads.length > 0) {
+    const template = config.payloads[requestIndex % config.payloads.length];
+    return parsePayload(template);
+  }
+
+  // Single payload mode
+  if (config.payload) {
+    return parsePayload(config.payload);
+  }
+
+  return undefined;
+}

package/src/runner.js

@@ -0,0 +1,116 @@
+import { Worker } from 'node:worker_threads';
+import { cpus } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { MetricsCollector } from './metrics.js';
+import { log, writeReport } from './logger.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const WORKER_PATH = join(__dirname, 'worker.js');
+
+// Max workers = number of CPU cores (minus 1 for main thread, min 1)
+const DEFAULT_NUM_WORKERS = Math.max(1, cpus().length - 1);
+// Max tasks dispatched per batch per worker to avoid overloading event loop
+const BATCH_SIZE = 200;
+
+/**
+ * Main test runner.
+ *
+ * Spawns worker threads and distributes request tasks across them
+ * for the configured duration. Collects metrics and writes a report.
+ *
+ * @param {object} config - stress test configuration
+ * @param {object} [options] - optional overrides
+ * @param {string} [options.reportPath] - custom report file path
+ * @returns {Promise<object>} summary metrics
+ */
+export async function runStressTest(config, options = {}) {
+  // ── Validate ──────────────────────────────────────────────────────
+  if (!config || !config.url) {
+    throw new Error('config.url is required');
+  }
+  const concurrency = config.concurrency || 1;
+  const duration = config.duration || 10; // seconds
+
+  log(`Starting stress test → ${config.url}`);
+  log(`Concurrency: ${concurrency} | Duration: ${duration}s`);
+
+  // ── Decide worker count ───────────────────────────────────────────
+  const numWorkers = Math.min(DEFAULT_NUM_WORKERS, concurrency);
+  const metrics = new MetricsCollector();
+
+  // ── Spawn workers ─────────────────────────────────────────────────
+  const workers = [];
+  for (let i = 0; i < numWorkers; i++) {
+    const w = new Worker(WORKER_PATH, { workerData: config });
+    workers.push(w);
+  }
+
+  // Listen for partial metrics from workers
+  for (const w of workers) {
+    w.on('message', (msg) => {
+      if (msg.type === 'result') {
+        metrics.merge(msg.metrics);
+      }
+    });
+    w.on('error', (err) => {
+      log(`Worker error: ${err.message}`);
+    });
+  }
+
+  // ── Dispatch loop ─────────────────────────────────────────────────
+  // We send batches of task indices to workers in round-robin fashion
+  // until the duration expires.
+  metrics.start();
+  const endAt = Date.now() + duration * 1000;
+  let taskIndex = 0;
+
+  while (Date.now() < endAt) {
+    const batchPromises = [];
+
+    for (const w of workers) {
+      const tasks = [];
+      const batchLimit = Math.min(
+        BATCH_SIZE,
+        Math.ceil(concurrency / numWorkers)
+      );
+      for (let j = 0; j < batchLimit; j++) {
+        tasks.push(taskIndex++);
+      }
+      // Wrap in a promise that resolves when the worker replies
+      const p = new Promise((resolve) => {
+        const handler = (msg) => {
+          if (msg.type === 'result') {
+            w.removeListener('message', handler);
+            resolve();
+          }
+        };
+        w.on('message', handler);
+        w.postMessage({ type: 'batch', tasks });
+      });
+      batchPromises.push(p);
+    }
+
+    // Wait for all workers to finish this round before dispatching next
+    await Promise.all(batchPromises);
+  }
+
+  metrics.stop();
+
+  // ── Teardown workers ──────────────────────────────────────────────
+  const termPromises = workers.map(
+    (w) =>
+      new Promise((resolve) => {
+        w.on('exit', resolve);
+        w.postMessage({ type: 'stop' });
+      })
+  );
+  await Promise.all(termPromises);
+
+  // ── Report ────────────────────────────────────────────────────────
+  const summary = metrics.getSummary();
+  writeReport(config, summary, options.reportPath);
+
+  return summary;
+}

package/src/worker.js

@@ -0,0 +1,86 @@
+/**
+ * Worker thread entry point.
+ *
+ * Receives task batches from the main thread and executes HTTP requests
+ * using undici's high-performance Pool.
+ *
+ * Communication is via parentPort messages:
+ *   main → worker : { type: 'batch', tasks: [...] }
+ *   main → worker : { type: 'stop' }
+ *   worker → main : { type: 'result', metrics: {...} }
+ */
+import { parentPort, workerData } from 'node:worker_threads';
+import { request } from 'undici';
+import { getPayload } from './payloadParser.js';
+
+const config = workerData;
+
+// Aggregate counters for this worker
+let totalRequests = 0;
+let successCount = 0;
+let errorCount = 0;
+let totalResponseTime = 0;
+
+/**
+ * Execute a single HTTP request and record timing.
+ */
+async function executeRequest(taskIndex) {
+  const startMs = Date.now();
+  let isError = false;
+
+  try {
+    const body = getPayload(config, taskIndex);
+    const options = {
+      method: (config.method || 'GET').toUpperCase(),
+      headers: config.headers || {},
+    };
+    if (body !== undefined && options.method !== 'GET') {
+      options.body = JSON.stringify(body);
+    }
+
+    const res = await request(config.url, options);
+
+    // Consume the body to free resources (undici requires this)
+    // eslint-disable-next-line no-unused-vars
+    const data = await res.body.text();
+
+    if (res.statusCode >= 400) {
+      isError = true;
+    }
+  } catch {
+    isError = true;
+  }
+
+  const elapsed = Date.now() - startMs;
+  totalRequests++;
+  totalResponseTime += elapsed;
+  if (isError) {
+    errorCount++;
+  } else {
+    successCount++;
+  }
+}
+
+parentPort.on('message', async (msg) => {
+  if (msg.type === 'batch') {
+    // Run all tasks in the batch concurrently
+    const promises = msg.tasks.map((taskIndex) => executeRequest(taskIndex));
+    await Promise.all(promises);
+
+    // Report partial metrics back to main thread
+    parentPort.postMessage({
+      type: 'result',
+      metrics: { totalRequests, successCount, errorCount, totalResponseTime },
+    });
+
+    // Reset for next batch
+    totalRequests = 0;
+    successCount = 0;
+    errorCount = 0;
+    totalResponseTime = 0;
+  }
+
+  if (msg.type === 'stop') {
+    process.exit(0);
+  }
+});