@codyswann/lisa 1.0.0

package/typescript/copy-overwrite/.github/k6/scenarios/soak.js

@@ -0,0 +1,244 @@
+import http from "k6/http";
+import { check, group, sleep } from "k6";
+import { Rate, Trend, Counter } from "k6/metrics";
+
+// Custom metrics for soak testing
+const errorRate = new Rate("errors");
+const memoryLeakIndicator = new Trend("response_time_degradation");
+const requestsPerMinute = new Counter("requests_per_minute");
+const degradationRate = new Trend("degradation_rate");
+
+export const options = {
+  vus: 10,
+  duration: __ENV.K6_DURATION || "30m", // Default 30 minutes, can override
+  thresholds: {
+    http_req_failed: ["rate<0.02"], // Very low error tolerance for soak
+    http_req_duration: ["p(95)<1000"], // Consistent performance expected
+    errors: ["rate<0.02"],
+    degradation_rate: ["value<0.1"], // Performance shouldn't degrade > 10%
+  },
+};
+
+const BASE_URL = __ENV.K6_BASE_URL || "http://localhost:3000";
+const CUSTOM_HEADERS = __ENV.K6_CUSTOM_HEADERS
+  ? JSON.parse(__ENV.K6_CUSTOM_HEADERS)
+  : {};
+
+// Track performance over time
+const performanceHistory = [];
+const historyInterval = 60; // Track every 60 seconds
+let lastHistoryUpdate = Date.now();
+let baselineResponseTime = null;
+
+export default function () {
+  const headers = {
+    "Content-Type": "application/json",
+    ...CUSTOM_HEADERS,
+  };
+
+  const iterationStart = Date.now();
+
+  group("Soak Test Operations", () => {
+    // Standard operations that run continuously
+    group("Read Operations", () => {
+      const endpoints = [
+        "/api/items",
+        "/api/status",
+        "/api/health",
+        "/api/metrics",
+      ];
+
+      endpoints.forEach(endpoint => {
+        const response = http.get(`${BASE_URL}${endpoint}`, {
+          headers,
+          tags: { name: `GET ${endpoint}`, operation: "read" },
+        });
+
+        const isOk = check(response, {
+          [`${endpoint} status OK`]: r => r.status === 200,
+          [`${endpoint} response time OK`]: r => r.timings.duration < 1000,
+        });
+
+        if (!isOk) {
+          errorRate.add(1);
+        }
+
+        // Track response time degradation
+        if (endpoint === "/api/items") {
+          memoryLeakIndicator.add(response.timings.duration);
+
+          // Set baseline on first successful request
+          if (baselineResponseTime === null && response.status === 200) {
+            baselineResponseTime = response.timings.duration;
+          }
+
+          // Calculate degradation
+          if (baselineResponseTime !== null) {
+            const degradation =
+              (response.timings.duration - baselineResponseTime) /
+              baselineResponseTime;
+            degradationRate.add(degradation);
+          }
+        }
+      });
+    });
+
+    group("Write Operations", () => {
+      // Periodic write operations to test resource cleanup
+      if (__ITER % 10 === 0) {
+        // Every 10th iteration
+        const payload = JSON.stringify({
+          test: "soak",
+          iteration: __ITER,
+          timestamp: Date.now(),
+          vu: __VU,
+          data: Array(100).fill("x").join(""), // Small payload
+        });
+
+        const writeResponse = http.post(`${BASE_URL}/api/items`, payload, {
+          headers,
+          tags: { name: "POST /api/items", operation: "write" },
+        });
+
+        check(writeResponse, {
+          "write status OK": r => r.status === 201 || r.status === 200,
+          "write response time OK": r => r.timings.duration < 2000,
+        }) || errorRate.add(1);
+
+        // Test cleanup - delete old items periodically
+        if (__ITER % 50 === 0) {
+          const deleteResponse = http.del(`${BASE_URL}/api/items/old`, {
+            headers,
+            tags: { name: "DELETE old items", operation: "cleanup" },
+          });
+
+          check(deleteResponse, {
+            "cleanup successful": r => r.status === 200 || r.status === 204,
+          });
+        }
+      }
+    });
+
+    group("Complex Operations", () => {
+      // Simulate complex user workflows
+      if (__ITER % 5 === 0) {
+        // Every 5th iteration
+        const searchResponse = http.get(
+          `${BASE_URL}/api/search?q=test&limit=100`,
+          {
+            headers,
+            tags: { name: "Complex Search", operation: "search" },
+          }
+        );
+
+        check(searchResponse, {
+          "search completed": r => r.status === 200,
+          "search performance OK": r => r.timings.duration < 3000,
+        }) || errorRate.add(1);
+      }
+    });
+  });
+
+  // Track requests per minute
+  requestsPerMinute.add(1);
+
+  // Update performance history
+  const now = Date.now();
+  if (now - lastHistoryUpdate > historyInterval * 1000) {
+    performanceHistory.push({
+      timestamp: now,
+      avgResponseTime: memoryLeakIndicator.value,
+      errorRate: errorRate.value,
+    });
+    lastHistoryUpdate = now;
+  }
+
+  // Consistent pacing for soak test
+  const iterationDuration = Date.now() - iterationStart;
+  const targetPace = 1000; // 1 request per second per VU
+  const sleepTime = Math.max(0, targetPace - iterationDuration) / 1000;
+  sleep(sleepTime);
+}
+
+export function handleSummary(data) {
+  const { metrics } = data;
+  const duration = parseInt(__ENV.K6_DURATION || "30m");
+
+  const summary = {
+    timestamp: new Date().toISOString(),
+    test_type: "soak",
+    duration: __ENV.K6_DURATION || "30m",
+    total_requests: metrics.http_reqs?.values?.count || 0,
+    failed_requests: metrics.http_req_failed?.values?.passes || 0,
+    error_rate: metrics.errors?.values?.rate || 0,
+    performance: {
+      baseline_response_time: baselineResponseTime,
+      final_avg_response_time: Math.round(
+        metrics.http_req_duration?.values?.avg || 0
+      ),
+      p95_response_time: Math.round(
+        metrics.http_req_duration?.values["p(95)"] || 0
+      ),
+      p99_response_time: Math.round(
+        metrics.http_req_duration?.values["p(99)"] || 0
+      ),
+      degradation_percentage:
+        (metrics.degradation_rate?.values?.avg || 0) * 100,
+    },
+    resource_usage: {
+      requests_per_minute: Math.round(
+        (metrics.http_reqs?.values?.count || 0) / (duration / 60)
+      ),
+      avg_data_sent: Math.round(metrics.data_sent?.values?.avg || 0),
+      avg_data_received: Math.round(metrics.data_received?.values?.avg || 0),
+    },
+    stability: {
+      consistent_performance: metrics.degradation_rate?.values?.avg < 0.1,
+      low_error_rate: metrics.errors?.values?.rate < 0.02,
+      thresholds_passed: Object.entries(data.thresholds || {}).every(
+        ([, value]) => value.ok
+      ),
+    },
+    performance_history: performanceHistory,
+  };
+
+  return {
+    "k6-results/soak-summary.json": JSON.stringify(summary, null, 2),
+    stdout: createSoakSummary(summary),
+  };
+}
+
+function createSoakSummary(summary) {
+  let text = "\n=== Soak Test Summary ===\n\n";
+  text += `Test Duration: ${summary.duration}\n`;
+  text += `Timestamp: ${summary.timestamp}\n\n`;
+
+  text += "Overall Statistics:\n";
+  text += `  Total Requests: ${summary.total_requests}\n`;
+  text += `  Failed Requests: ${summary.failed_requests}\n`;
+  text += `  Error Rate: ${(summary.error_rate * 100).toFixed(2)}%\n\n`;
+
+  text += "Performance Analysis:\n";
+  text += `  Baseline Response Time: ${summary.performance.baseline_response_time}ms\n`;
+  text += `  Final Avg Response Time: ${summary.performance.final_avg_response_time}ms\n`;
+  text += `  95th Percentile: ${summary.performance.p95_response_time}ms\n`;
+  text += `  99th Percentile: ${summary.performance.p99_response_time}ms\n`;
+  text += `  Performance Degradation: ${summary.performance.degradation_percentage.toFixed(2)}%\n\n`;
+
+  text += "Resource Usage:\n";
+  text += `  Requests/Minute: ${summary.resource_usage.requests_per_minute}\n`;
+  text += `  Avg Data Sent: ${(summary.resource_usage.avg_data_sent / 1024).toFixed(2)} KB\n`;
+  text += `  Avg Data Received: ${(summary.resource_usage.avg_data_received / 1024).toFixed(2)} KB\n\n`;
+
+  text += "Stability Assessment:\n";
+  text += `  Consistent Performance: ${summary.stability.consistent_performance ? "✅ YES" : "❌ NO"}\n`;
+  text += `  Low Error Rate: ${summary.stability.low_error_rate ? "✅ YES" : "❌ NO"}\n`;
+  text += `  All Thresholds Passed: ${summary.stability.thresholds_passed ? "✅ YES" : "❌ NO"}\n`;
+
+  if (!summary.stability.consistent_performance) {
+    text +=
+      "\n⚠️  WARNING: Performance degradation detected over time. Possible memory leak or resource exhaustion.\n";
+  }
+
+  return text;
+}

