+3

bun.lock

reviewed

··· 8 8 "@sentry/bun": "^9.10.1", 9 9 "@types/pg": "^8.11.13", 10 10 "bottleneck": "^2.19.5", 11 11 + "chalk": "^5.4.1", 11 12 "colors": "^1.4.0", 12 13 "cron": "^4.3.0", 13 14 "drizzle-orm": "^0.42.0", ··· 212 213 "buffer-from": ["buffer-from@1.1.2", "", {}, "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ=="], 213 214 214 215 "bun-types": ["bun-types@1.2.10", "", { "dependencies": { "@types/node": "*" } }, "sha512-b5ITZMnVdf3m1gMvJHG+gIfeJHiQPJak0f7925Hxu6ZN5VKA8AGy4GZ4lM+Xkn6jtWxg5S3ldWvfmXdvnkp3GQ=="], 216 216 + 217 217 + "chalk": ["chalk@5.4.1", "", {}, "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w=="], 215 218 216 219 "cjs-module-lexer": ["cjs-module-lexer@1.4.3", "", {}, "sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q=="], 217 220

+3 -1

package.json

reviewed

··· 12 12 "db:generate": "drizzle-kit generate", 13 13 "db:migrate": "drizzle-kit migrate", 14 14 "db:studio": "drizzle-kit studio --port 3001", 15 15 - "db:push": "drizzle-kit push" 15 15 + "db:push": "drizzle-kit push", 16 16 + "stress": "bun run stress.ts" 16 17 }, 17 18 "devDependencies": { 18 19 "@types/bun": "latest", ··· 26 27 "@sentry/bun": "^9.10.1", 27 28 "@types/pg": "^8.11.13", 28 29 "bottleneck": "^2.19.5", 30 30 + "chalk": "^5.4.1", 29 31 "colors": "^1.4.0", 30 32 "cron": "^4.3.0", 31 33 "drizzle-orm": "^0.42.0",

+822

stress.ts

reviewed

··· 1 1 + import { Chalk } from "chalk"; 2 2 + import { randomUUIDv7 } from "bun"; 3 3 + 4 4 + // Create a console logger with fancy colors 5 5 + const chalk = new Chalk({ level: 3 }); 6 6 + const endpoints = [ 7 7 + "/api/stories", 8 8 + "/api/stats/total-stories", 9 9 + "/api/stats/verified-users", 10 10 + ]; 11 11 + 12 12 + // Script configuration 13 13 + const CONFIG = { 14 14 + baseUrl: "http://localhost:3000", 15 15 + startConcurrency: 100, // Start with higher concurrency 16 16 + maxConcurrency: 200000, // Increased max to test limits more aggressively 17 17 + concurrencyFactor: 3, // More aggressive scaling (3x per step) 18 18 + requestsPerUser: 20, // More requests per user 19 19 + delayBetweenRequests: 0, // No delay between requests for maximum load 20 20 + delayBetweenLevels: 1000, // Shorter delay between levels 21 21 + runWithCaching: false, // Disabled caching for more aggressive testing 22 22 + successThreshold: 95, // % success rate to continue 23 23 + responseTimeThreshold: 500, // ms 24 24 + stopOnFailure: true, // Stop when hitting breaking point 25 25 + disableDetailedLogging: true, // Disable per-request logging to reduce overhead 26 26 + }; 27 27 + 28 28 + // Stats tracking 29 29 + type EndpointStats = { 30 30 + totalRequests: number; 31 31 + successfulRequests: number; 32 32 + notModifiedResponses: number; 33 33 + failedRequests: number; 34 34 + responseTimeTotal: number; 35 35 + responseTimeMin: number; 36 36 + responseTimeMax: number; 37 37 + }; 38 38 + 39 39 + // Add memory usage tracking 40 40 + type ConcurrencyStats = { 41 41 + concurrency: number; 42 42 + totalRequests: number; 43 43 + successfulRequests: number; 44 44 + notModifiedResponses: number; 45 45 + failedRequests: number; 46 46 + responseTimeTotal: number; 47 47 + responseTimeMin: number; 48 48 + responseTimeMax: number; 49 49 + startTime: number; 50 50 + endTime: number; 51 51 + userCompletedCount: number; 52 52 + requestsPerSecond: number; 53 53 + successRate: number; 54 54 + endpoints: Record<string, EndpointStats>; 55 55 + memoryUsage?: { 56 56 + rss: number; 57 57 + heapTotal: number; 58 58 + heapUsed: number; 59 59 + external: number; 60 60 + }; 61 61 + }; 62 62 + 63 63 + const concurrencyResults: ConcurrencyStats[] = []; 64 64 + let breakingPoint: ConcurrencyStats | null = null; 65 65 + 66 66 + // Current level stats 67 67 + const stats = { 68 68 + concurrency: 0, 69 69 + totalRequests: 0, 70 70 + successfulRequests: 0, 71 71 + notModifiedResponses: 0, 72 72 + failedRequests: 0, 73 73 + responseTimeTotal: 0, 74 74 + responseTimeMin: Number.MAX_VALUE, 75 75 + responseTimeMax: 0, 76 76 + startTime: 0, 77 77 + endTime: 0, 78 78 + userCompletedCount: 0, 79 79 + requestsPerSecond: 0, 80 80 + successRate: 0, 81 81 + endpoints: {} as Record<string, EndpointStats>, 82 82 + }; 83 83 + 84 84 + // Initialize stats for each endpoint 85 85 + for (const endpoint of endpoints) { 86 86 + stats.endpoints[endpoint] = { 87 87 + totalRequests: 0, 88 88 + successfulRequests: 0, 89 89 + notModifiedResponses: 0, 90 90 + failedRequests: 0, 91 91 + responseTimeTotal: 0, 92 92 + responseTimeMin: Number.MAX_VALUE, 93 93 + responseTimeMax: 0, 94 94 + }; 95 95 + } 96 96 + // ETag cache 97 97 + const etagCache: Record<string, string> = {}; 98 98 + 99 99 + // Spinner for loading animation 100 100 + class Spinner { 101 101 + private frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]; 102 102 + private interval: NodeJS.Timeout | null = null; 103 103 + private currentFrame = 0; 104 104 + private text: string; 105 105 + 106 106 + constructor(text: string) { 107 107 + this.text = text; 108 108 + } 109 109 + 110 110 + start() { 111 111 + this.interval = setInterval(() => { 112 112 + process.stdout.write( 113 113 + `\r${chalk.cyan(this.frames[this.currentFrame])} ${this.text}`, 114 114 + ); 115 115 + this.currentFrame = (this.currentFrame + 1) % this.frames.length; 116 116 + }, 80); 117 117 + } 118 118 + 119 119 + stop() { 120 120 + if (this.interval) { 121 121 + clearInterval(this.interval); 122 122 + this.interval = null; 123 123 + process.stdout.write( 124 124 + "\r \r", 125 125 + ); 126 126 + } 127 127 + } 128 128 + 129 129 + setText(text: string) { 130 130 + this.text = text; 131 131 + } 132 132 + } 133 133 + 134 134 + // Helper to log with timestamp 135 135 + function logWithTime( 136 136 + message: string, 137 137 + type: "info" | "success" | "error" | "warn" = "info", 138 138 + ) { 139 139 + const timestamp = new Date().toISOString().split("T")[1]?.slice(0, -1) || ""; 140 140 + const prefix = { 141 141 + info: chalk.blue(`[${timestamp}] ℹ️ `), 142 142 + success: chalk.green(`[${timestamp}] ✅ `), 143 143 + error: chalk.red(`[${timestamp}] ❌ `), 144 144 + warn: chalk.yellow(`[${timestamp}] ⚠️ `), 145 145 + }[type]; 146 146 + 147 147 + console.log(`${prefix}${message}`); 148 148 + } 149 149 + 150 150 + // Make a HTTP request with timing 151 151 + async function makeRequest( 152 152 + endpoint: string, 153 153 + userId: string, 154 154 + requestId: number, 155 155 + ): Promise<void> { 156 156 + const url = `${CONFIG.baseUrl}${endpoint}`; 157 157 + const headers: Record<string, string> = { 158 158 + "User-Agent": `stress-test-user-${userId}/request-${requestId}`, 159 159 + }; 160 160 + 161 161 + // Add ETag if available and caching is enabled 162 162 + const cacheKey = `${userId}-${endpoint}`; 163 163 + if (CONFIG.runWithCaching && etagCache[cacheKey]) { 164 164 + headers["If-None-Match"] = etagCache[cacheKey]; 165 165 + } 166 166 + 167 167 + try { 168 168 + const startTime = performance.now(); 169 169 + const response = await fetch(url, { headers }); 170 170 + const endTime = performance.now(); 171 171 + const responseTime = endTime - startTime; 172 172 + 173 173 + // Track overall stats 174 174 + stats.totalRequests++; 175 175 + 176 176 + // Ensure the endpoint exists in stats.endpoints 177 177 + if (!stats.endpoints[endpoint]) { 178 178 + stats.endpoints[endpoint] = { 179 179 + totalRequests: 0, 180 180 + successfulRequests: 0, 181 181 + notModifiedResponses: 0, 182 182 + failedRequests: 0, 183 183 + responseTimeTotal: 0, 184 184 + responseTimeMin: Number.MAX_VALUE, 185 185 + responseTimeMax: 0, 186 186 + }; 187 187 + } 188 188 + 189 189 + stats.endpoints[endpoint].totalRequests++; 190 190 + stats.responseTimeTotal += responseTime; 191 191 + stats.responseTimeMin = Math.min(stats.responseTimeMin, responseTime); 192 192 + stats.responseTimeMax = Math.max(stats.responseTimeMax, responseTime); 193 193 + 194 194 + // Track endpoint-specific stats 195 195 + stats.endpoints[endpoint].responseTimeTotal += responseTime; 196 196 + stats.endpoints[endpoint].responseTimeMin = Math.min( 197 197 + stats.endpoints[endpoint].responseTimeMin, 198 198 + responseTime, 199 199 + ); 200 200 + stats.endpoints[endpoint].responseTimeMax = Math.max( 201 201 + stats.endpoints[endpoint].responseTimeMax, 202 202 + responseTime, 203 203 + ); 204 204 + 205 205 + if (response.status === 304) { 206 206 + stats.notModifiedResponses++; 207 207 + stats.endpoints[endpoint].notModifiedResponses++; 208 208 + if (!CONFIG.disableDetailedLogging) { 209 209 + logWithTime( 210 210 + `User ${userId.slice(0, 4)} - Request ${requestId} - ${endpoint} - 304 Not Modified (${responseTime.toFixed(2)}ms)`, 211 211 + "info", 212 212 + ); 213 213 + } 214 214 + } else if (response.ok) { 215 215 + stats.successfulRequests++; 216 216 + stats.endpoints[endpoint].successfulRequests++; 217 217 + if (!CONFIG.disableDetailedLogging) { 218 218 + logWithTime( 219 219 + `User ${userId.slice(0, 4)} - Request ${requestId} - ${endpoint} - ${response.status} OK (${responseTime.toFixed(2)}ms)`, 220 220 + "success", 221 221 + ); 222 222 + } 223 223 + 224 224 + // Store ETag for future requests if caching is enabled 225 225 + if (CONFIG.runWithCaching) { 226 226 + const etag = response.headers.get("ETag"); 227 227 + if (etag) { 228 228 + etagCache[cacheKey] = etag; 229 229 + } 230 230 + } 231 231 + 232 232 + // Parse JSON response (but don't do anything with it) 233 233 + await response.json(); 234 234 + } else { 235 235 + stats.failedRequests++; 236 236 + stats.endpoints[endpoint].failedRequests++; 237 237 + // Always log errors, even if detailed logging is disabled 238 238 + logWithTime( 239 239 + `User ${userId.slice(0, 4)} - Request ${requestId} - ${endpoint} - ${response.status} Error (${responseTime.toFixed(2)}ms)`, 240 240 + "error", 241 241 + ); 242 242 + } 243 243 + } catch (error) { 244 244 + stats.failedRequests++; 245 245 + 246 246 + // Ensure the endpoint exists in stats.endpoints 247 247 + if (!stats.endpoints[endpoint]) { 248 248 + stats.endpoints[endpoint] = { 249 249 + totalRequests: 0, 250 250 + successfulRequests: 0, 251 251 + notModifiedResponses: 0, 252 252 + failedRequests: 0, 253 253 + responseTimeTotal: 0, 254 254 + responseTimeMin: Number.MAX_VALUE, 255 255 + responseTimeMax: 0, 256 256 + }; 257 257 + } 258 258 + 259 259 + stats.endpoints[endpoint].failedRequests++; 260 260 + // Always log errors, even if detailed logging is disabled 261 261 + logWithTime( 262 262 + `User ${userId.slice(0, 4)} - Request ${requestId} - ${endpoint} - Exception: ${(error as Error).message}`, 263 263 + "error", 264 264 + ); 265 265 + } 266 266 + } 267 267 + 268 268 + // Simulate a user session 269 269 + async function simulateUser(userId: string): Promise<void> { 270 270 + try { 271 271 + // Create all requests at once for maximum concurrency 272 272 + const requests: Promise<void>[] = []; 273 273 + 274 274 + for (let i = 0; i < CONFIG.requestsPerUser; i++) { 275 275 + // Choose a random endpoint 276 276 + const endpoint = endpoints[Math.floor(Math.random() * endpoints.length)]; 277 277 + 278 278 + // Make sure endpoint is not undefined before adding it 279 279 + if (endpoint) { 280 280 + // Instead of waiting for each request, push them to an array 281 281 + requests.push(makeRequest(endpoint, userId, i + 1)); 282 282 + 283 283 + // Add a minimal delay if configured (usually 0) 284 284 + if (CONFIG.delayBetweenRequests > 0) { 285 285 + await new Promise((resolve) => 286 286 + setTimeout(resolve, CONFIG.delayBetweenRequests), 287 287 + ); 288 288 + } 289 289 + } 290 290 + } 291 291 + 292 292 + // Wait for all requests to complete 293 293 + await Promise.allSettled(requests); 294 294 + } catch (error) { 295 295 + logWithTime( 296 296 + `User ${userId.slice(0, 4)} - Error: ${(error as Error).message}`, 297 297 + "error", 298 298 + ); 299 299 + } finally { 300 300 + // Mark user as completed regardless of success/failure 301 301 + stats.userCompletedCount++; 302 302 + } 303 303 + } 304 304 + 305 305 + // Print results in a fancy way 306 306 + function printResults() { 307 307 + console.log("\n"); 308 308 + console.log(chalk.bold.cyan("🚀 Stress Test Results 🚀")); 309 309 + console.log( 310 310 + chalk.gray("════════════════════════════════════════════════════════"), 311 311 + ); 312 312 + console.log(chalk.bold.white("📊 General Stats:")); 313 313 + console.log( 314 314 + `${chalk.cyan("Total Users:")} ${chalk.yellow(stats.concurrency)}`, 315 315 + ); 316 316 + console.log( 317 317 + `${chalk.cyan("Completed Users:")} ${chalk.yellow(stats.userCompletedCount)}`, 318 318 + ); 319 319 + console.log( 320 320 + `${chalk.cyan("Total Requests:")} ${chalk.yellow(stats.totalRequests)}`, 321 321 + ); 322 322 + console.log( 323 323 + `${chalk.cyan("Successful Requests:")} ${chalk.green(stats.successfulRequests)} (${( 324 324 + (stats.successfulRequests / stats.totalRequests) * 325 325 + 100 326 326 + ).toFixed(2)}%)`, 327 327 + ); 328 328 + console.log( 329 329 + `${chalk.cyan("Not Modified (304):")} ${chalk.blue(stats.notModifiedResponses)} (${((stats.notModifiedResponses / stats.totalRequests) * 100).toFixed(2)}%)`, 330 330 + ); 331 331 + console.log( 332 332 + `${chalk.cyan("Failed Requests:")} ${chalk.red(stats.failedRequests)} (${((stats.failedRequests / stats.totalRequests) * 100).toFixed(2)}%)`, 333 333 + ); 334 334 + 335 335 + const durationInSeconds = (stats.endTime - stats.startTime) / 1000; 336 336 + console.log( 337 337 + `${chalk.cyan("Test Duration:")} ${chalk.yellow(durationInSeconds.toFixed(2))} seconds`, 338 338 + ); 339 339 + console.log( 340 340 + `${chalk.cyan("Requests per Second:")} ${chalk.yellow((stats.totalRequests / durationInSeconds).toFixed(2))}`, 341 341 + ); 342 342 + 343 343 + const avgResponseTime = stats.responseTimeTotal / stats.totalRequests; 344 344 + console.log( 345 345 + `${chalk.cyan("Average Response Time:")} ${chalk.yellow(avgResponseTime.toFixed(2))} ms`, 346 346 + ); 347 347 + console.log( 348 348 + `${chalk.cyan("Min Response Time:")} ${chalk.green(stats.responseTimeMin.toFixed(2))} ms`, 349 349 + ); 350 350 + console.log( 351 351 + `${chalk.cyan("Max Response Time:")} ${chalk.red(stats.responseTimeMax.toFixed(2))} ms`, 352 352 + ); 353 353 + 354 354 + console.log("\n"); 355 355 + console.log(chalk.bold.white("📈 Endpoint Stats:")); 356 356 + 357 357 + for (const [endpoint, endpointStats] of Object.entries(stats.endpoints)) { 358 358 + if (endpointStats.totalRequests === 0) continue; 359 359 + 360 360 + console.log( 361 361 + chalk.gray("────────────────────────────────────────────────────"), 362 362 + ); 363 363 + console.log(chalk.bold.cyan(`Endpoint: ${endpoint}`)); 364 364 + console.log( 365 365 + `${chalk.cyan("Total Requests:")} ${chalk.yellow(endpointStats.totalRequests)}`, 366 366 + ); 367 367 + console.log( 368 368 + `${chalk.cyan("Successful Requests:")} ${chalk.green(endpointStats.successfulRequests)} (${((endpointStats.successfulRequests / endpointStats.totalRequests) * 100).toFixed(2)}%)`, 369 369 + ); 370 370 + console.log( 371 371 + `${chalk.cyan("Not Modified (304):")} ${chalk.blue(endpointStats.notModifiedResponses)} (${((endpointStats.notModifiedResponses / endpointStats.totalRequests) * 100).toFixed(2)}%)`, 372 372 + ); 373 373 + console.log( 374 374 + `${chalk.cyan("Failed Requests:")} ${chalk.red(endpointStats.failedRequests)} (${((endpointStats.failedRequests / endpointStats.totalRequests) * 100).toFixed(2)}%)`, 375 375 + ); 376 376 + 377 377 + const avgResponseTime = 378 378 + endpointStats.responseTimeTotal / endpointStats.totalRequests; 379 379 + console.log( 380 380 + `${chalk.cyan("Average Response Time:")} ${chalk.yellow(avgResponseTime.toFixed(2))} ms`, 381 381 + ); 382 382 + console.log( 383 383 + `${chalk.cyan("Min Response Time:")} ${chalk.green(endpointStats.responseTimeMin.toFixed(2))} ms`, 384 384 + ); 385 385 + console.log( 386 386 + `${chalk.cyan("Max Response Time:")} ${chalk.red(endpointStats.responseTimeMax.toFixed(2))} ms`, 387 387 + ); 388 388 + } 389 389 + 390 390 + console.log( 391 391 + chalk.gray("════════════════════════════════════════════════════════"), 392 392 + ); 393 393 + console.log(chalk.bold.green("✅ Stress Test Completed")); 394 394 + if (CONFIG.runWithCaching) { 395 395 + console.log(chalk.bold.blue("ℹ️ Test ran with caching enabled (ETags)")); 396 396 + } else { 397 397 + console.log(chalk.bold.yellow("⚠️ Test ran without caching (no ETags)")); 398 398 + } 399 399 + } 400 400 + 401 401 + // Main function 402 402 + async function runConcurrencyLevel( 403 403 + concurrencyLevel: number, 404 404 + ): Promise<ConcurrencyStats> { 405 405 + // Reset stats for this level 406 406 + Object.assign(stats, { 407 407 + concurrency: concurrencyLevel, 408 408 + totalRequests: 0, 409 409 + successfulRequests: 0, 410 410 + notModifiedResponses: 0, 411 411 + failedRequests: 0, 412 412 + responseTimeTotal: 0, 413 413 + responseTimeMin: Number.MAX_VALUE, 414 414 + responseTimeMax: 0, 415 415 + startTime: 0, 416 416 + endTime: 0, 417 417 + userCompletedCount: 0, 418 418 + requestsPerSecond: 0, 419 419 + successRate: 0, 420 420 + endpoints: {}, 421 421 + }); 422 422 + 423 423 + // Reset endpoint stats 424 424 + for (const endpoint of endpoints) { 425 425 + stats.endpoints[endpoint] = { 426 426 + totalRequests: 0, 427 427 + successfulRequests: 0, 428 428 + notModifiedResponses: 0, 429 429 + failedRequests: 0, 430 430 + responseTimeTotal: 0, 431 431 + responseTimeMin: Number.MAX_VALUE, 432 432 + responseTimeMax: 0, 433 433 + }; 434 434 + } 435 435 + 436 436 + logWithTime(`Running concurrency level: ${concurrencyLevel} users`, "info"); 437 437 + stats.startTime = performance.now(); 438 438 + 439 439 + // Create user promises 440 440 + const userPromises: Promise<void>[] = []; 441 441 + 442 442 + for (let i = 0; i < concurrencyLevel; i++) { 443 443 + const userId = randomUUIDv7(); 444 444 + userPromises.push(simulateUser(userId)); 445 445 + } 446 446 + 447 447 + // Wait for all users to complete 448 448 + const spinner = new Spinner( 449 449 + `Running ${concurrencyLevel} concurrent users...`, 450 450 + ); 451 451 + spinner.start(); 452 452 + 453 453 + // Only update spinner occasionally to reduce logging overhead 454 454 + const updateIntervalMs = concurrencyLevel > 10000 ? 500 : 100; 455 455 + 456 456 + let lastCount = 0; 457 457 + const updateInterval = setInterval(() => { 458 458 + if (stats.userCompletedCount > lastCount) { 459 459 + lastCount = stats.userCompletedCount; 460 460 + // Only update text if significant progress has been made 461 461 + if ( 462 462 + stats.userCompletedCount === concurrencyLevel || 463 463 + stats.userCompletedCount % 464 464 + Math.max(1, Math.floor(concurrencyLevel / 20)) === 465 465 + 0 466 466 + ) { 467 467 + spinner.setText( 468 468 + `Progress: ${stats.userCompletedCount}/${concurrencyLevel} users (${Math.floor((stats.userCompletedCount / concurrencyLevel) * 100)}%)`, 469 469 + ); 470 470 + } 471 471 + } 472 472 + }, updateIntervalMs); 473 473 + 474 474 + await Promise.allSettled(userPromises); 475 475 + 476 476 + clearInterval(updateInterval); 477 477 + spinner.stop(); 478 478 + 479 479 + stats.endTime = performance.now(); 480 480 + 481 481 + // Calculate final stats 482 482 + const durationInSeconds = (stats.endTime - stats.startTime) / 1000; 483 483 + stats.requestsPerSecond = stats.totalRequests / durationInSeconds; 484 484 + stats.successRate = 485 485 + stats.totalRequests > 0 486 486 + ? (stats.successfulRequests / stats.totalRequests) * 100 487 487 + : 0; 488 488 + 489 489 + // Capture memory usage 490 490 + if (process.memoryUsage) { 491 491 + const memoryUsage = process.memoryUsage(); 492 492 + (stats as any).memoryUsage = { 493 493 + rss: memoryUsage.rss, 494 494 + heapTotal: memoryUsage.heapTotal, 495 495 + heapUsed: memoryUsage.heapUsed, 496 496 + external: memoryUsage.external, 497 497 + }; 498 498 + } 499 499 + 500 500 + // Create a deep copy of the stats to return 501 501 + const result: ConcurrencyStats = JSON.parse(JSON.stringify(stats)); 502 502 + 503 503 + return result; 504 504 + } 505 505 + 506 506 + function printLevelResults(levelStats: ConcurrencyStats) { 507 507 + console.log("\n"); 508 508 + console.log( 509 509 + chalk.bold.cyan(`📊 Concurrency Level: ${levelStats.concurrency} users`), 510 510 + ); 511 511 + console.log( 512 512 + chalk.gray("────────────────────────────────────────────────────"), 513 513 + ); 514 514 + 515 515 + console.log( 516 516 + `${chalk.cyan("Success Rate:")} ${ 517 517 + levelStats.successRate >= CONFIG.successThreshold 518 518 + ? chalk.green(`${levelStats.successRate.toFixed(2)}%`) 519 519 + : chalk.red(`${levelStats.successRate.toFixed(2)}%`) 520 520 + }`, 521 521 + ); 522 522 + 523 523 + console.log( 524 524 + `${chalk.cyan("Requests per Second:")} ${levelStats.requestsPerSecond.toFixed(2)}`, 525 525 + ); 526 526 + 527 527 + const avgResponseTime = 528 528 + levelStats.responseTimeTotal / levelStats.totalRequests; 529 529 + console.log( 530 530 + `${chalk.cyan("Average Response Time:")} ${ 531 531 + avgResponseTime <= CONFIG.responseTimeThreshold 532 532 + ? chalk.green(`${avgResponseTime.toFixed(2)} ms`) 533 533 + : chalk.red(`${avgResponseTime.toFixed(2)} ms`) 534 534 + }`, 535 535 + ); 536 536 + 537 537 + console.log(`${chalk.cyan("Total Requests:")} ${levelStats.totalRequests}`); 538 538 + console.log( 539 539 + `${chalk.cyan("Successful Requests:")} ${levelStats.successfulRequests}`, 540 540 + ); 541 541 + console.log(`${chalk.cyan("Failed Requests:")} ${levelStats.failedRequests}`); 542 542 + console.log( 543 543 + `${chalk.cyan("Test Duration:")} ${((levelStats.endTime - levelStats.startTime) / 1000).toFixed(2)}s`, 544 544 + ); 545 545 + 546 546 + // Add memory usage info if available 547 547 + if (levelStats.memoryUsage) { 548 548 + console.log( 549 549 + `${chalk.cyan("Memory RSS:")} ${(levelStats.memoryUsage.rss / 1024 / 1024).toFixed(2)} MB`, 550 550 + ); 551 551 + console.log( 552 552 + `${chalk.cyan("Heap Used:")} ${(levelStats.memoryUsage.heapUsed / 1024 / 1024).toFixed(2)} MB`, 553 553 + ); 554 554 + } 555 555 + } 556 556 + 557 557 + function printBreakingPointSummary() { 558 558 + console.log("\n"); 559 559 + console.log(chalk.bold.magenta("🔥 BREAKING POINT SUMMARY 🔥")); 560 560 + console.log( 561 561 + chalk.gray("════════════════════════════════════════════════════════"), 562 562 + ); 563 563 + 564 564 + if (breakingPoint) { 565 565 + console.log( 566 566 + chalk.bold.yellow( 567 567 + `Server breaking point: ${breakingPoint.concurrency} concurrent users`, 568 568 + ), 569 569 + ); 570 570 + console.log( 571 571 + chalk.gray("────────────────────────────────────────────────────"), 572 572 + ); 573 573 + console.log( 574 574 + `${chalk.cyan("Success Rate:")} ${chalk.red(`${breakingPoint.successRate.toFixed(2)}%`)}`, 575 575 + ); 576 576 + console.log( 577 577 + `${chalk.cyan("Requests per Second:")} ${breakingPoint.requestsPerSecond.toFixed(2)}`, 578 578 + ); 579 579 + 580 580 + const avgResponseTime = 581 581 + breakingPoint.responseTimeTotal / breakingPoint.totalRequests; 582 582 + console.log( 583 583 + `${chalk.cyan("Average Response Time:")} ${chalk.red(`${avgResponseTime.toFixed(2)} ms`)}`, 584 584 + ); 585 585 + 586 586 + // Get the last successful level 587 587 + const lastGoodLevelIndex = 588 588 + concurrencyResults.findIndex( 589 589 + (stats) => stats.concurrency === breakingPoint.concurrency, 590 590 + ) - 1; 591 591 + 592 592 + if (lastGoodLevelIndex >= 0) { 593 593 + const safeLevel = concurrencyResults[lastGoodLevelIndex]; 594 594 + if (safeLevel) { 595 595 + console.log(""); 596 596 + console.log( 597 597 + chalk.bold.green( 598 598 + `✅ Recommended Safe Concurrency: ${safeLevel.concurrency} users`, 599 599 + ), 600 600 + ); 601 601 + console.log( 602 602 + `${chalk.cyan("Success Rate:")} ${chalk.green(`${safeLevel.successRate.toFixed(2)}%`)}`, 603 603 + ); 604 604 + console.log( 605 605 + `${chalk.cyan("Requests per Second:")} ${safeLevel.requestsPerSecond.toFixed(2)}`, 606 606 + ); 607 607 + 608 608 + const safeAvgTime = 609 609 + safeLevel.responseTimeTotal / safeLevel.totalRequests; 610 610 + console.log( 611 611 + `${chalk.cyan("Average Response Time:")} ${chalk.green(`${safeAvgTime.toFixed(2)} ms`)}`, 612 612 + ); 613 613 + } 614 614 + } 615 615 + } else { 616 616 + console.log(chalk.bold.green("✅ No breaking point found!")); 617 617 + 618 618 + if (concurrencyResults.length > 0) { 619 619 + const maxLevel = concurrencyResults[concurrencyResults.length - 1]; 620 620 + if (maxLevel) { 621 621 + console.log( 622 622 + chalk.gray("────────────────────────────────────────────────────"), 623 623 + ); 624 624 + console.log( 625 625 + chalk.bold.green( 626 626 + `Maximum tested concurrency: ${maxLevel.concurrency} users`, 627 627 + ), 628 628 + ); 629 629 + console.log( 630 630 + `${chalk.cyan("Success Rate:")} ${chalk.green(`${maxLevel.successRate.toFixed(2)}%`)}`, 631 631 + ); 632 632 + console.log( 633 633 + `${chalk.cyan("Requests per Second:")} ${maxLevel.requestsPerSecond.toFixed(2)}`, 634 634 + ); 635 635 + 636 636 + const maxAvgTime = maxLevel.responseTimeTotal / maxLevel.totalRequests; 637 637 + console.log( 638 638 + `${chalk.cyan("Average Response Time:")} ${chalk.green(`${maxAvgTime.toFixed(2)} ms`)}`, 639 639 + ); 640 640 + } 641 641 + } 642 642 + } 643 643 + 644 644 + console.log(""); 645 645 + console.log(chalk.bold.white("📈 Concurrency Progression:")); 646 646 + 647 647 + for (const levelStats of concurrencyResults) { 648 648 + const avgResponseTime = 649 649 + levelStats.responseTimeTotal / levelStats.totalRequests; 650 650 + 651 651 + // Determine if this level was successful 652 652 + const isSuccessful = 653 653 + levelStats.successRate >= CONFIG.successThreshold && 654 654 + avgResponseTime <= CONFIG.responseTimeThreshold; 655 655 + 656 656 + // Get icon and color based on success 657 657 + const icon = isSuccessful ? "✅" : "❌"; 658 658 + const color = isSuccessful ? chalk.green : chalk.red; 659 659 + 660 660 + console.log( 661 661 + color( 662 662 + `${icon} ${levelStats.concurrency} users: ${levelStats.successRate.toFixed(2)}% success, ${levelStats.requestsPerSecond.toFixed(2)} req/s, ${avgResponseTime.toFixed(2)}ms avg`, 663 663 + ), 664 664 + ); 665 665 + } 666 666 + 667 667 + console.log(""); 668 668 + console.log(chalk.gray("HN Front Page Readiness Assessment:")); 669 669 + 670 670 + // Hacker News Front Page typically might see ~100-500 concurrent users 671 671 + if (!breakingPoint || breakingPoint.concurrency > 500) { 672 672 + console.log( 673 673 + chalk.bold.green( 674 674 + "✅ READY FOR HN FRONT PAGE! Your server can handle high traffic loads.", 675 675 + ), 676 676 + ); 677 677 + } else if (breakingPoint.concurrency > 100) { 678 678 + console.log( 679 679 + chalk.bold.yellow( 680 680 + "⚠️ POTENTIALLY READY: Your server may handle the front page but could struggle with peak traffic.", 681 681 + ), 682 682 + ); 683 683 + } else { 684 684 + console.log( 685 685 + chalk.bold.red( 686 686 + "❌ NOT READY: Your server is likely to fail under HN front page traffic.", 687 687 + ), 688 688 + ); 689 689 + } 690 690 + } 691 691 + 692 692 + async function main() { 693 693 + console.clear(); 694 694 + console.log(chalk.bold.cyan("⚡ Hacker News Breaking Point Stress Test ⚡")); 695 695 + console.log( 696 696 + chalk.gray("════════════════════════════════════════════════════════"), 697 697 + ); 698 698 + console.log(`${chalk.cyan("Base URL:")} ${chalk.yellow(CONFIG.baseUrl)}`); 699 699 + console.log( 700 700 + `${chalk.cyan("Starting Users:")} ${chalk.yellow(CONFIG.startConcurrency)}`, 701 701 + ); 702 702 + console.log( 703 703 + `${chalk.cyan("Maximum Users:")} ${chalk.yellow(CONFIG.maxConcurrency)}`, 704 704 + ); 705 705 + console.log( 706 706 + `${chalk.cyan("Concurrency Factor:")} ${chalk.yellow(CONFIG.concurrencyFactor)}x (exponential growth)`, 707 707 + ); 708 708 + console.log( 709 709 + `${chalk.cyan("Success Threshold:")} ${chalk.yellow(CONFIG.successThreshold)}%`, 710 710 + ); 711 711 + console.log( 712 712 + `${chalk.cyan("Response Time Threshold:")} ${chalk.yellow(CONFIG.responseTimeThreshold)}ms`, 713 713 + ); 714 714 + console.log( 715 715 + `${chalk.cyan("Caching:")} ${CONFIG.runWithCaching ? chalk.green("Enabled") : chalk.red("Disabled")}`, 716 716 + ); 717 717 + console.log( 718 718 + `${chalk.cyan("Detailed Logging:")} ${!CONFIG.disableDetailedLogging ? chalk.green("Enabled") : chalk.yellow("Disabled")}`, 719 719 + ); 720 720 + console.log( 721 721 + chalk.gray("════════════════════════════════════════════════════════"), 722 722 + ); 723 723 + 724 724 + // Verify server is up 725 725 + const spinner = new Spinner("Checking server availability..."); 726 726 + spinner.start(); 727 727 + 728 728 + try { 729 729 + const response = await fetch(`${CONFIG.baseUrl}/health`); 730 730 + if (!response.ok) { 731 731 + spinner.stop(); 732 732 + logWithTime( 733 733 + `Server health check failed: ${response.status} ${response.statusText}`, 734 734 + "error", 735 735 + ); 736 736 + process.exit(1); 737 737 + } 738 738 + 739 739 + spinner.stop(); 740 740 + logWithTime("Server is up and running", "success"); 741 741 + } catch (error) { 742 742 + spinner.stop(); 743 743 + logWithTime(`Server not available: ${(error as Error).message}`, "error"); 744 744 + logWithTime( 745 745 + "Make sure the server is running before starting the stress test", 746 746 + "info", 747 747 + ); 748 748 + process.exit(1); 749 749 + } 750 750 + 751 751 + console.log("\n"); 752 752 + logWithTime("Starting breaking point test...", "info"); 753 753 + 754 754 + let currentConcurrency = CONFIG.startConcurrency; 755 755 + let failureDetected = false; 756 756 + 757 757 + while (currentConcurrency <= CONFIG.maxConcurrency && !failureDetected) { 758 758 + // Run test with current concurrency level 759 759 + const levelResults = await runConcurrencyLevel(currentConcurrency); 760 760 + 761 761 + // Store results 762 762 + concurrencyResults.push(levelResults); 763 763 + 764 764 + // Print results for this level 765 765 + printLevelResults(levelResults); 766 766 + 767 767 + // Check if this is the breaking point 768 768 + const avgResponseTime = 769 769 + levelResults.responseTimeTotal / levelResults.totalRequests; 770 770 + if ( 771 771 + levelResults.successRate < CONFIG.successThreshold || 772 772 + avgResponseTime > CONFIG.responseTimeThreshold 773 773 + ) { 774 774 + breakingPoint = levelResults; 775 775 + 776 776 + if (CONFIG.stopOnFailure) { 777 777 + logWithTime( 778 778 + `Breaking point found at ${currentConcurrency} users!`, 779 779 + "warn", 780 780 + ); 781 781 + failureDetected = true; 782 782 + } else { 783 783 + logWithTime( 784 784 + `Performance degradation at ${currentConcurrency} users, but continuing test...`, 785 785 + "warn", 786 786 + ); 787 787 + } 788 788 + } 789 789 + 790 790 + // Increment concurrency exponentially for next level 791 791 + currentConcurrency = Math.floor( 792 792 + currentConcurrency * CONFIG.concurrencyFactor, 793 793 + ); 794 794 + 795 795 + // Wait between levels 796 796 + if (!failureDetected && currentConcurrency <= CONFIG.maxConcurrency) { 797 797 + await new Promise((resolve) => 798 798 + setTimeout(resolve, CONFIG.delayBetweenLevels), 799 799 + ); 800 800 + } 801 801 + } 802 802 + 803 803 + // Print final summary 804 804 + printBreakingPointSummary(); 805 805 + 806 806 + if (!breakingPoint && currentConcurrency > CONFIG.maxConcurrency) { 807 807 + logWithTime( 808 808 + "Maximum concurrency level reached without hitting breaking point.", 809 809 + "success", 810 810 + ); 811 811 + logWithTime( 812 812 + `Your server can handle at least ${CONFIG.maxConcurrency} concurrent users!`, 813 813 + "success", 814 814 + ); 815 815 + } 816 816 + } 817 817 + 818 818 + // Run the stress test and handle errors 819 819 + main().catch((error) => { 820 820 + console.error(`${chalk.red("Fatal error:")} ${error.message}`); 821 821 + process.exit(1); 822 822 + });