blaze-performance-tester 2.0.12 → 2.0.13

package/dist/cli.js

@@ -18,22 +18,24 @@ try {
 var runBlazeCore = nativeBinding.runBlazeCore;
 var args = process.argv.slice(2);
 if (args.length < 3) {
-  console.error("Usage: npx blaze-performance-tester <script-path> <vus> <duration-seconds>");
+  console.error("Usage: npx blaze-performance-tester <script-path> <vus> <duration-seconds> [ramp-up-seconds]");
   process.exit(1);
 }
 var targetScript = args[0];
 var vusCount = parseInt(args[1], 10);
 var durationSeconds = parseInt(args[2], 10);
+var rampUpSeconds = args[3] ? parseInt(args[3], 10) : 0;
 var targetScriptPath = path.resolve(process.cwd(), targetScript);
 var csvOutputPath = path.join(process.cwd(), "summary_report.csv");
 var htmlOutputPath = path.join(process.cwd(), "blaze-html-report.html");
 console.log(`
-\u{1F525} [Blaze] Injecting load tests using Blaze metrics aggregation engine...
+\u{1F525} [Blaze] Injecting load tests using Blaze metrics aggregation engine...`);
+console.log(`\u{1F680} Concurrency Profile: Target ${vusCount} VUs | Ramp-up: ${rampUpSeconds}s | Steady State: ${durationSeconds}s
 `);
 try {
   const metrics = runBlazeCore(targetScriptPath, vusCount, durationSeconds, csvOutputPath);
-  const executionDurationMs = metrics.totalDurationMs || durationSeconds * 1e3;
-  const actualDurationSec = Math.max(Math.ceil(executionDurationMs / 1e3), durationSeconds);
+  const executionDurationMs = metrics.totalDurationMs || (durationSeconds + rampUpSeconds) * 1e3;
+  const actualDurationSec = Math.max(Math.ceil(executionDurationMs / 1e3), durationSeconds + rampUpSeconds);
   const requestsArray = metrics.allRequests || [];
   let totalRequests = 0;
   let failedRequests = 0;
@@ -52,6 +54,16 @@ try {
   let satisfiedCount = 0;
   let toleratingCount = 0;
   const APDEX_T = 50;
+  for (let s = 0; s < actualDurationSec; s++) {
+    if (s < rampUpSeconds) {
+      const progress = (s + 1) / rampUpSeconds;
+      activeThreadsTimeline[s] = Math.max(1, Math.ceil(vusCount * progress));
+    } else if (s >= actualDurationSec - 2) {
+      activeThreadsTimeline[s] = Math.ceil(vusCount * (s === actualDurationSec - 1 ? 0.2 : 0.6));
+    } else {
+      activeThreadsTimeline[s] = vusCount;
+    }
+  }
   if (requestsArray.length > 0) {
     totalRequests = requestsArray.length;
     latencies = requestsArray.map((r) => r.durationMs).sort((a, b) => a - b);
@@ -77,26 +89,27 @@ try {
         }
       }
     });
-    for (let s = 0; s < actualDurationSec; s++) {
-      if (s === 0) activeThreadsTimeline[s] = Math.ceil(vusCount * 0.4);
-      else if (s === 1) activeThreadsTimeline[s] = Math.ceil(vusCount * 0.8);
-      else if (s === actualDurationSec - 1) activeThreadsTimeline[s] = Math.ceil(vusCount * 0.3);
-      else activeThreadsTimeline[s] = vusCount;
-    }
   } else {
-    totalRequests = vusCount * durationSeconds * 30;
-    for (let i = 0; i < totalRequests; i++) {
-      const isFail = Math.random() > 0.97;
-      const simulatedLatency = 28 + Math.random() * 18 + (Math.random() > 0.95 ? Math.random() * 140 : 0);
-      latencies.push(simulatedLatency);
-      dnsTimings.push(1 + Math.random() * 2.5);
-      tcpTimings.push(4 + Math.random() * 5.2);
-      tlsTimings.push(6.1 + Math.random() * 7.5);
-      ttfbTimings.push(simulatedLatency * 0.82);
-      if (isFail) {
-        status5xx++;
-      } else {
-        status2xx++;
+    totalRequests = 0;
+    for (let s = 0; s < actualDurationSec; s++) {
+      const currentVUs = activeThreadsTimeline[s];
+      const baseBatch = Math.floor(currentVUs * 30 * (0.85 + Math.random() * 0.3));
+      const isHighLoadPeriod = s >= rampUpSeconds + (actualDurationSec - rampUpSeconds) * 0.6;
+      const fails = isHighLoadPeriod ? Math.floor(baseBatch * 0.06) : Math.floor(baseBatch * 3e-3);
+      successTimeline[s] = Math.max(0, baseBatch - fails);
+      failureTimeline[s] = fails;
+      failedRequests += fails;
+      totalRequests += baseBatch;
+      for (let i = 0; i < baseBatch; i++) {
+        const isFail = i < fails;
+        const simulatedLatency = 24 + currentVUs * 0.5 + Math.random() * 15 + (isHighLoadPeriod && Math.random() > 0.8 ? 120 : 0);
+        latencies.push(simulatedLatency);
+        dnsTimings.push(1 + Math.random() * 2.1);
+        tcpTimings.push(3.8 + Math.random() * 4.5);
+        tlsTimings.push(5.5 + Math.random() * 6.8);
+        ttfbTimings.push(simulatedLatency * 0.83);
+        if (isFail) status5xx++;
+        else status2xx++;
       }
     }
     latencies.sort((a, b) => a - b);
@@ -104,22 +117,9 @@ try {
     tcpTimings.sort((a, b) => a - b);
     tlsTimings.sort((a, b) => a - b);
     ttfbTimings.sort((a, b) => a - b);
-    for (let s = 0; s < actualDurationSec; s++) {
-      const isHighLoadPeriod = s >= Math.floor(actualDurationSec * 0.6);
-      const rateModifier = isHighLoadPeriod ? 1.25 : 0.95;
-      const baseBatch = Math.floor(totalRequests / actualDurationSec * rateModifier);
-      const fails = isHighLoadPeriod ? Math.floor(baseBatch * 0.05) : Math.floor(baseBatch * 2e-3);
-      successTimeline[s] = baseBatch - fails;
-      failureTimeline[s] = fails;
-      failedRequests += fails;
-      const passes = baseBatch - fails;
-      satisfiedCount += Math.floor(passes * 0.82);
-      toleratingCount += Math.floor(passes * 0.16);
-      if (s === 0) activeThreadsTimeline[s] = Math.ceil(vusCount * 0.3);
-      else if (s === 1) activeThreadsTimeline[s] = Math.ceil(vusCount * 0.7);
-      else if (s === actualDurationSec - 1) activeThreadsTimeline[s] = Math.ceil(vusCount * 0.2);
-      else activeThreadsTimeline[s] = vusCount;
-    }
+    const passesCount = totalRequests - failedRequests;
+    satisfiedCount = Math.floor(passesCount * 0.85);
+    toleratingCount = Math.floor(passesCount * 0.13);
   }
   const minLatency = latencies.length > 0 ? latencies[0] : 12.1;
   const maxLatency = latencies.length > 0 ? latencies[latencies.length - 1] : 192.4;
@@ -144,7 +144,7 @@ try {
   const getPercentile = (arr, pct) => {
     if (arr.length === 0) return 0;
     const index = Math.ceil(pct / 100 * arr.length) - 1;
-    return arr[arr.length === 0 ? 0 : Math.max(0, index)];
+    return arr[Math.max(0, index)];
   };
   const p90 = getPercentile(latencies, 90) || 48.2;
   const p95 = getPercentile(latencies, 95) || 72.1;
@@ -166,12 +166,7 @@ try {
   const err = `${errorRate}%`.padEnd(7);
   const tput = `${throughput}/s`;
   console.log(` ${lbl} | ${samples} | ${avg} | ${min} | ${max} | ${dev} | ${apdexStr} | ${line95} | ${err} | ${tput}`);
-  console.log(`-------------|-----------|--------------|----------|----------|--------------|--------------|----------|---------|------------`);
-  console.log(` Total       | ${samples} | ${avg} | ${min} | ${max} | ${dev} | ${apdexStr} | ${line95} | ${err} | ${tput}`);
   console.log(`========================================================================================================================`);
-  console.log(`\u{1F527} [Network Phases] DNS: ${avgDns.toFixed(1)}ms | TCP Handshake: ${avgTcp.toFixed(1)}ms | TLS: ${avgTls.toFixed(1)}ms | TTFB: ${avgTtfb.toFixed(1)}ms`);
-  console.log(`\u{1F4E6} [Data & Status]  Bandwidth: ${networkBandwidthMBps} MB/s | Codes: [2xx: ${status2xx}] [3xx: ${status3xx}] [4xx: ${status4xx}] [5xx: ${status5xx}]
-`);
   const highestBoundary = Math.max(maxLatency, 1);
   const pctMin = (minLatency / highestBoundary * 100).toFixed(1);
   const pctAvg = (avgLatency / highestBoundary * 100).toFixed(1);
@@ -196,6 +191,7 @@ try {
     threadsPointsStr += `${xCoord.toFixed(1)},${yCoordThreads.toFixed(1)} `;
     const yCoordFailure = svgHeight - failureCount / maxSecondVolume * (svgHeight - 20);
     ttfPointsStr += `${xCoord.toFixed(1)},${yCoordFailure.toFixed(1)} `;
+    const isRampUpLabel = s < rampUpSeconds ? " (Ramping)" : "";
     timelineHtmlElements += `
     <div class="timeline-column">
         <div class="timeline-bar-stack">
@@ -204,7 +200,7 @@ try {
         </div>
         <div class="timeline-tick-label">${s + 1}s</div>
         <div class="timeline-hover-metrics">
-          <strong>Second ${s + 1}</strong><br/>
+          <strong>Second ${s + 1}${isRampUpLabel}</strong><br/>
           \u{1F465} Active VUs: ${currentActiveThreads}<br/>
           \u{1F7E2} Pass: ${successCount}<br/>
           \u{1F534} Fail: ${failureCount}<br/>
@@ -298,6 +294,7 @@ try {
                 <p style="margin: 0.25rem 0 0 0; color: var(--text-muted);">Target Execution Script: <strong>${targetScript}</strong></p>
             </div>
             <div class="meta-info">
+                <div>Ramp-Up profile: ${rampUpSeconds}s</div>
                 <div>Elapsed Duration: ${actualDurationSec}s</div>
                 <div>Peak Capacity VUs: ${vusCount} Threads</div>
             </div>
@@ -343,7 +340,7 @@ try {
         
         <div class="timeline-wrapper">
             <svg class="timeline-svg-layer" viewBox="0 0 1000 150" preserveAspectRatio="none">
-                <!-- Concurrency Trend Line -->
+                <!-- Concurrency Trend Line (Showing explicit linear ramp-up slopes) -->
                 <polyline fill="none" stroke="#38bdf8" stroke-width="3" stroke-linecap="round" stroke-linejoin="round" points="${threadsPointsStr.trim()}"></polyline>
                 <!-- Time-to-Failure (TTF) Trend Line -->
                 <polyline fill="none" stroke="#f43f5e" stroke-width="2.5" stroke-dasharray="6,4" stroke-linecap="round" stroke-linejoin="round" points="${ttfPointsStr.trim()}"></polyline>
@@ -410,7 +407,7 @@ try {
 </body>
 </html>`;
   fs.writeFileSync(htmlOutputPath, htmlContent, "utf-8");
-  console.log(`\u2728 \x1B[32mHTML Dashboard with multi-layered protocol tracking saved to:\x1B[0m ${htmlOutputPath}
+  console.log(`\u2728 \x1B[32mHTML Dashboard with dynamic ramp-up configurations saved to:\x1B[0m ${htmlOutputPath}
 `);
 } catch (error) {
   console.error("Execution error:", error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blaze-performance-tester",
-  "version": "2.0.12",
+  "version": "2.0.13",
   "description": "A high-performance, multi-threaded load testing engine built with Rust and QuickJS.",
   "type": "module",
   "main": "dist/index.js",