package/typescript/copy-overwrite/.github/k6/scenarios/soak.json

@@ -0,0 +1,29 @@
+{
+  "name": "soak",
+  "description": "Extended duration test to identify memory leaks and performance degradation",
+  "executor": "constant-vus",
+  "vus": 10,
+  "duration": "30m",
+  "thresholds": {
+    "http_req_failed": ["rate<0.02"],
+    "http_req_duration": ["p(95)<1000", "p(99)<2000"],
+    "http_req_receiving": ["p(95)<500"],
+    "checks": ["rate>0.95"],
+    "iterations": ["count>1000"],
+    "vus": ["value==10"]
+  },
+  "env": {
+    "SCENARIO_NAME": "soak",
+    "SOAK_DURATION": "30m",
+    "MEMORY_CHECK_INTERVAL": "5m"
+  },
+  "tags": {
+    "test_type": "soak",
+    "environment": "${K6_ENVIRONMENT}",
+    "long_running": "true"
+  },
+  "notes": {
+    "monitoring": "Monitor memory usage, CPU, and response time trends over the duration",
+    "duration_override": "Can be extended to 1h, 2h, or 4h based on requirements"
+  }
+}

package/typescript/copy-overwrite/.github/k6/scenarios/spike.js

@@ -0,0 +1,180 @@
+import http from "k6/http";
+import { check, group, sleep } from "k6";
+import { Rate, Trend } from "k6/metrics";
+
+// Custom metrics
+const errorRate = new Rate("errors");
+const spikeResponseTime = new Trend("spike_response_time");
+const recoveryTime = new Trend("recovery_time");
+
+export const options = {
+  stages: [
+    { duration: "30s", target: 5 }, // Baseline load
+    { duration: "1m", target: 5 }, // Stay at baseline
+    { duration: "30s", target: 100 }, // Spike to 100 users
+    { duration: "3m", target: 100 }, // Stay at peak
+    { duration: "30s", target: 5 }, // Drop back to baseline
+    { duration: "2m", target: 5 }, // Recovery period
+    { duration: "30s", target: 0 }, // Ramp down
+  ],
+  thresholds: {
+    http_req_failed: ["rate<0.15"], // Higher tolerance during spikes
+    http_req_duration: ["p(95)<3000"], // 95% of requests under 3s
+    errors: ["rate<0.2"], // 20% error rate threshold
+    spike_response_time: ["p(95)<5000"], // Spike-specific metric
+  },
+};
+
+const BASE_URL = __ENV.K6_BASE_URL || "http://localhost:3000";
+const CUSTOM_HEADERS = __ENV.K6_CUSTOM_HEADERS
+  ? JSON.parse(__ENV.K6_CUSTOM_HEADERS)
+  : {};
+
+// Track test phases
+let currentPhase = "baseline";
+let phaseStartTime = Date.now();
+
+export default function () {
+  const headers = {
+    "Content-Type": "application/json",
+    ...CUSTOM_HEADERS,
+  };
+
+  // Determine current phase based on VU count
+  const vuCount = __VU;
+  let phase = "baseline";
+  if (vuCount > 50) phase = "spike";
+  else if (vuCount <= 10 && currentPhase === "spike") phase = "recovery";
+
+  if (phase !== currentPhase) {
+    const phaseDuration = Date.now() - phaseStartTime;
+    if (currentPhase === "spike") {
+      recoveryTime.add(phaseDuration);
+    }
+    currentPhase = phase;
+    phaseStartTime = Date.now();
+  }
+
+  group(`Spike Test - ${phase} phase`, () => {
+    // Critical user path that must handle spikes
+    const criticalResponse = http.get(`${BASE_URL}/api/critical-endpoint`, {
+      headers,
+      tags: { name: "CriticalPath", phase: phase },
+      timeout: "10s", // Longer timeout during spikes
+    });
+
+    const criticalCheck = check(criticalResponse, {
+      "critical path available": r => r.status === 200 || r.status === 503,
+      "response time acceptable": r =>
+        r.timings.duration < (phase === "spike" ? 5000 : 1000),
+    });
+
+    if (!criticalCheck) {
+      errorRate.add(1);
+    }
+
+    if (phase === "spike") {
+      spikeResponseTime.add(criticalResponse.timings.duration);
+    }
+
+    // Simulate various user behaviors during spike
+    if (Math.random() < 0.7) {
+      // 70% read operations
+      const readResponse = http.get(`${BASE_URL}/api/items`, {
+        headers,
+        tags: { name: "ReadOperation", phase: phase },
+      });
+
+      check(readResponse, {
+        "read operation successful": r => r.status === 200,
+      }) || errorRate.add(1);
+    } else {
+      // 30% write operations
+      const writePayload = JSON.stringify({
+        action: "spike_test",
+        timestamp: Date.now(),
+        phase: phase,
+        vu: __VU,
+      });
+
+      const writeResponse = http.post(`${BASE_URL}/api/items`, writePayload, {
+        headers,
+        tags: { name: "WriteOperation", phase: phase },
+      });
+
+      check(writeResponse, {
+        "write operation handled": r => [200, 201, 429, 503].includes(r.status),
+      }) || errorRate.add(1);
+    }
+  });
+
+  // Minimal sleep during spike phase, normal sleep otherwise
+  sleep(phase === "spike" ? 0.1 : 1);
+}
+
+export function handleSummary(data) {
+  const { metrics } = data;
+
+  const summary = {
+    timestamp: new Date().toISOString(),
+    test_type: "spike",
+    phases: {
+      baseline: {
+        avg_response_time: Math.round(
+          metrics.http_req_duration?.values?.avg || 0
+        ),
+        error_rate: metrics.errors?.values?.rate || 0,
+      },
+      spike: {
+        avg_response_time: Math.round(
+          metrics.spike_response_time?.values?.avg || 0
+        ),
+        p95_response_time: Math.round(
+          metrics.spike_response_time?.values["p(95)"] || 0
+        ),
+        max_response_time: Math.round(
+          metrics.spike_response_time?.values?.max || 0
+        ),
+        error_rate: metrics.errors?.values?.rate || 0,
+      },
+      recovery: {
+        time_to_normal: Math.round(metrics.recovery_time?.values?.avg || 0),
+      },
+    },
+    total_requests: metrics.http_reqs?.values?.count || 0,
+    failed_requests: metrics.http_req_failed?.values?.passes || 0,
+    thresholds_passed: Object.entries(data.thresholds || {}).every(
+      ([, value]) => value.ok
+    ),
+  };
+
+  return {
+    "k6-results/spike-summary.json": JSON.stringify(summary, null, 2),
+    stdout: createSpikeSummary(summary),
+  };
+}
+
+function createSpikeSummary(summary) {
+  let text = "\n=== Spike Test Summary ===\n\n";
+  text += `Timestamp: ${summary.timestamp}\n`;
+  text += `Total Requests: ${summary.total_requests}\n`;
+  text += `Failed Requests: ${summary.failed_requests}\n\n`;
+
+  text += "Phase Analysis:\n";
+  text += `  Baseline Phase:\n`;
+  text += `    - Avg Response Time: ${summary.phases.baseline.avg_response_time}ms\n`;
+  text += `    - Error Rate: ${(summary.phases.baseline.error_rate * 100).toFixed(2)}%\n`;
+
+  text += `  Spike Phase:\n`;
+  text += `    - Avg Response Time: ${summary.phases.spike.avg_response_time}ms\n`;
+  text += `    - 95th Percentile: ${summary.phases.spike.p95_response_time}ms\n`;
+  text += `    - Max Response Time: ${summary.phases.spike.max_response_time}ms\n`;
+  text += `    - Error Rate: ${(summary.phases.spike.error_rate * 100).toFixed(2)}%\n`;
+
+  text += `  Recovery Phase:\n`;
+  text += `    - Time to Normal: ${summary.phases.recovery.time_to_normal}ms\n\n`;
+
+  text += `All Thresholds Passed: ${summary.thresholds_passed ? "✅ YES" : "❌ NO"}\n`;
+
+  return text;
+}

