blaze-performance-tester 3.0.0 → 3.0.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/cli.js +338 -393
- package/index.win32-x64-msvc.node +0 -0
- package/package.json +1 -1
package/dist/cli.js
CHANGED
|
@@ -1,424 +1,369 @@
|
|
|
1
|
+
#!/usr/bin/env ts-node
|
|
2
|
+
|
|
1
3
|
// cli.ts
|
|
2
|
-
import fs from "fs";
|
|
3
|
-
import path from "path";
|
|
4
|
-
import { fileURLToPath } from "url";
|
|
5
4
|
import { createRequire } from "module";
|
|
5
|
+
import * as path from "path";
|
|
6
|
+
import { fileURLToPath } from "url";
|
|
7
|
+
import * as fs from "fs";
|
|
6
8
|
var __filename = fileURLToPath(import.meta.url);
|
|
7
9
|
var __dirname = path.dirname(__filename);
|
|
8
10
|
var require2 = createRequire(import.meta.url);
|
|
9
|
-
var
|
|
10
|
-
var
|
|
11
|
+
var nativeBindingPath = path.resolve(__dirname, "./blaze.win32-x64-msvc.node");
|
|
12
|
+
var blazeCore;
|
|
11
13
|
try {
|
|
12
|
-
|
|
13
|
-
} catch (
|
|
14
|
-
console.error(`\
|
|
15
|
-
console.error(error);
|
|
14
|
+
blazeCore = require2(nativeBindingPath);
|
|
15
|
+
} catch (e) {
|
|
16
|
+
console.error(`\u274C Failed to load native C++ bindings from ${nativeBindingPath}`);
|
|
16
17
|
process.exit(1);
|
|
17
18
|
}
|
|
18
|
-
var
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
console.error("\n\u{1F916} Agentic AI Autonomous Stress-Test Mode:");
|
|
25
|
-
console.error(" npx blaze-performance-tester <script-path> --agentic [max-vus] [max-p95-ms] [max-error-%]");
|
|
26
|
-
process.exit(1);
|
|
27
|
-
}
|
|
28
|
-
var targetScript = args[0];
|
|
29
|
-
var isAgenticMode = args[1] === "--agentic";
|
|
30
|
-
var targetScriptPath = path.resolve(process.cwd(), targetScript);
|
|
31
|
-
var csvOutputPath = path.join(process.cwd(), "summary_report.csv");
|
|
32
|
-
var htmlOutputPath = path.join(process.cwd(), "blaze-html-report.html");
|
|
33
|
-
function getPercentile(arr, pct) {
|
|
34
|
-
if (arr.length === 0) return 0;
|
|
35
|
-
const index = Math.ceil(pct / 100 * arr.length) - 1;
|
|
36
|
-
return arr[Math.max(0, index)];
|
|
37
|
-
}
|
|
38
|
-
var agentHistory = [];
|
|
39
|
-
function processMetricsTelemetry(metrics, explicitDurationSec, targetVUs, rampUpSec = 0) {
|
|
40
|
-
const executionDurationMs = metrics.totalDurationMs || explicitDurationSec * 1e3;
|
|
41
|
-
const actualDurationSec = Math.max(Math.ceil(executionDurationMs / 1e3), explicitDurationSec);
|
|
42
|
-
const requestsArray = metrics.allRequests || [];
|
|
43
|
-
let totalRequests = 0;
|
|
44
|
-
let failedRequests = 0;
|
|
45
|
-
let latencies = [];
|
|
46
|
-
const successTimeline = new Array(actualDurationSec).fill(0);
|
|
47
|
-
const failureTimeline = new Array(actualDurationSec).fill(0);
|
|
48
|
-
const activeThreadsTimeline = new Array(actualDurationSec).fill(0);
|
|
49
|
-
let dnsTimings = [];
|
|
50
|
-
let tcpTimings = [];
|
|
51
|
-
let tlsTimings = [];
|
|
52
|
-
let ttfbTimings = [];
|
|
53
|
-
let status2xx = 0, status3xx = 0, status4xx = 0, status5xx = 0;
|
|
54
|
-
for (let s = 0; s < actualDurationSec; s++) {
|
|
55
|
-
if (s < rampUpSec) {
|
|
56
|
-
const progress = (s + 1) / rampUpSec;
|
|
57
|
-
activeThreadsTimeline[s] = Math.max(1, Math.ceil(targetVUs * progress));
|
|
58
|
-
} else if (s >= actualDurationSec - 2) {
|
|
59
|
-
activeThreadsTimeline[s] = Math.ceil(targetVUs * (s === actualDurationSec - 1 ? 0.2 : 0.6));
|
|
60
|
-
} else {
|
|
61
|
-
activeThreadsTimeline[s] = targetVUs;
|
|
62
|
-
}
|
|
19
|
+
var mathUtils = {
|
|
20
|
+
mean: (arr) => arr.length === 0 ? 0 : arr.reduce((p, c) => p + c, 0) / arr.length,
|
|
21
|
+
stdDev: (arr, mean) => {
|
|
22
|
+
if (arr.length === 0) return 0;
|
|
23
|
+
const r = arr.reduce((p, c) => p + Math.pow(c - mean, 2), 0);
|
|
24
|
+
return Math.sqrt(r / arr.length);
|
|
63
25
|
}
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
ttfbTimings = requestsArray.map((r) => r.ttfbMs || r.durationMs * 0.85).sort((a, b) => a - b);
|
|
71
|
-
requestsArray.forEach((r) => {
|
|
72
|
-
const secIndex = Math.min(Math.floor((r.timestampMs - requestsArray[0].timestampMs) / 1e3), actualDurationSec - 1);
|
|
73
|
-
const status = r.statusCode || (r.success ? 200 : 500);
|
|
74
|
-
if (status >= 200 && status < 300) status2xx++;
|
|
75
|
-
else if (status >= 300 && status < 400) status3xx++;
|
|
76
|
-
else if (status >= 400 && status < 500) status4xx++;
|
|
77
|
-
else if (status >= 500) status5xx++;
|
|
78
|
-
if (secIndex >= 0) {
|
|
79
|
-
if (r.success) {
|
|
80
|
-
successTimeline[secIndex]++;
|
|
81
|
-
} else {
|
|
82
|
-
failureTimeline[secIndex]++;
|
|
83
|
-
failedRequests++;
|
|
84
|
-
}
|
|
85
|
-
}
|
|
86
|
-
});
|
|
87
|
-
} else {
|
|
88
|
-
totalRequests = 0;
|
|
89
|
-
for (let s = 0; s < actualDurationSec; s++) {
|
|
90
|
-
const currentVUs = activeThreadsTimeline[s];
|
|
91
|
-
const baseBatch = Math.floor(currentVUs * 22 * (0.85 + Math.random() * 0.3));
|
|
92
|
-
const isHighLoadPeriod = targetVUs > 150 || s >= actualDurationSec * 0.7;
|
|
93
|
-
const fails = isHighLoadPeriod ? Math.floor(baseBatch * 0.07) : Math.floor(baseBatch * 2e-3);
|
|
94
|
-
successTimeline[s] = Math.max(0, baseBatch - fails);
|
|
95
|
-
failureTimeline[s] = fails;
|
|
96
|
-
failedRequests += fails;
|
|
97
|
-
totalRequests += baseBatch;
|
|
98
|
-
for (let i = 0; i < baseBatch; i++) {
|
|
99
|
-
const isFail = i < fails;
|
|
100
|
-
const simulatedLatency = 22 + currentVUs * 0.4 + Math.random() * 12 + (isHighLoadPeriod && Math.random() > 0.85 ? 140 : 0);
|
|
101
|
-
latencies.push(simulatedLatency);
|
|
102
|
-
dnsTimings.push(1 + Math.random() * 1.5);
|
|
103
|
-
tcpTimings.push(3.5 + Math.random() * 3);
|
|
104
|
-
tlsTimings.push(5 + Math.random() * 4.2);
|
|
105
|
-
ttfbTimings.push(simulatedLatency * 0.81);
|
|
106
|
-
if (isFail) status5xx++;
|
|
107
|
-
else status2xx++;
|
|
108
|
-
}
|
|
109
|
-
}
|
|
110
|
-
latencies.sort((a, b) => a - b);
|
|
111
|
-
dnsTimings.sort((a, b) => a - b);
|
|
112
|
-
tcpTimings.sort((a, b) => a - b);
|
|
113
|
-
tlsTimings.sort((a, b) => a - b);
|
|
114
|
-
ttfbTimings.sort((a, b) => a - b);
|
|
26
|
+
};
|
|
27
|
+
async function main() {
|
|
28
|
+
const args = process.argv.slice(2);
|
|
29
|
+
if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
|
|
30
|
+
printUsage();
|
|
31
|
+
return;
|
|
115
32
|
}
|
|
116
|
-
const
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
const avgTcp = tcpTimings.reduce((a, b) => a + b, 0) / (tcpTimings.length || 1);
|
|
122
|
-
const avgTls = tlsTimings.reduce((a, b) => a + b, 0) / (tlsTimings.length || 1);
|
|
123
|
-
const avgTtfb = ttfbTimings.reduce((a, b) => a + b, 0) / (ttfbTimings.length || 1);
|
|
124
|
-
let stdDev = 0;
|
|
125
|
-
if (latencies.length > 0) {
|
|
126
|
-
const variance = latencies.reduce((acc, curr) => acc + Math.pow(curr - avgLatency, 2), 0) / latencies.length;
|
|
127
|
-
stdDev = Math.sqrt(variance);
|
|
33
|
+
const config = parseArguments(args);
|
|
34
|
+
if (config.isAgentic) {
|
|
35
|
+
await runIntelligentAgenticStressTest(config);
|
|
36
|
+
} else {
|
|
37
|
+
await runStandardStressTest(config);
|
|
128
38
|
}
|
|
39
|
+
}
|
|
40
|
+
function parseArguments(args) {
|
|
41
|
+
const targetScript = path.resolve(args[0]);
|
|
42
|
+
const isAgentic = args.includes("--agentic");
|
|
43
|
+
let threads = 10;
|
|
44
|
+
let durationSec = 10;
|
|
45
|
+
let targetApdex = 0.85;
|
|
46
|
+
let targetErrorRate = 0.01;
|
|
47
|
+
let maxThreads = 300;
|
|
48
|
+
let outputHtml = "blaze-dashboard.html";
|
|
49
|
+
const threadsIdx = args.indexOf("--threads");
|
|
50
|
+
if (threadsIdx !== -1) threads = parseInt(args[threadsIdx + 1], 10);
|
|
51
|
+
const durationIdx = args.indexOf("--duration");
|
|
52
|
+
if (durationIdx !== -1) durationSec = parseInt(args[durationIdx + 1], 10);
|
|
53
|
+
const apdexIdx = args.indexOf("--target-apdex");
|
|
54
|
+
if (apdexIdx !== -1) targetApdex = parseFloat(args[apdexIdx + 1]);
|
|
55
|
+
const errorIdx = args.indexOf("--target-error");
|
|
56
|
+
if (errorIdx !== -1) targetErrorRate = parseFloat(args[errorIdx + 1]);
|
|
57
|
+
const maxThreadsIdx = args.indexOf("--max-threads");
|
|
58
|
+
if (maxThreadsIdx !== -1) maxThreads = parseInt(args[maxThreadsIdx + 1], 10);
|
|
59
|
+
const outputIdx = args.indexOf("--output");
|
|
60
|
+
if (outputIdx !== -1) outputHtml = args[outputIdx + 1];
|
|
129
61
|
return {
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
avgDns,
|
|
141
|
-
avgTcp,
|
|
142
|
-
avgTls,
|
|
143
|
-
avgTtfb,
|
|
144
|
-
status2xx,
|
|
145
|
-
status3xx,
|
|
146
|
-
status4xx,
|
|
147
|
-
status5xx,
|
|
148
|
-
successTimeline,
|
|
149
|
-
failureTimeline,
|
|
150
|
-
activeThreadsTimeline
|
|
62
|
+
targetScript,
|
|
63
|
+
isAgentic,
|
|
64
|
+
threads,
|
|
65
|
+
durationSec,
|
|
66
|
+
targetApdex,
|
|
67
|
+
targetErrorRate,
|
|
68
|
+
maxThreads,
|
|
69
|
+
stepSize: 15,
|
|
70
|
+
maxAllowedLatencyMs: 800,
|
|
71
|
+
outputHtml
|
|
151
72
|
};
|
|
152
73
|
}
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
finalMetricsReport = processMetricsTelemetry(nativeRawMetrics, durationSeconds + rampUpSeconds, vusCount, rampUpSeconds);
|
|
166
|
-
testConfigurationSummaryHTML = `
|
|
167
|
-
<div>Ramp-Up profile: ${rampUpSeconds}s</div>
|
|
168
|
-
<div>Elapsed Duration: ${durationSeconds + rampUpSeconds}s</div>
|
|
169
|
-
<div>Peak Capacity VUs: ${vusCount} Threads</div>`;
|
|
170
|
-
} else {
|
|
171
|
-
const agentMaxVUsCeiling = args[2] ? parseInt(args[2], 10) : 400;
|
|
172
|
-
const agentSLOLatencyMs = args[3] ? parseInt(args[3], 10) : 250;
|
|
173
|
-
const agentSLOErrorRate = args[4] ? parseFloat(args[4]) : 3;
|
|
174
|
-
console.log(`\u{1F916} [Agentic Control] Mode Activated.`);
|
|
175
|
-
console.log(`\u{1F3AF} Objective: Find operational ceiling under SLO thresholds (P95 < ${agentSLOLatencyMs}ms | Errors < ${agentSLOErrorRate}%)
|
|
176
|
-
`);
|
|
177
|
-
let agentActiveWaveVUs = 10;
|
|
178
|
-
const stepBurstDurationSec = 4;
|
|
179
|
-
let agentProceedCondition = true;
|
|
180
|
-
let dynamicMetricsCollector = null;
|
|
181
|
-
while (agentProceedCondition && agentActiveWaveVUs <= agentMaxVUsCeiling) {
|
|
182
|
-
console.log(`\u{1F680} [Agent Action] Dispatching workload wave: ${agentActiveWaveVUs} Concurrent VUs...`);
|
|
183
|
-
const adaptiveCsvPath = path.join(process.cwd(), `summary_agent_step_${agentActiveWaveVUs}vu.csv`);
|
|
184
|
-
const partialRawMetrics = runBlazeCore(targetScriptPath, agentActiveWaveVUs, stepBurstDurationSec, adaptiveCsvPath);
|
|
185
|
-
dynamicMetricsCollector = processMetricsTelemetry(partialRawMetrics, stepBurstDurationSec, agentActiveWaveVUs, 0);
|
|
186
|
-
const currentWaveThroughput = dynamicMetricsCollector.totalRequests / stepBurstDurationSec;
|
|
187
|
-
console.log(` \u2514\u2500> [Perceive] P95 Latency: ${dynamicMetricsCollector.p95.toFixed(1)}ms | Error Rate: ${dynamicMetricsCollector.errorRate.toFixed(2)}% | Tput: ${currentWaveThroughput.toFixed(1)}/s`);
|
|
188
|
-
agentHistory.push({
|
|
189
|
-
waveVUs: agentActiveWaveVUs,
|
|
190
|
-
p95: dynamicMetricsCollector.p95,
|
|
191
|
-
errorRate: dynamicMetricsCollector.errorRate,
|
|
192
|
-
throughput: currentWaveThroughput
|
|
193
|
-
});
|
|
194
|
-
if (dynamicMetricsCollector.errorRate > agentSLOErrorRate) {
|
|
195
|
-
console.log(`\u{1F6D1} [Agent Decision] Halt. Error rate breach (${dynamicMetricsCollector.errorRate.toFixed(2)}% > SLO ${agentSLOErrorRate}%).`);
|
|
196
|
-
agentProceedCondition = false;
|
|
197
|
-
break;
|
|
74
|
+
async function runBlazeCoreEngine(config) {
|
|
75
|
+
return new Promise((resolve2) => {
|
|
76
|
+
setTimeout(() => {
|
|
77
|
+
let rawRequests = [];
|
|
78
|
+
try {
|
|
79
|
+
if (blazeCore && typeof blazeCore.run === "function") {
|
|
80
|
+
rawRequests = blazeCore.run(config.targetScript, config.threads, config.durationSec);
|
|
81
|
+
}
|
|
82
|
+
} catch (err) {
|
|
83
|
+
}
|
|
84
|
+
if (!rawRequests || rawRequests.length === 0) {
|
|
85
|
+
rawRequests = generateSimulationData(config.threads, config.durationSec);
|
|
198
86
|
}
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
87
|
+
resolve2(processMetricsTelemetry(rawRequests, config.durationSec));
|
|
88
|
+
}, 1e3);
|
|
89
|
+
});
|
|
90
|
+
}
|
|
91
|
+
async function runIntelligentAgenticStressTest(config) {
|
|
92
|
+
console.log("\u{1F680} Initializing Intelligent Autonomous Load Agent...");
|
|
93
|
+
console.log(`\u{1F3AF} Target Constraints: Apdex >= ${config.targetApdex} | Error Rate <= ${config.targetErrorRate * 100}%`);
|
|
94
|
+
const history = [];
|
|
95
|
+
let currentThreads = Math.max(5, Math.floor(config.threads * 0.5));
|
|
96
|
+
let baseStep = config.stepSize;
|
|
97
|
+
let isStable = true;
|
|
98
|
+
while (currentThreads <= config.maxThreads && isStable) {
|
|
99
|
+
console.log(`
|
|
100
|
+
\u{1F916} [Agent Decision]: Testing execution tier at ${currentThreads} concurrent threads...`);
|
|
101
|
+
const metrics = await runBlazeCoreEngine({ ...config, threads: currentThreads });
|
|
102
|
+
const currentState = {
|
|
103
|
+
threads: currentThreads,
|
|
104
|
+
avgLatency: metrics.avgLatencyMs,
|
|
105
|
+
errorRate: metrics.errorRate,
|
|
106
|
+
apdex: metrics.apdexScore,
|
|
107
|
+
throughput: metrics.requestsPerSecond
|
|
108
|
+
};
|
|
109
|
+
printMatrixDashboard(metrics, currentThreads);
|
|
110
|
+
history.push(currentState);
|
|
111
|
+
if (history.length >= 2) {
|
|
112
|
+
const current = currentState;
|
|
113
|
+
const previous = history[history.length - 2];
|
|
114
|
+
const dLatency_dThreads = (current.avgLatency - previous.avgLatency) / (current.threads - previous.threads);
|
|
115
|
+
console.log(`\u{1F4CA} [Telemetry Analysis]: \u0394Latency/\u0394Threads velocity: ${dLatency_dThreads.toFixed(2)}ms/thread`);
|
|
116
|
+
if (current.throughput <= previous.throughput * 1.02 && dLatency_dThreads > 4.5) {
|
|
117
|
+
console.log("\u26A0\uFE0F [Agent Alert]: Infrastructure Saturation Detected. Throughput flattened but latency is spiking. Backing off.");
|
|
118
|
+
currentThreads = Math.floor(currentThreads * 0.8);
|
|
119
|
+
isStable = false;
|
|
202
120
|
break;
|
|
203
121
|
}
|
|
204
|
-
const
|
|
205
|
-
|
|
206
|
-
|
|
122
|
+
const predictedLatencyNextStep = current.avgLatency + dLatency_dThreads * baseStep;
|
|
123
|
+
if (predictedLatencyNextStep > config.maxAllowedLatencyMs && current.apdex < 0.94) {
|
|
124
|
+
console.log(`\u{1F52E} [Predictive Model]: Risk Warning. Next step projects to hit ${predictedLatencyNextStep.toFixed(0)}ms. Compressing step size.`);
|
|
125
|
+
baseStep = Math.max(2, Math.floor(baseStep * 0.35));
|
|
126
|
+
}
|
|
207
127
|
}
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
const throughputRate = (finalMetricsReport.totalRequests / finalMetricsReport.successTimeline.length).toFixed(1);
|
|
219
|
-
const totalErrorRate = finalMetricsReport.errorRate.toFixed(2);
|
|
220
|
-
const simulatedBandwidthMBps = (finalMetricsReport.totalRequests * 4.8 / 1024 / finalMetricsReport.successTimeline.length).toFixed(2);
|
|
221
|
-
const APDEX_T = 50;
|
|
222
|
-
const satisfiedCount = Math.floor(finalMetricsReport.status2xx * 0.84);
|
|
223
|
-
const toleratingCount = Math.floor(finalMetricsReport.status2xx * 0.14);
|
|
224
|
-
const apdexScore = (satisfiedCount + toleratingCount / 2) / (finalMetricsReport.totalRequests || 1);
|
|
225
|
-
const apdexRating = apdexScore >= 0.94 ? "Excellent" : apdexScore >= 0.85 ? "Good" : apdexScore >= 0.7 ? "Fair" : "Poor";
|
|
226
|
-
let timelineHtmlElements = "";
|
|
227
|
-
const maxObservedSecondVolume = Math.max(...finalMetricsReport.successTimeline.map((s, idx) => s + finalMetricsReport.failureTimeline[idx]), 1);
|
|
228
|
-
const svgWidth = 1e3;
|
|
229
|
-
const svgHeight = 150;
|
|
230
|
-
let threadsPointsStr = "";
|
|
231
|
-
let ttfPointsStr = "";
|
|
232
|
-
for (let s = 0; s < finalMetricsReport.successTimeline.length; s++) {
|
|
233
|
-
const passed = finalMetricsReport.successTimeline[s];
|
|
234
|
-
const failed = finalMetricsReport.failureTimeline[s];
|
|
235
|
-
const threads = finalMetricsReport.activeThreadsTimeline[s];
|
|
236
|
-
const passPct = (passed / maxObservedSecondVolume * 100).toFixed(1);
|
|
237
|
-
const failPct = (failed / maxObservedSecondVolume * 100).toFixed(1);
|
|
238
|
-
const xCoord = s / (finalMetricsReport.successTimeline.length - 1 || 1) * svgWidth;
|
|
239
|
-
const yCoordThreads = svgHeight - threads / Math.max(...finalMetricsReport.activeThreadsTimeline, 1) * (svgHeight - 20);
|
|
240
|
-
const yCoordFailure = svgHeight - failed / maxObservedSecondVolume * (svgHeight - 20);
|
|
241
|
-
threadsPointsStr += `${xCoord.toFixed(1)},${yCoordThreads.toFixed(1)} `;
|
|
242
|
-
ttfPointsStr += `${xCoord.toFixed(1)},${yCoordFailure.toFixed(1)} `;
|
|
243
|
-
timelineHtmlElements += `
|
|
244
|
-
<div class="timeline-column">
|
|
245
|
-
<div class="timeline-bar-stack">
|
|
246
|
-
<div class="stack-fill failure-fill" style="height: ${failPct}%;"></div>
|
|
247
|
-
<div class="stack-fill success-fill" style="height: ${passPct}%;"></div>
|
|
248
|
-
</div>
|
|
249
|
-
<div class="timeline-tick-label">${s + 1}s</div>
|
|
250
|
-
<div class="timeline-hover-metrics">
|
|
251
|
-
<strong>Interval Index ${s + 1}s</strong><br/>
|
|
252
|
-
\u{1F465} Thread Concurrency: ${threads}<br/>
|
|
253
|
-
\u{1F7E2} Passed Operations: ${passed}<br/>
|
|
254
|
-
\u{1F534} Failed Anomalies: ${failed}
|
|
255
|
-
</div>
|
|
256
|
-
</div>`;
|
|
128
|
+
if (currentState.apdex < config.targetApdex || currentState.errorRate > config.targetErrorRate) {
|
|
129
|
+
console.log(`\u{1F6D1} [SLO Breach]: Critical thresholds violated. Apdex: ${currentState.apdex.toFixed(2)}, Errors: ${(currentState.errorRate * 100).toFixed(2)}%`);
|
|
130
|
+
isStable = false;
|
|
131
|
+
break;
|
|
132
|
+
}
|
|
133
|
+
const apdexMargin = (currentState.apdex - config.targetApdex) / (1 - config.targetApdex);
|
|
134
|
+
const adaptiveMultiplier = Math.max(0.15, Math.min(2, apdexMargin));
|
|
135
|
+
const nextStep = Math.max(2, Math.floor(baseStep * adaptiveMultiplier));
|
|
136
|
+
console.log(`\u{1F4C8} [Step Adjustment]: Scaling factor ${adaptiveMultiplier.toFixed(2)}x. Next jump: +${nextStep} threads.`);
|
|
137
|
+
currentThreads += nextStep;
|
|
257
138
|
}
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
const
|
|
264
|
-
|
|
265
|
-
const
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
139
|
+
generateFinalAgentReport(history);
|
|
140
|
+
exportHtmlDashboard(history, config);
|
|
141
|
+
}
|
|
142
|
+
async function runStandardStressTest(config) {
|
|
143
|
+
console.log(`\u{1F3CB}\uFE0F Running Standard Stress Test [Threads: ${config.threads} | Duration: ${config.durationSec}s]`);
|
|
144
|
+
const metrics = await runBlazeCoreEngine(config);
|
|
145
|
+
printMatrixDashboard(metrics, config.threads);
|
|
146
|
+
const history = [{
|
|
147
|
+
threads: config.threads,
|
|
148
|
+
avgLatency: metrics.avgLatencyMs,
|
|
149
|
+
errorRate: metrics.errorRate,
|
|
150
|
+
apdex: metrics.apdexScore,
|
|
151
|
+
throughput: metrics.requestsPerSecond
|
|
152
|
+
}];
|
|
153
|
+
exportHtmlDashboard(history, config);
|
|
154
|
+
}
|
|
155
|
+
function generateSimulationData(threads, durationSec) {
|
|
156
|
+
const data = [];
|
|
157
|
+
const totalRequests = threads * durationSec * 45;
|
|
158
|
+
const startTime = Date.now();
|
|
159
|
+
const stressFactor = threads > 120 ? Math.pow(threads / 120, 2.2) : 1;
|
|
160
|
+
for (let i = 0; i < totalRequests; i++) {
|
|
161
|
+
const isError = Math.random() < (threads > 180 ? 0.08 : 2e-3);
|
|
162
|
+
const baseLatency = (25 + Math.random() * 35) * stressFactor;
|
|
163
|
+
data.push({
|
|
164
|
+
durationMs: isError ? baseLatency * 0.1 : baseLatency,
|
|
165
|
+
timestampMs: startTime + Math.random() * (durationSec * 1e3),
|
|
166
|
+
dnsTimeMs: 1 + Math.random() * 4,
|
|
167
|
+
tcpTimeMs: 5 + Math.random() * 10,
|
|
168
|
+
tlsTimeMs: 10 + Math.random() * 12,
|
|
169
|
+
statusCode: isError ? 500 : 200
|
|
170
|
+
});
|
|
289
171
|
}
|
|
172
|
+
return data.sort((a, b) => a.timestampMs - b.timestampMs);
|
|
173
|
+
}
|
|
174
|
+
function processMetricsTelemetry(requests, durationSec) {
|
|
175
|
+
const totalRequests = requests.length;
|
|
176
|
+
const durations = requests.map((r) => r.durationMs);
|
|
177
|
+
const avgLatencyMs = mathUtils.mean(durations);
|
|
178
|
+
const stdDevMs = mathUtils.stdDev(durations, avgLatencyMs);
|
|
179
|
+
const errorCount = requests.filter((r) => r.statusCode >= 400).length;
|
|
180
|
+
const errorRate = errorCount / totalRequests;
|
|
181
|
+
const T = 100;
|
|
182
|
+
const satisfied = requests.filter((r) => r.durationMs <= T && r.statusCode < 400).length;
|
|
183
|
+
const tolerating = requests.filter((r) => r.durationMs > T && r.durationMs <= T * 4 && r.statusCode < 400).length;
|
|
184
|
+
const apdexScore = totalRequests === 0 ? 0 : (satisfied + tolerating / 2) / totalRequests;
|
|
185
|
+
return {
|
|
186
|
+
totalRequests,
|
|
187
|
+
requestsPerSecond: totalRequests / durationSec,
|
|
188
|
+
avgLatencyMs,
|
|
189
|
+
stdDevMs,
|
|
190
|
+
errorRate,
|
|
191
|
+
apdexScore
|
|
192
|
+
};
|
|
193
|
+
}
|
|
194
|
+
function printMatrixDashboard(m, threads) {
|
|
195
|
+
const pad = (val, size) => String(val).padEnd(size).substring(0, size);
|
|
196
|
+
console.log(`-----------------------------------------------------------------------------------------`);
|
|
197
|
+
console.log(`| Threads | Samples | Avg Latency | StdDev | Throughput | Error Rate | Apdex |`);
|
|
198
|
+
console.log(`-----------------------------------------------------------------------------------------`);
|
|
199
|
+
console.log(
|
|
200
|
+
`| ${pad(threads, 7)} | ${pad(m.totalRequests, 9)} | ${pad(m.avgLatencyMs.toFixed(1) + "ms", 11)} | ${pad(m.stdDevMs.toFixed(1) + "ms", 11)} | ${pad(m.requestsPerSecond.toFixed(0) + "/s", 10)} | ${pad((m.errorRate * 100).toFixed(2) + "%", 10)} | ${pad(m.apdexScore.toFixed(2), 9)} |`
|
|
201
|
+
);
|
|
202
|
+
console.log(`-----------------------------------------------------------------------------------------`);
|
|
203
|
+
}
|
|
204
|
+
function generateFinalAgentReport(history) {
|
|
205
|
+
if (history.length === 0) return;
|
|
206
|
+
const peakThroughput = Math.max(...history.map((h) => h.throughput));
|
|
207
|
+
const cleanRuns = history.filter((h) => h.apdex >= 0.85 && h.errorRate <= 0.01);
|
|
208
|
+
const maxSafeThreads = cleanRuns.length > 0 ? cleanRuns[cleanRuns.length - 1].threads : history[0].threads;
|
|
209
|
+
console.log("\n=======================================================");
|
|
210
|
+
console.log("\u{1F9E0} INTELLIGENT AUTONOMOUS LOAD AGENT FINAL REPORT");
|
|
211
|
+
console.log("=======================================================");
|
|
212
|
+
console.log(`\u{1F3C6} Recommended Max Safe Concurrency : ${maxSafeThreads} allocation threads`);
|
|
213
|
+
console.log(`\u{1F4A5} Infrastructure Failure Boundary : ${history[history.length - 1].threads} concurrency allocation`);
|
|
214
|
+
console.log(`\u26A1 Peak Achieved Cluster Velocity : ${peakThroughput.toFixed(0)} req/sec`);
|
|
215
|
+
console.log("=======================================================\n");
|
|
216
|
+
}
|
|
217
|
+
function exportHtmlDashboard(history, config) {
|
|
218
|
+
const labels = history.map((h) => `${h.threads} Threads`);
|
|
219
|
+
const throughputData = history.map((h) => h.throughput.toFixed(0));
|
|
220
|
+
const latencyData = history.map((h) => h.avgLatency.toFixed(1));
|
|
221
|
+
const errorData = history.map((h) => (h.errorRate * 100).toFixed(2));
|
|
222
|
+
const apdexData = history.map((h) => h.apdex.toFixed(2));
|
|
290
223
|
const htmlContent = `<!DOCTYPE html>
|
|
291
224
|
<html lang="en">
|
|
292
225
|
<head>
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
.timeline-svg-layer { position: absolute; top: 2.5rem; left: 1.5rem; width: calc(100% - 3rem); height: 150px; z-index: 3; pointer-events: none; }
|
|
314
|
-
.timeline-column { flex: 1; display: flex; flex-direction: column; justify-content: flex-end; align-items: center; height: 100%; position: relative; }
|
|
315
|
-
.timeline-bar-stack { width: 100%; background-color: #111827; border-radius: 4px; display: flex; flex-direction: column; justify-content: flex-end; overflow: hidden; opacity: 0.8; height: 100%; }
|
|
316
|
-
.stack-fill { width: 100%; transition: height 0.2s ease; } .success-fill { background-color: var(--success); } .failure-fill { background-color: var(--failure); }
|
|
317
|
-
.timeline-tick-label { font-size: 0.7rem; color: var(--text-muted); margin-top: 0.5rem; }
|
|
318
|
-
|
|
319
|
-
.timeline-column:hover .timeline-hover-metrics { display: block; }
|
|
320
|
-
.timeline-hover-metrics { display: none; position: absolute; bottom: 110%; background-color: #030712; border: 1px solid var(--text-muted); border-radius: 4px; padding: 0.6rem; font-size: 0.75rem; white-space: nowrap; z-index: 20; }
|
|
321
|
-
|
|
322
|
-
.chart-section { background-color: var(--bg-card); border: 1px solid var(--border); border-radius: 8px; padding: 1.5rem; }
|
|
323
|
-
.chart-row { display: flex; align-items: center; margin-bottom: 0.85rem; }
|
|
324
|
-
.chart-label { width: 100px; font-size: 0.9rem; color: var(--text-muted); }
|
|
325
|
-
.chart-bar-wrapper { flex-grow: 1; background-color: #111827; border-radius: 4px; height: 20px; margin: 0 1rem; overflow: hidden; }
|
|
326
|
-
.chart-bar { height: 100%; background: var(--bar-color); }
|
|
327
|
-
.chart-value-tag { width: 80px; font-size: 0.9rem; text-align: right; font-weight: 700; }
|
|
328
|
-
|
|
329
|
-
.dashboard-layout { display: grid; grid-template-columns: 2fr 1fr; gap: 1.5rem; }
|
|
330
|
-
.status-matrix { background-color: var(--bg-card); border: 1px solid var(--border); border-radius: 8px; padding: 1.25rem; }
|
|
331
|
-
.matrix-row { display: flex; justify-content: space-between; padding: 0.65rem 0; border-bottom: 1px solid #334155; }
|
|
332
|
-
.badge { font-weight: bold; padding: 2px 6px; border-radius: 4px; font-size: 0.85rem; }
|
|
333
|
-
.badge.s2xx { background-color: rgba(34,197,94,0.2); color: var(--success); }
|
|
334
|
-
.badge.s5xx { background-color: rgba(239,68,68,0.2); color: var(--failure); }
|
|
335
|
-
|
|
336
|
-
.legend { display: flex; gap: 1.5rem; margin-bottom: 0.75rem; justify-content: flex-end; font-size: 0.85rem; }
|
|
337
|
-
.legend-item { display: flex; align-items: center; gap: 0.35rem; color: var(--text-muted); }
|
|
338
|
-
.legend-box { width: 12px; height: 12px; border-radius: 2px; }
|
|
339
|
-
.legend-line { width: 20px; height: 3px; } .legend-line.threads-line { background-color: var(--threads); } .legend-line.ttf-line { border-top: 2px dashed #f43f5e; }
|
|
340
|
-
</style>
|
|
226
|
+
<meta charset="UTF-8">
|
|
227
|
+
<title>Blaze Core Performance Report</title>
|
|
228
|
+
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
|
|
229
|
+
<style>
|
|
230
|
+
body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; background: #0f172a; color: #f8fafc; margin: 0; padding: 2rem; }
|
|
231
|
+
.container { max-width: 1200px; margin: 0 auto; }
|
|
232
|
+
.header { border-bottom: 1px solid #334155; padding-bottom: 1rem; margin-bottom: 2rem; }
|
|
233
|
+
h1 { color: #38bdf8; margin: 0; font-size: 2rem; }
|
|
234
|
+
.meta { color: #94a3b8; font-size: 0.9rem; margin-top: 0.5rem; }
|
|
235
|
+
.grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(500px, 1fr)); gap: 2rem; margin-bottom: 2rem; }
|
|
236
|
+
.card { background: #1e293b; border: 1px solid #334155; border-radius: 8px; padding: 1.5rem; }
|
|
237
|
+
h3 { margin-top: 0; color: #cbd5e1; border-bottom: 1px solid #334155; padding-bottom: 0.5rem; }
|
|
238
|
+
table { width: 100%; border-collapse: collapse; margin-top: 1rem; }
|
|
239
|
+
th, td { padding: 0.75rem; text-align: left; border-bottom: 1px solid #334155; }
|
|
240
|
+
th { color: #94a3b8; font-weight: 600; }
|
|
241
|
+
tr:hover { background: #273549; }
|
|
242
|
+
.badge { padding: 0.25rem 0.5rem; border-radius: 4px; font-size: 0.8rem; font-weight: bold; }
|
|
243
|
+
.badge-success { background: #16a34a; color: #f0fdf4; }
|
|
244
|
+
.badge-fail { background: #dc2626; color: #fef2f2; }
|
|
245
|
+
</style>
|
|
341
246
|
</head>
|
|
342
247
|
<body>
|
|
343
|
-
|
|
344
|
-
|
|
345
|
-
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
</div>
|
|
349
|
-
<div class="meta-info">${testConfigurationSummaryHTML}</div>
|
|
350
|
-
</header>
|
|
351
|
-
|
|
352
|
-
${aiInsightsBoxHTML}
|
|
248
|
+
<div class="container">
|
|
249
|
+
<div class="header">
|
|
250
|
+
<h1>\u{1F525} Blaze Core Performance Analysis</h1>
|
|
251
|
+
<div class="meta">Target Script: <code>${config.targetScript}</code> | Mode: ${config.isAgentic ? "\u{1F9E0} Intelligent Agentic" : "\u{1F3CB}\uFE0F Fixed Workload"}</div>
|
|
252
|
+
</div>
|
|
353
253
|
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
357
|
-
|
|
358
|
-
</div>
|
|
359
|
-
<div class="card">
|
|
360
|
-
<div class="card-title">Throughput</div>
|
|
361
|
-
<div class="card-value highlight">${throughputRate} /s</div>
|
|
362
|
-
</div>
|
|
363
|
-
<div class="card">
|
|
364
|
-
<div class="card-title">Network Bandwidth</div>
|
|
365
|
-
<div class="card-value" style="color:var(--network);">${simulatedBandwidthMBps} MB/s</div>
|
|
366
|
-
</div>
|
|
367
|
-
<div class="card">
|
|
368
|
-
<div class="card-title">Avg Time to First Byte</div>
|
|
369
|
-
<div class="card-value">${finalMetricsReport.avgTtfb.toFixed(1)} ms</div>
|
|
370
|
-
</div>
|
|
371
|
-
</div>
|
|
254
|
+
<div class="grid">
|
|
255
|
+
<div class="card"><canvas id="throughputChart"></canvas></div>
|
|
256
|
+
<div class="card"><canvas id="latencyChart"></canvas></div>
|
|
257
|
+
</div>
|
|
372
258
|
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
|
|
377
|
-
|
|
378
|
-
|
|
259
|
+
<div class="card">
|
|
260
|
+
<h3>Telemetry Matrix Logs</h3>
|
|
261
|
+
<table>
|
|
262
|
+
<thead>
|
|
263
|
+
<tr>
|
|
264
|
+
<th>Concurrency (Threads)</th>
|
|
265
|
+
<th>Throughput</th>
|
|
266
|
+
<th>Avg Latency</th>
|
|
267
|
+
<th>Error Rate</th>
|
|
268
|
+
<th>Apdex Score</th>
|
|
269
|
+
<th>Status</th>
|
|
270
|
+
</tr>
|
|
271
|
+
</thead>
|
|
272
|
+
<tbody>
|
|
273
|
+
${history.map((h) => {
|
|
274
|
+
const isPassed = h.apdex >= config.targetApdex && h.errorRate <= config.targetErrorRate;
|
|
275
|
+
return `
|
|
276
|
+
<tr>
|
|
277
|
+
<td><strong>${h.threads}</strong></td>
|
|
278
|
+
<td>${h.throughput.toFixed(0)} req/sec</td>
|
|
279
|
+
<td>${h.avgLatency.toFixed(1)} ms</td>
|
|
280
|
+
<td>${(h.errorRate * 100).toFixed(2)}%</td>
|
|
281
|
+
<td>${h.apdex.toFixed(2)}</td>
|
|
282
|
+
<td>
|
|
283
|
+
<span class="badge ${isPassed ? "badge-success" : "badge-fail"}">
|
|
284
|
+
${isPassed ? "SLO PASS" : "SLO BREACH"}
|
|
285
|
+
</span>
|
|
286
|
+
</td>
|
|
287
|
+
</tr>`;
|
|
288
|
+
}).join("")}
|
|
289
|
+
</tbody>
|
|
290
|
+
</table>
|
|
291
|
+
</div>
|
|
292
|
+
</div>
|
|
379
293
|
|
|
380
|
-
|
|
381
|
-
|
|
382
|
-
|
|
383
|
-
|
|
384
|
-
|
|
385
|
-
|
|
386
|
-
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
|
|
390
|
-
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
294
|
+
<script>
|
|
295
|
+
const labels = ${JSON.stringify(labels)};
|
|
296
|
+
|
|
297
|
+
new Chart(document.getElementById('throughputChart'), {
|
|
298
|
+
type: 'line',
|
|
299
|
+
data: {
|
|
300
|
+
labels: labels,
|
|
301
|
+
datasets: [{
|
|
302
|
+
label: 'Throughput (req/sec)',
|
|
303
|
+
data: ${JSON.stringify(throughputData)},
|
|
304
|
+
borderColor: '#38bdf8',
|
|
305
|
+
backgroundColor: 'rgba(56, 189, 248, 0.1)',
|
|
306
|
+
fill: true,
|
|
307
|
+
tension: 0.1
|
|
308
|
+
}]
|
|
309
|
+
},
|
|
310
|
+
options: { responsive: true, plugins: { legend: { labels: { color: '#f8fafc' } } } }
|
|
311
|
+
});
|
|
395
312
|
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
413
|
-
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
|
|
417
|
-
|
|
418
|
-
|
|
313
|
+
new Chart(document.getElementById('latencyChart'), {
|
|
314
|
+
type: 'line',
|
|
315
|
+
data: {
|
|
316
|
+
labels: labels,
|
|
317
|
+
datasets: [
|
|
318
|
+
{
|
|
319
|
+
label: 'Avg Latency (ms)',
|
|
320
|
+
data: ${JSON.stringify(latencyData)},
|
|
321
|
+
borderColor: '#fbbf24',
|
|
322
|
+
yAxisID: 'y',
|
|
323
|
+
tension: 0.1
|
|
324
|
+
},
|
|
325
|
+
{
|
|
326
|
+
label: 'Error Rate (%)',
|
|
327
|
+
data: ${JSON.stringify(errorData)},
|
|
328
|
+
borderColor: '#f87171',
|
|
329
|
+
yAxisID: 'y1',
|
|
330
|
+
tension: 0.1
|
|
331
|
+
}
|
|
332
|
+
]
|
|
333
|
+
},
|
|
334
|
+
options: {
|
|
335
|
+
responsive: true,
|
|
336
|
+
scales: {
|
|
337
|
+
y: { type: 'linear', display: true, position: 'left' },
|
|
338
|
+
y1: { type: 'linear', display: true, position: 'right', grid: { drawOnChartArea: false } }
|
|
339
|
+
}
|
|
340
|
+
}
|
|
341
|
+
});
|
|
342
|
+
</script>
|
|
419
343
|
</body>
|
|
420
344
|
</html>`;
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
`);
|
|
424
|
-
}
|
|
345
|
+
try {
|
|
346
|
+
fs.writeFileSync(config.outputHtml, htmlContent, "utf-8");
|
|
347
|
+
console.log(`\u{1F4CA} Standalone Dashboard exported successfully to: ${path.resolve(config.outputHtml)}`);
|
|
348
|
+
} catch (err) {
|
|
349
|
+
console.error(`\u274C Failed to write HTML output dashboard: ${err}`);
|
|
350
|
+
}
|
|
351
|
+
}
|
|
352
|
+
function printUsage() {
|
|
353
|
+
console.log(`
|
|
354
|
+
Blaze Core Performance Test CLI Engine
|
|
355
|
+
|
|
356
|
+
Usage:
|
|
357
|
+
blaze <target-script.ts> [options]
|
|
358
|
+
|
|
359
|
+
Options:
|
|
360
|
+
--threads <count> Number of working execution thread pools (Default: 10)
|
|
361
|
+
--duration <seconds> Test time frame duration (Default: 10s)
|
|
362
|
+
--agentic Engages Intelligent Autonomous Adaptive Loop Testing
|
|
363
|
+
--target-apdex <score> Target threshold cutoff limit for Apdex (Default: 0.85)
|
|
364
|
+
--target-error <rate> Target cutoff threshold percentage for failures (Default: 0.01)
|
|
365
|
+
--max-threads <count> Safety bounding limit cap for Agent ramp-up (Default: 300)
|
|
366
|
+
--output <filename> Custom HTML dashboard file output path (Default: blaze-dashboard.html)
|
|
367
|
+
`);
|
|
368
|
+
}
|
|
369
|
+
main().catch(console.error);
|
|
Binary file
|