@cloudbeat/atlas-cli 0.1.0

package/dist/gates.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GATE_METRICS = void 0;
+exports.parseGates = parseGates;
+exports.evaluateGates = evaluateGates;
+exports.formatGate = formatGate;
+const ui_1 = require("./ui");
+/**
+ * Pass/fail thresholds, so a load test can block a pipeline.
+ *
+ * v1 evaluates the overall (`_all`) row only. Per-label thresholds are a
+ * deliberate later addition — the syntax leaves room for a `label:` qualifier.
+ */
+exports.GATE_METRICS = {
+    error_rate: { field: 'errorPct', unit: '%', label: 'error rate' },
+    avg: { field: 'avgMs', unit: 'ms', label: 'avg response time' },
+    p90: { field: 'p90Ms', unit: 'ms', label: 'p90' },
+    p95: { field: 'p95Ms', unit: 'ms', label: 'p95' },
+    p99: { field: 'p99Ms', unit: 'ms', label: 'p99' },
+    max: { field: 'maxMs', unit: 'ms', label: 'max response time' },
+    throughput: { field: 'throughput', unit: '/s', label: 'throughput' },
+    requests: { field: 'requests', unit: '', label: 'requests' },
+};
+const GATE_RE = /^([a-z_0-9]+)\s*(<=|>=|<|>)\s*(-?\d+(?:\.\d+)?)$/i;
+/** `--gate "error_rate<1,p95<2000"` (repeatable, comma-separated). */
+function parseGates(specs) {
+    const gates = [];
+    for (const spec of specs.flatMap(s => s.split(','))) {
+        const raw = spec.trim();
+        if (!raw)
+            continue;
+        const m = GATE_RE.exec(raw);
+        if (!m) {
+            throw new ui_1.CliError(`Invalid gate "${raw}". Expected <metric><op><number>, e.g. error_rate<1 or p95<=2000`, ui_1.EXIT.USAGE);
+        }
+        const metric = m[1].toLowerCase();
+        if (!(metric in exports.GATE_METRICS)) {
+            throw new ui_1.CliError(`Unknown gate metric "${m[1]}". Known: ${Object.keys(exports.GATE_METRICS).join(', ')}`, ui_1.EXIT.USAGE);
+        }
+        gates.push({ metric, operator: m[2], threshold: parseFloat(m[3]), source: raw });
+    }
+    return gates;
+}
+function compare(actual, operator, threshold) {
+    switch (operator) {
+        case '<': return actual < threshold;
+        case '<=': return actual <= threshold;
+        case '>': return actual > threshold;
+        case '>=': return actual >= threshold;
+    }
+}
+/** Evaluate gates against the run's overall row. */
+function evaluateGates(gates, rows) {
+    const overall = rows.find(r => r.label === '_all');
+    if (!overall) {
+        throw new ui_1.CliError('No overall (_all) metrics for this run — nothing was reported to Elasticsearch, so gates cannot be evaluated.', ui_1.EXIT.ERROR);
+    }
+    return gates.map(g => {
+        const actual = overall[exports.GATE_METRICS[g.metric].field];
+        return { ...g, actual, passed: compare(actual, g.operator, g.threshold) };
+    });
+}
+function formatGate(r) {
+    const { unit, label } = exports.GATE_METRICS[r.metric];
+    return `${label} ${r.actual}${unit} ${r.operator} ${r.threshold}${unit}`;
+}
+//# sourceMappingURL=gates.js.map

