koa-classic-server 1.2.0 → 2.0.0

package/benchmark-results-optimized-v2.0.0.txt

@@ -0,0 +1,354 @@
+
+> koa-classic-server@1.2.0 test:performance
+> jest __tests__/performance.test.js --runInBand
+
+  console.log
+    
+    📊 Small File (1KB) Benchmark:
+
+      at Object.log (__tests__/performance.test.js:90:21)
+
+  console.log
+       Average: 2.93ms
+
+      at Object.log (__tests__/performance.test.js:91:21)
+
+  console.log
+       Median:  2.48ms
+
+      at Object.log (__tests__/performance.test.js:92:21)
+
+  console.log
+       Min:     1.90ms
+
+      at Object.log (__tests__/performance.test.js:93:21)
+
+  console.log
+       Max:     25.14ms
+
+      at Object.log (__tests__/performance.test.js:94:21)
+
+  console.log
+    
+    📊 Medium File (100KB) Benchmark:
+
+      at Object.log (__tests__/performance.test.js:109:21)
+
+  console.log
+       Average: 3.13ms
+
+      at Object.log (__tests__/performance.test.js:110:21)
+
+  console.log
+       Median:  3.15ms
+
+      at Object.log (__tests__/performance.test.js:111:21)
+
+  console.log
+       Min:     2.31ms
+
+      at Object.log (__tests__/performance.test.js:112:21)
+
+  console.log
+       Max:     4.11ms
+
+      at Object.log (__tests__/performance.test.js:113:21)
+
+  console.log
+    
+    📊 Large File (1MB) Benchmark:
+
+      at Object.log (__tests__/performance.test.js:128:21)
+
+  console.log
+       Average: 8.76ms
+
+      at Object.log (__tests__/performance.test.js:129:21)
+
+  console.log
+       Median:  9.85ms
+
+      at Object.log (__tests__/performance.test.js:130:21)
+
+  console.log
+       Min:     5.79ms
+
+      at Object.log (__tests__/performance.test.js:131:21)
+
+  console.log
+       Max:     11.72ms
+
+      at Object.log (__tests__/performance.test.js:132:21)
+
+  console.log
+    
+    📊 Small Directory (100 files) Benchmark:
+
+      at Object.log (__tests__/performance.test.js:150:21)
+
+  console.log
+       Average: 2.68ms
+
+      at Object.log (__tests__/performance.test.js:151:21)
+
+  console.log
+       Median:  2.53ms
+
+      at Object.log (__tests__/performance.test.js:152:21)
+
+  console.log
+       Min:     2.22ms
+
+      at Object.log (__tests__/performance.test.js:153:21)
+
+  console.log
+       Max:     4.79ms
+
+      at Object.log (__tests__/performance.test.js:154:21)
+
+  console.log
+    
+    📊 Large Directory (1,000 files) Benchmark:
+
+      at Object.log (__tests__/performance.test.js:168:21)
+
+  console.log
+       Average: 9.49ms
+
+      at Object.log (__tests__/performance.test.js:169:21)
+
+  console.log
+       Median:  9.16ms
+
+      at Object.log (__tests__/performance.test.js:170:21)
+
+  console.log
+       Min:     8.20ms
+
+      at Object.log (__tests__/performance.test.js:171:21)
+
+  console.log
+       Max:     11.49ms
+
+      at Object.log (__tests__/performance.test.js:172:21)
+
+  console.log
+       ⚠️  WARNING: This will be MUCH faster after async optimization
+
+      at Object.log (__tests__/performance.test.js:175:21)
+
+  console.log
+    
+    📊 Very Large Directory (10,000 files) Benchmark:
+
+      at Object.log (__tests__/performance.test.js:189:21)
+
+  console.log
+       Average: 90.06ms
+
+      at Object.log (__tests__/performance.test.js:190:21)
+
+  console.log
+       Median:  90.14ms
+
+      at Object.log (__tests__/performance.test.js:191:21)
+
+  console.log
+       Min:     87.00ms
+
+      at Object.log (__tests__/performance.test.js:192:21)
+
+  console.log
+       Max:     93.29ms
+
+      at Object.log (__tests__/performance.test.js:193:21)
+
+  console.log
+       ⚠️  WARNING: Event loop BLOCKED during this operation!
+
+      at Object.log (__tests__/performance.test.js:194:21)
+
+  console.log
+       ⚠️  Expected to drop to ~27.02ms after optimization
+
+      at Object.log (__tests__/performance.test.js:195:21)
+
+  console.log
+    
+    📊 10 Concurrent Small Files:
+
+      at Object.log (__tests__/performance.test.js:212:21)
+
+  console.log
+       Total time: 14.35ms
+
+      at Object.log (__tests__/performance.test.js:213:21)
+
+  console.log
+       Avg per request: 1.43ms
+
+      at Object.log (__tests__/performance.test.js:214:21)
+
+  console.log
+    
+    📊 5 Concurrent Directory Listings (100 files):
+
+      at Object.log (__tests__/performance.test.js:231:21)
+
+  console.log
+       Total time: 7.26ms
+
+      at Object.log (__tests__/performance.test.js:232:21)
+
+  console.log
+       Avg per request: 1.45ms
+
+      at Object.log (__tests__/performance.test.js:233:21)
+
+  console.log
+       ⚠️  With current sync code, these run SEQUENTIALLY
+
+      at Object.log (__tests__/performance.test.js:234:21)
+
+  console.log
+       ⚠️  After async optimization, will run in PARALLEL
+
+      at Object.log (__tests__/performance.test.js:235:21)
+
+  console.log
+    
+    📊 404 Not Found Benchmark:
+
+      at Object.log (__tests__/performance.test.js:252:21)
+
+  console.log
+       Average: 1.53ms
+
+      at Object.log (__tests__/performance.test.js:253:21)
+
+  console.log
+       Median:  1.43ms
+
+      at Object.log (__tests__/performance.test.js:254:21)
+
+  console.log
+       Min:     1.24ms
+
+      at Object.log (__tests__/performance.test.js:255:21)
+
+  console.log
+       Max:     3.80ms
+
+      at Object.log (__tests__/performance.test.js:256:21)
+
+  console.log
+    
+    📊 Memory Usage (10,000 files directory):
+
+      at Object.log (__tests__/performance.test.js:278:21)
+
+  console.log
+       Heap used increase: 0.96 MB
+
+      at Object.log (__tests__/performance.test.js:279:21)
+
+  console.log
+       External increase: 2.54 MB
+
+      at Object.log (__tests__/performance.test.js:280:21)
+
+  console.log
+       Response size: 1.29 MB
+
+      at Object.log (__tests__/performance.test.js:281:21)
+
+  console.log
+       ⚠️  Expected to reduce by ~30-40% after optimization
+
+      at Object.log (__tests__/performance.test.js:282:21)
+
+  console.log
+    
+    ======================================================================
+
+      at Object.log (__tests__/performance.test.js:289:13)
+
+  console.log
+    📋 BASELINE BENCHMARK SUMMARY
+
+      at Object.log (__tests__/performance.test.js:290:13)
+
+  console.log
+    ======================================================================
+
+      at Object.log (__tests__/performance.test.js:291:13)
+
+  console.log
+    
+    These results represent the CURRENT performance (v1.2.0)
+
+      at Object.log (__tests__/performance.test.js:292:13)
+
+  console.log
+    After implementing optimizations, run this test again to see improvements.
+
+      at Object.log (__tests__/performance.test.js:293:13)
+
+  console.log
+    Expected improvements after optimization:
+
+      at Object.log (__tests__/performance.test.js:294:13)
+
+  console.log
+      ✓ Small files:        10-20% faster (async operations)
+
+      at Object.log (__tests__/performance.test.js:295:13)
+
+  console.log
+      ✓ Large directories:  50-70% faster (async + array join)
+
+      at Object.log (__tests__/performance.test.js:296:13)
+
+  console.log
+      ✓ Concurrent requests: 5-10x faster (non-blocking event loop)
+
+      at Object.log (__tests__/performance.test.js:297:13)
+
+  console.log
+      ✓ Memory usage:       30-40% reduction (array join vs concatenation)
+
+      at Object.log (__tests__/performance.test.js:298:13)
+
+  console.log
+      ✓ With HTTP caching:  80-95% faster (304 responses)
+
+      at Object.log (__tests__/performance.test.js:299:13)
+
+  console.log
+    ======================================================================
+
+      at Object.log (__tests__/performance.test.js:300:13)
+
+PASS __tests__/performance.test.js
+  Performance Benchmarks - BASELINE (v1.2.0)
+    File Serving Performance
+      ✓ Benchmark: Small file (1KB) - 100 iterations (322 ms)
+      ✓ Benchmark: Medium file (100KB) - 50 iterations (160 ms)
+      ✓ Benchmark: Large file (1MB) - 20 iterations (178 ms)
+    Directory Listing Performance
+      ✓ Benchmark: Small directory (100 files) - 50 iterations (136 ms)
+      ✓ Benchmark: Large directory (1,000 files) - 20 iterations (192 ms)
+      ✓ Benchmark: Very large directory (10,000 files) - 5 iterations (454 ms)
+    Concurrent Request Performance
+      ✓ Benchmark: 10 concurrent small file requests (17 ms)
+      ✓ Benchmark: 5 concurrent directory listings (100 files each) (9 ms)
+    404 Not Found Performance
+      ✓ Benchmark: Non-existent file - 50 iterations (79 ms)
+    Memory Usage (Informational)
+      ✓ Memory usage during large directory listing (90 ms)
+
+Test Suites: 1 passed, 1 total
+Tests:       10 passed, 10 total
+Snapshots:   0 total
+Time:        2.781 s, estimated 4 s
+Ran all test suites matching /__tests__\/performance.test.js/i.