package/typescript/copy-overwrite/.github/k6/scenarios/spike.json

@@ -0,0 +1,32 @@
+{
+  "name": "spike",
+  "description": "Test system's ability to handle sudden traffic spikes",
+  "executor": "ramping-vus",
+  "startVUs": 0,
+  "stages": [
+    { "duration": "30s", "target": 5 },
+    { "duration": "1m", "target": 5 },
+    { "duration": "30s", "target": 100 },
+    { "duration": "3m", "target": 100 },
+    { "duration": "30s", "target": 5 },
+    { "duration": "2m", "target": 5 },
+    { "duration": "30s", "target": 0 }
+  ],
+  "gracefulStop": "30s",
+  "thresholds": {
+    "http_req_failed": ["rate<0.15"],
+    "http_req_duration": ["p(95)<3000", "p(99)<10000"],
+    "http_req_receiving": ["p(95)<2000"],
+    "checks": ["rate>0.75"],
+    "http_req_waiting": ["p(95)<5000"]
+  },
+  "env": {
+    "SCENARIO_NAME": "spike",
+    "SPIKE_MULTIPLIER": "20",
+    "RECOVERY_TIME": "2m"
+  },
+  "tags": {
+    "test_type": "spike",
+    "environment": "${K6_ENVIRONMENT}"
+  }
+}