package/dist/junit.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildJUnit = buildJUnit;
+exports.writeJUnit = writeJUnit;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const gates_1 = require("./gates");
+function escapeXml(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+/**
+ * One <testcase> per gate, so a CI server renders each threshold as its own
+ * pass/fail rather than a single opaque "load test failed".
+ */
+function buildJUnit(params) {
+    const { testId, project, durationSec, gates, overall } = params;
+    const failures = gates.filter(g => !g.passed).length;
+    const suiteName = `atlas.${project}`;
+    const cases = gates.map(g => {
+        const name = `${g.metric} ${g.operator} ${g.threshold}`;
+        if (g.passed) {
+            return `    <testcase classname="${escapeXml(suiteName)}" name="${escapeXml(name)}"/>`;
+        }
+        const message = `Gate breached: ${(0, gates_1.formatGate)(g)} (actual ${g.actual}${gates_1.GATE_METRICS[g.metric].unit})`;
+        return (`    <testcase classname="${escapeXml(suiteName)}" name="${escapeXml(name)}">\n` +
+            `      <failure message="${escapeXml(message)}" type="GateFailure">${escapeXml(message)}</failure>\n` +
+            `    </testcase>`);
+    });
+    // Overall numbers ride along as properties so they are visible in CI even
+    // when every gate passed (or none were set).
+    const props = overall
+        ? [
+            `      <property name="requests" value="${overall.requests}"/>`,
+            `      <property name="errorPct" value="${overall.errorPct}"/>`,
+            `      <property name="avgMs" value="${overall.avgMs}"/>`,
+            `      <property name="p95Ms" value="${overall.p95Ms}"/>`,
+            `      <property name="p99Ms" value="${overall.p99Ms}"/>`,
+            `      <property name="throughput" value="${overall.throughput}"/>`,
+        ].join('\n')
+        : '';
+    return (`<?xml version="1.0" encoding="UTF-8"?>\n` +
+        `<testsuites>\n` +
+        `  <testsuite name="${escapeXml(suiteName)}" tests="${gates.length}" failures="${failures}" ` +
+        `time="${durationSec}" timestamp="${new Date().toISOString()}" hostname="${escapeXml(testId)}">\n` +
+        (props ? `    <properties>\n${props}\n    </properties>\n` : '') +
+        (cases.length ? cases.join('\n') + '\n' : '') +
+        `  </testsuite>\n` +
+        `</testsuites>\n`);
+}
+function writeJUnit(filePath, xml) {
+    const dir = path_1.default.dirname(path_1.default.resolve(filePath));
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.writeFileSync(filePath, xml, 'utf-8');
+}
+//# sourceMappingURL=junit.js.map

package/dist/ui.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = exports.CliError = exports.EXIT = void 0;
+exports.json = json;
+exports.formatDuration = formatDuration;
+exports.parseDuration = parseDuration;
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Exit codes are part of the CLI's contract with CI — a pipeline needs to tell
+ * "the test ran and breached a threshold" from "the CLI could not run at all".
+ */
+exports.EXIT = {
+    OK: 0,
+    /** The run completed but a --gate threshold was breached. */
+    GATE_FAILED: 1,
+    /** Bad flags, missing project, not logged in. */
+    USAGE: 2,
+    /** The run itself failed, timed out, or the API was unreachable. */
+    ERROR: 3,
+};
+/** Thrown for expected failures — reported without a stack trace. */
+class CliError extends Error {
+    code;
+    constructor(message, code = exports.EXIT.ERROR) {
+        super(message);
+        this.code = code;
+        this.name = 'CliError';
+    }
+}
+exports.CliError = CliError;
+exports.log = {
+    info: (msg) => console.log(msg),
+    step: (msg) => console.log(chalk_1.default.dim('· ') + msg),
+    ok: (msg) => console.log(chalk_1.default.green('✓ ') + msg),
+    warn: (msg) => console.warn(chalk_1.default.yellow('! ') + msg),
+    error: (msg) => console.error(chalk_1.default.red('✗ ') + msg),
+    dim: (msg) => console.log(chalk_1.default.dim(msg)),
+};
+function json(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+function formatDuration(ms) {
+    const s = Math.max(0, Math.round(ms / 1000));
+    const h = Math.floor(s / 3600);
+    const m = Math.floor((s % 3600) / 60);
+    const sec = s % 60;
+    if (h > 0)
+        return `${h}h ${m}m ${sec}s`;
+    if (m > 0)
+        return `${m}m ${sec}s`;
+    return `${sec}s`;
+}
+/** "30m" / "90s" / "2h" / plain seconds → milliseconds. */
+function parseDuration(value) {
+    const m = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h)?$/i.exec(value.trim());
+    if (!m)
+        throw new CliError(`Invalid duration: ${value} (use e.g. 30s, 15m, 2h)`, exports.EXIT.USAGE);
+    const n = parseFloat(m[1]);
+    switch ((m[2] ?? 's').toLowerCase()) {
+        case 'ms': return n;
+        case 's': return n * 1000;
+        case 'm': return n * 60_000;
+        case 'h': return n * 3_600_000;
+        default: return n * 1000;
+    }
+}
+//# sourceMappingURL=ui.js.map

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@cloudbeat/atlas-cli",
+  "version": "0.1.0",
+  "description": "Atlas CLI — run JMeter load tests from CI and record scenarios",
+  "main": "dist/cli.js",
+  "bin": {
+    "atlas": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "!dist/**/*.map"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cloudbeat-io/cb-atlas.git",
+    "directory": "cli"
+  },
+  "license": "UNLICENSED",
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src/cli.ts",
+    "start": "node dist/cli.js",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.0"
+  }
+}