package/benchmark.js

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+
+/**
+ * HTTP Load Testing Benchmark using autocannon
+ *
+ * This script performs realistic load testing to measure:
+ * - Requests per second
+ * - Latency (avg, p50, p99)
+ * - Throughput
+ *
+ * Usage:
+ *   node benchmark.js
+ *   node benchmark.js --save baseline.json
+ *
+ * Compare before/after:
+ *   node benchmark.js --save before.json
+ *   # ... apply optimizations ...
+ *   node benchmark.js --save after.json --compare before.json
+ */
+
+const autocannon = require('autocannon');
+const Koa = require('koa');
+const koaClassicServer = require('./index.cjs');
+const path = require('path');
+const fs = require('fs');
+
+const BENCHMARK_DIR = path.join(__dirname, 'benchmark-data');
+
+// Check if benchmark data exists
+if (!fs.existsSync(BENCHMARK_DIR)) {
+    console.error('\n❌ Benchmark data not found!');
+    console.error('Please run: node scripts/setup-benchmark.js\n');
+    process.exit(1);
+}
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const saveFile = args.includes('--save') ? args[args.indexOf('--save') + 1] : null;
+const compareFile = args.includes('--compare') ? args[args.indexOf('--compare') + 1] : null;
+
+console.log('🚀 Starting koa-classic-server benchmark...\n');
+
+// Start server
+const app = new Koa();
+app.use(koaClassicServer(BENCHMARK_DIR));
+const server = app.listen(0); // Random available port
+
+const port = server.address().port;
+console.log(`Server running on http://localhost:${port}\n`);
+
+// Define benchmark scenarios
+const scenarios = [
+    {
+        name: 'Small file (1KB)',
+        url: `http://localhost:${port}/small-files/file-1.txt`,
+        duration: 10,
+        connections: 10
+    },
+    {
+        name: 'Medium file (100KB)',
+        url: `http://localhost:${port}/medium-files/file-1.txt`,
+        duration: 10,
+        connections: 10
+    },
+    {
+        name: 'Large file (1MB)',
+        url: `http://localhost:${port}/large-files/file-1.txt`,
+        duration: 10,
+        connections: 10
+    },
+    {
+        name: 'Directory listing (100 files)',
+        url: `http://localhost:${port}/small-files/`,
+        duration: 10,
+        connections: 10
+    },
+    {
+        name: 'Directory listing (1,000 files)',
+        url: `http://localhost:${port}/large-directory/`,
+        duration: 10,
+        connections: 5
+    },
+    {
+        name: 'HTML file',
+        url: `http://localhost:${port}/test.html`,
+        duration: 10,
+        connections: 10
+    },
+    {
+        name: '404 Not Found',
+        url: `http://localhost:${port}/does-not-exist.txt`,
+        duration: 10,
+        connections: 10
+    }
+];
+
+// Run benchmarks sequentially
+async function runBenchmarks() {
+    const results = {};
+
+    for (const scenario of scenarios) {
+        console.log('─'.repeat(70));
+        console.log(`📊 Benchmarking: ${scenario.name}`);
+        console.log('─'.repeat(70));
+
+        const result = await runBenchmark(scenario);
+        results[scenario.name] = result;
+
+        // Wait a bit between tests
+        await sleep(2000);
+    }
+
+    return results;
+}
+
+function runBenchmark(scenario) {
+    return new Promise((resolve, reject) => {
+        const instance = autocannon({
+            url: scenario.url,
+            connections: scenario.connections,
+            duration: scenario.duration,
+            pipelining: 1,
+        }, (err, result) => {
+            if (err) {
+                reject(err);
+            } else {
+                printResults(result, scenario.name);
+                resolve(formatResults(result, scenario.name));
+            }
+        });
+
+        autocannon.track(instance, { renderProgressBar: true });
+    });
+}
+
+function printResults(result, name) {
+    console.log(`\n✓ ${name} - Results:`);
+    console.log(`  Requests/sec:  ${result.requests.average.toFixed(2)}`);
+    console.log(`  Latency (avg): ${result.latency.mean.toFixed(2)}ms`);
+    console.log(`  Latency (p50): ${result.latency.p50.toFixed(2)}ms`);
+    console.log(`  Latency (p99): ${result.latency.p99.toFixed(2)}ms`);
+    console.log(`  Throughput:    ${(result.throughput.average / 1024 / 1024).toFixed(2)} MB/sec`);
+    console.log(`  Total requests: ${result.requests.total}`);
+    console.log('');
+}
+
+function formatResults(result, name) {
+    return {
+        name,
+        requestsPerSecond: result.requests.average,
+        latency: {
+            mean: result.latency.mean,
+            p50: result.latency.p50,
+            p75: result.latency.p75,
+            p90: result.latency.p90,
+            p99: result.latency.p99,
+            p999: result.latency.p999
+        },
+        throughput: result.throughput.average,
+        totalRequests: result.requests.total,
+        errors: result.errors
+    };
+}
+
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// Main execution
+runBenchmarks()
+    .then(results => {
+        console.log('='.repeat(70));
+        console.log('📋 BENCHMARK SUMMARY');
+        console.log('='.repeat(70));
+        console.log('');
+
+        // Summary table
+        console.log('Scenario                          | Req/sec | Latency (avg) | Throughput');
+        console.log('----------------------------------|---------|---------------|-------------');
+
+        Object.values(results).forEach(result => {
+            const name = result.name.padEnd(33);
+            const reqSec = result.requestsPerSecond.toFixed(0).padStart(7);
+            const latency = `${result.latency.mean.toFixed(2)}ms`.padStart(13);
+            const throughput = `${(result.throughput / 1024 / 1024).toFixed(2)} MB/s`.padStart(11);
+            console.log(`${name} | ${reqSec} | ${latency} | ${throughput}`);
+        });
+
+        console.log('');
+        console.log('='.repeat(70));
+
+        // Save results if requested
+        if (saveFile) {
+            const data = {
+                timestamp: new Date().toISOString(),
+                version: require('./package.json').version,
+                results
+            };
+            fs.writeFileSync(saveFile, JSON.stringify(data, null, 2));
+            console.log(`\n✓ Results saved to: ${saveFile}`);
+        }
+
+        // Compare with previous results if requested
+        if (compareFile && fs.existsSync(compareFile)) {
+            const previous = JSON.parse(fs.readFileSync(compareFile, 'utf8'));
+            console.log('\n📊 COMPARISON WITH PREVIOUS RESULTS');
+            console.log('='.repeat(70));
+
+            Object.keys(results).forEach(key => {
+                const current = results[key];
+                const prev = previous.results[key];
+
+                if (prev) {
+                    const reqDiff = ((current.requestsPerSecond - prev.requestsPerSecond) / prev.requestsPerSecond * 100);
+                    const latDiff = ((current.latency.mean - prev.latency.mean) / prev.latency.mean * 100);
+
+                    console.log(`\n${key}:`);
+                    console.log(`  Requests/sec: ${prev.requestsPerSecond.toFixed(2)} → ${current.requestsPerSecond.toFixed(2)} (${reqDiff > 0 ? '+' : ''}${reqDiff.toFixed(1)}%)`);
+                    console.log(`  Latency:      ${prev.latency.mean.toFixed(2)}ms → ${current.latency.mean.toFixed(2)}ms (${latDiff > 0 ? '+' : ''}${latDiff.toFixed(1)}%)`);
+
+                    if (reqDiff > 10) {
+                        console.log(`  ✅ Significant improvement!`);
+                    } else if (reqDiff < -10) {
+                        console.log(`  ⚠️  Performance regression!`);
+                    }
+                }
+            });
+
+            console.log('\n' + '='.repeat(70));
+        }
+
+        server.close();
+        console.log('\n✓ Benchmark complete!\n');
+    })
+    .catch(err => {
+        console.error('❌ Benchmark failed:', err);
+        server.close();
+        process.exit(1);
+    });