package/typescript/copy-overwrite/.github/k6/scenarios/stress.js

@@ -0,0 +1,206 @@
+import http from "k6/http";
+import { check, group, sleep } from "k6";
+import { Rate, Trend } from "k6/metrics";
+
+// Custom metrics
+const errorRate = new Rate("errors");
+const responseTime = new Trend("custom_response_time");
+const throughput = new Rate("throughput");
+
+export const options = {
+  stages: [
+    { duration: "2m", target: 10 }, // Warm up
+    { duration: "5m", target: 10 }, // Normal load
+    { duration: "2m", target: 20 }, // Increase to 20 users
+    { duration: "5m", target: 20 }, // Stay at 20 users
+    { duration: "2m", target: 30 }, // Increase to 30 users
+    { duration: "5m", target: 30 }, // Stay at 30 users
+    { duration: "5m", target: 0 }, // Ramp down
+  ],
+  thresholds: {
+    http_req_failed: [
+      {
+        threshold: "rate<0.1",
+        abortOnFail: true,
+        delayAbortEval: "30s",
+      },
+    ], // Abort if error rate > 10%
+    http_req_duration: ["p(95)<1000", "p(99)<2000"], // More relaxed for stress
+    errors: ["rate<0.15"], // Allow up to 15% errors under stress
+    throughput: ["rate>0.8"], // At least 80% of requests should complete
+  },
+};
+
+const BASE_URL = __ENV.K6_BASE_URL || "http://localhost:3000";
+const CUSTOM_HEADERS = __ENV.K6_CUSTOM_HEADERS
+  ? JSON.parse(__ENV.K6_CUSTOM_HEADERS)
+  : {};
+
+export default function () {
+  const headers = {
+    "Content-Type": "application/json",
+    ...CUSTOM_HEADERS,
+  };
+
+  // Stress test focuses on system behavior under high load
+  group("Concurrent API Calls", () => {
+    const batch = http.batch([
+      [
+        "GET",
+        `${BASE_URL}/api/items`,
+        null,
+        { headers, tags: { name: "BatchGet1" } },
+      ],
+      [
+        "GET",
+        `${BASE_URL}/api/items?page=2`,
+        null,
+        { headers, tags: { name: "BatchGet2" } },
+      ],
+      [
+        "GET",
+        `${BASE_URL}/api/status`,
+        null,
+        { headers, tags: { name: "BatchStatus" } },
+      ],
+    ]);
+
+    batch.forEach((response, index) => {
+      const isOk = check(response, {
+        "batch request succeeded": r => r.status === 200,
+      });
+
+      if (!isOk) {
+        errorRate.add(1);
+      } else {
+        throughput.add(1);
+      }
+
+      responseTime.add(response.timings.duration);
+    });
+  });
+
+  // Heavy operations
+  group("Resource Intensive Operations", () => {
+    // Simulate large payload
+    const largePayload = JSON.stringify({
+      data: Array(100)
+        .fill(null)
+        .map((_, i) => ({
+          id: i,
+          name: `Item ${i}`,
+          description:
+            "Lorem ipsum dolor sit amet, consectetur adipiscing elit".repeat(
+              10
+            ),
+          metadata: {
+            created: new Date().toISOString(),
+            tags: Array(20)
+              .fill(null)
+              .map((_, j) => `tag${j}`),
+          },
+        })),
+    });
+
+    const heavyResponse = http.post(
+      `${BASE_URL}/api/bulk-process`,
+      largePayload,
+      {
+        headers,
+        tags: { name: "HeavyOperation" },
+        timeout: "30s",
+      }
+    );
+
+    const heavyCheck = check(heavyResponse, {
+      "heavy operation completed": r => r.status === 200 || r.status === 202,
+      "heavy operation within timeout": r => r.timings.duration < 30000,
+    });
+
+    if (!heavyCheck) {
+      errorRate.add(1);
+    } else {
+      throughput.add(1);
+    }
+  });
+
+  // Rapid fire requests (no sleep)
+  group("Rapid Requests", () => {
+    for (let i = 0; i < 5; i++) {
+      const rapidResponse = http.get(
+        `${BASE_URL}/api/items/${Math.floor(Math.random() * 100)}`,
+        {
+          headers,
+          tags: { name: "RapidFire" },
+        }
+      );
+
+      check(rapidResponse, {
+        "rapid request handled": r => r.status === 200 || r.status === 404,
+      }) || errorRate.add(1);
+    }
+  });
+
+  // Minimal think time to maintain pressure
+  sleep(Math.random() * 0.5);
+}
+
+export function handleSummary(data) {
+  const { metrics } = data;
+
+  // Calculate stress test specific metrics
+  const totalRequests = metrics.http_reqs?.values?.count || 0;
+  const failedRequests = metrics.http_req_failed?.values?.passes || 0;
+  const errorPercentage =
+    totalRequests > 0 ? ((failedRequests / totalRequests) * 100).toFixed(2) : 0;
+
+  const summary = {
+    timestamp: new Date().toISOString(),
+    test_type: "stress",
+    total_requests: totalRequests,
+    failed_requests: failedRequests,
+    error_percentage: parseFloat(errorPercentage),
+    avg_response_time: Math.round(metrics.http_req_duration?.values?.avg || 0),
+    p95_response_time: Math.round(
+      metrics.http_req_duration?.values["p(95)"] || 0
+    ),
+    p99_response_time: Math.round(
+      metrics.http_req_duration?.values["p(99)"] || 0
+    ),
+    max_response_time: Math.round(metrics.http_req_duration?.values?.max || 0),
+    custom_metrics: {
+      error_rate: metrics.errors?.values?.rate || 0,
+      throughput_rate: metrics.throughput?.values?.rate || 0,
+      avg_custom_response_time: Math.round(
+        metrics.custom_response_time?.values?.avg || 0
+      ),
+    },
+    thresholds_passed: Object.entries(data.thresholds || {}).every(
+      ([, value]) => value.ok
+    ),
+  };
+
+  return {
+    "k6-results/stress-summary.json": JSON.stringify(summary, null, 2),
+    stdout: createTextSummary(summary),
+  };
+}
+
+function createTextSummary(summary) {
+  let text = "\n=== Stress Test Summary ===\n\n";
+  text += `Test Type: ${summary.test_type}\n`;
+  text += `Timestamp: ${summary.timestamp}\n\n`;
+  text += `Total Requests: ${summary.total_requests}\n`;
+  text += `Failed Requests: ${summary.failed_requests} (${summary.error_percentage}%)\n`;
+  text += `Average Response Time: ${summary.avg_response_time}ms\n`;
+  text += `95th Percentile: ${summary.p95_response_time}ms\n`;
+  text += `99th Percentile: ${summary.p99_response_time}ms\n`;
+  text += `Max Response Time: ${summary.max_response_time}ms\n\n`;
+  text += `Custom Metrics:\n`;
+  text += `  Error Rate: ${(summary.custom_metrics.error_rate * 100).toFixed(2)}%\n`;
+  text += `  Throughput Rate: ${(summary.custom_metrics.throughput_rate * 100).toFixed(2)}%\n`;
+  text += `  Avg Custom Response Time: ${summary.custom_metrics.avg_custom_response_time}ms\n\n`;
+  text += `All Thresholds Passed: ${summary.thresholds_passed ? "✅ YES" : "❌ NO"}\n`;
+
+  return text;
+}