agent-master-devsecops 3.9.0 → 5.1.0

package/scripts/mcp/handlers/sre_handlers.js

@@ -0,0 +1,443 @@
+/**
+ * scripts/mcp/handlers/sre_handlers.js
+ * 
+ * SRE, Observability & Resiliency MCP Handlers.
+ * Despacha chamadas JSON-RPC 2.0 para telemetria OpenTelemetry (W3C TraceContext),
+ * benchmarks de performance e regressão, auto-remediação de processos/heap,
+ * e roteamento resiliente com Circuit Breaker multi-provedor (Princípio 6).
+ * 
+ * Versão: 5.1.0 Enterprise
+ */
+
+'use strict';
+
+const { createSarifReport } = require('../../core/sarif_engine.js');
+
+let _sreEngineInstance = null;
+function getSreEngine() {
+  if (!_sreEngineInstance) {
+    const { SreRemediationEngine } = require('../../core/sre_remediation_engine.js');
+    _sreEngineInstance = new SreRemediationEngine();
+  }
+  return _sreEngineInstance;
+}
+
+let _routerInstance = null;
+function getCircuitBreakerRouter(options = {}) {
+  if (!_routerInstance) {
+    const { MultiProviderRouter } = require('../../core/circuit_breaker.js');
+    const failureThreshold = options.failureThreshold || 3;
+    _routerInstance = new MultiProviderRouter(['anthropic', 'openai', 'groq', 'ollama'], { failureThreshold });
+  }
+  return _routerInstance;
+}
+
+/**
+ * Helpers funcionais puros para construção determinística de respostas JSON-RPC 2.0 (DRY)
+ */
+function buildSuccessResponse(id, data) {
+  const textContent = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
+  return {
+    jsonrpc: '2.0',
+    id,
+    result: {
+      content: [
+        {
+          type: 'text',
+          text: textContent
+        }
+      ]
+    }
+  };
+}
+
+function buildErrorResponse(id, code, message, data = null) {
+  const errObj = { code, message };
+  if (data) errObj.data = data;
+  return {
+    jsonrpc: '2.0',
+    id,
+    error: errObj
+  };
+}
+
+/**
+ * 1. Telemetria OpenTelemetry & Flamegraph W3C (agent_otel_trace)
+ */
+function handleOtelTrace(id, args) {
+  try {
+    const safeArgs = args && typeof args === 'object' ? args : {};
+    const { Tracer } = require('../../core/otel_tracer.js');
+    const serviceName = safeArgs.serviceName || 'agent-service';
+    const thresholdMs = Number(safeArgs.thresholdMs) || 50;
+    const format = safeArgs.format || 'json';
+    const tracer = new Tracer(serviceName);
+
+    const inputSpans = Array.isArray(safeArgs.spans) && safeArgs.spans.length > 0
+      ? safeArgs.spans
+      : [
+          { name: 'op_request', durationMs: 15 },
+          { name: 'llm_inference', durationMs: 70 },
+          { name: 'response_formatting', durationMs: 10 }
+        ];
+
+    let runningOffset = Date.now();
+    let rootSpan = null;
+
+    inputSpans.forEach((s, idx) => {
+      const dur = Math.max(1, Number(s.durationMs) || 10);
+      const span = tracer.startSpan(s.name, {
+        startTime: runningOffset,
+        parentSpanId: idx > 0 && rootSpan ? rootSpan.spanId : null,
+        attributes: s.attributes || {}
+      });
+      span.end(runningOffset + dur);
+      if (idx === 0) rootSpan = span;
+      runningOffset += dur;
+    });
+
+    const bottlenecks = tracer.analyzeBottlenecks(thresholdMs);
+    const flamegraph = tracer.renderFlamegraphAscii();
+    const traceContext = tracer.getTraceContext(rootSpan);
+
+    if (format === 'sarif') {
+      const findings = bottlenecks.map(b => ({
+        ruleId: 'RULE-PERF-001',
+        severity: 'MEDIUM',
+        filename: 'traces/opentelemetry.log',
+        line: 1,
+        column: 1,
+        snippet: `Span: ${b.name} (${b.durationMs}ms)`,
+        message: `Gargalo de latência detectado: o span '${b.name}' durou ${b.durationMs}ms (limiar: ${thresholdMs}ms).`,
+        remediation: 'Otimizar o processamento assíncrono ou chavear para modelo/operação de menor latência.'
+      }));
+
+      const sarif = createSarifReport({
+        toolName: 'agent-master-otel-tracer',
+        toolVersion: '5.1.0',
+        findings,
+        properties: {
+          traceId: traceContext.traceId,
+          traceparent: traceContext.traceparent,
+          serviceName,
+          totalSpans: tracer.spans.length,
+          bottlenecksCount: bottlenecks.length
+        }
+      });
+      return buildSuccessResponse(id, sarif);
+    }
+
+    return buildSuccessResponse(id, {
+      traceId: traceContext.traceId,
+      traceparent: traceContext.traceparent,
+      serviceName,
+      totalSpans: tracer.spans.length,
+      gargalosDetectados: bottlenecks,
+      flamegraph
+    });
+  } catch (err) {
+    return buildErrorResponse(id, -32603, `Falha em handleOtelTrace: ${err.message}`);
+  }
+}
+
+/**
+ * 2. Benchmark de Performance & Comparação contra Baseline (agent_perf_benchmark)
+ */
+function handlePerfBenchmark(id, args) {
+  try {
+    const safeArgs = args && typeof args === 'object' ? args : {};
+    const { runBenchmark, comparePerformance, formatPerfReport, getOrInitBaseline } = require('../../core/perf_benchmark.js');
+    const iterations = Number(safeArgs.iterations) || 50;
+    const maxDegradationPct = Number(safeArgs.maxDegradationPct) || 15;
+    const format = safeArgs.format || 'json';
+
+    const baseline = getOrInitBaseline();
+    const current = runBenchmark(iterations);
+    const comparison = comparePerformance(current, baseline, maxDegradationPct);
+    const report = formatPerfReport(comparison);
+
+    if (format === 'sarif') {
+      const findings = [];
+      if (!comparison.passed) {
+        findings.push({
+          ruleId: 'RULE-PERF-002',
+          severity: 'HIGH',
+          filename: 'perf/benchmark.json',
+          line: 1,
+          column: 1,
+          snippet: `Degradação: +${comparison.deltas.latencyDeltaPct}%`,
+          message: `Regressão de performance detectada: latência degradou em ${comparison.deltas.latencyDeltaPct}% (limite: ${maxDegradationPct}%).`,
+          remediation: 'Investigar hotspots de CPU/memória e reverter alterações que introduziram complexidade ciclomática elevada.'
+        });
+      }
+
+      const sarif = createSarifReport({
+        toolName: 'agent-master-perf-benchmark',
+        toolVersion: '5.1.0',
+        findings,
+        properties: {
+          verdict: comparison.verdict,
+          passed: comparison.passed,
+          deltas: comparison.deltas,
+          iterations
+        }
+      });
+      return buildSuccessResponse(id, sarif);
+    }
+
+    return buildSuccessResponse(id, {
+      veredito: comparison.verdict,
+      passou: comparison.passed,
+      metricas: current,
+      deltas: comparison.deltas,
+      relatorio: report
+    });
+  } catch (err) {
+    return buildErrorResponse(id, -32603, `Falha em handlePerfBenchmark: ${err.message}`);
+  }
+}
+
+/**
+ * 3. Gerenciamento do Circuit Breaker Multi-Provedor LLM (agent_circuit_breaker)
+ */
+function handleCircuitBreaker(id, args) {
+  try {
+    const safeArgs = args && typeof args === 'object' ? args : {};
+    const action = safeArgs.action || 'status';
+    const failureThreshold = Number(safeArgs.failureThreshold) || 3;
+    const format = safeArgs.format || 'json';
+    const router = getCircuitBreakerRouter({ failureThreshold });
+
+    let responseData;
+
+    if (action === 'reset') {
+      router.resetAll();
+      responseData = {
+        status: 'SUCCESS',
+        action: 'reset',
+        circuitStates: router.getAllStatuses()
+      };
+    } else if (action === 'simulate_failover') {
+      const taskMap = {
+        anthropic: () => { throw new Error('HTTP 429: Too Many Requests (Rate limit)'); },
+        openai: () => { throw new Error('HTTP 503: Service Unavailable'); },
+        groq: () => 'Resposta gerada com sucesso via Groq (Llama 3.3 70B)',
+        ollama: () => 'Resposta via Ollama local'
+      };
+
+      const dispatchRes = router.dispatchSync(taskMap);
+      responseData = {
+        status: 'SUCCESS',
+        action: 'simulate_failover',
+        dispatchResult: dispatchRes
+      };
+    } else {
+      // Default: 'status'
+      responseData = {
+        status: 'SUCCESS',
+        action: 'status',
+        circuitStates: router.getAllStatuses()
+      };
+    }
+
+    if (format === 'sarif') {
+      const statuses = router.getAllStatuses();
+      const findings = [];
+
+      for (const [provider, st] of Object.entries(statuses)) {
+        if (st.state === 'OPEN') {
+          findings.push({
+            ruleId: 'RULE-CIRCUIT-OPEN',
+            severity: 'HIGH',
+            filename: 'circuit_breaker.json',
+            line: 1,
+            column: 1,
+            snippet: `Provedor: ${provider} (State: OPEN)`,
+            message: `Circuito para '${provider}' está ABERTO devido a falhas consecutivas (${st.consecutiveFailures}).`,
+            remediation: 'Verificar status da API remota, rate limits ou executar reset via action: reset.'
+          });
+        }
+      }
+
+      const sarif = createSarifReport({
+        toolName: 'agent-master-circuit-breaker',
+        toolVersion: '5.1.0',
+        findings,
+        properties: {
+          action,
+          statuses
+        }
+      });
+      return buildSuccessResponse(id, sarif);
+    }
+
+    return buildSuccessResponse(id, responseData);
+  } catch (err) {
+    return buildErrorResponse(id, -32603, `Falha em handleCircuitBreaker: ${err.message}`);
+  }
+}
+
+/**
+ * 4. Telemetria de Processo & Métricas Prometheus (agent_sre_telemetry)
+ */
+function handleSreTelemetry(id, args) {
+  try {
+    const safeArgs = args && typeof args === 'object' ? args : {};
+    const engine = getSreEngine();
+    const format = safeArgs.format || 'json';
+    const evaluateAlerts = safeArgs.evaluateAlerts;
+
+    if (format === 'prometheus') {
+      const prometheusData = engine.getPrometheusFormat();
+      return buildSuccessResponse(id, prometheusData);
+    }
+
+    const summary = engine.getMetricsSummary();
+    const alertsEvaluation = evaluateAlerts ? engine.evaluateAlerts() : undefined;
+
+    const responseData = {
+      summary,
+      ...(alertsEvaluation ? { alertsEvaluation } : {})
+    };
+
+    if (format === 'sarif') {
+      const evalResult = typeof engine.evaluateAlerts === 'function' ? engine.evaluateAlerts() : {};
+      const alerts = Array.isArray(evalResult.alerts) ? evalResult.alerts : [];
+      const findings = alerts.map(a => ({
+        ruleId: 'RULE-SRE-001',
+        severity: a.severity === 'CRITICAL' ? 'CRITICAL' : 'HIGH',
+        filename: 'metrics/sre.prom',
+        line: 1,
+        column: 1,
+        snippet: `Métrica: ${a.metric} (Valor: ${a.currentValue !== undefined ? a.currentValue : a.value})`,
+        message: a.message || `Alerta disparado para ${a.metric}`,
+        remediation: 'Executar agent_sre_remediate ou liberar heap não utilizado.'
+      }));
+
+      const sarif = createSarifReport({
+        toolName: 'agent-master-sre-telemetry',
+        toolVersion: '5.1.0',
+        findings,
+        properties: {
+          metricsSummary: summary,
+          alertsCount: alerts.length
+        }
+      });
+      return buildSuccessResponse(id, sarif);
+    }
+
+    return buildSuccessResponse(id, responseData);
+  } catch (err) {
+    return buildErrorResponse(id, -32603, `Falha em handleSreTelemetry: ${err.message}`);
+  }
+}
+
+/**
+ * 5. Auto-Cura SRE & Gestão de Ciclo de Vida de Memória (agent_sre_remediate)
+ */
+function handleSreRemediate(id, args) {
+  try {
+    const safeArgs = args && typeof args === 'object' ? args : {};
+    const engine = getSreEngine();
+    const action = safeArgs.action;
+    const context = safeArgs.context || {};
+    const format = safeArgs.format || 'json';
+
+    const remediationRecord = engine.executeRemediation(action, context);
+
+    if (format === 'sarif') {
+      const sarif = createSarifReport({
+        toolName: 'agent-master-sre-remediation',
+        toolVersion: '5.1.0',
+        findings: [],
+        properties: {
+          status: 'SUCCESS',
+          action: remediationRecord.action,
+          remediationStatus: remediationRecord.status,
+          details: remediationRecord.details
+        }
+      });
+      return buildSuccessResponse(id, sarif);
+    }
+
+    return buildSuccessResponse(id, {
+      status: 'SUCCESS',
+      remediationRecord
+    });
+  } catch (err) {
+    return buildErrorResponse(id, -32603, `Falha em handleSreRemediate: ${err.message}`);
+  }
+}
+
+/**
+ * Classe Canônica SreHandlers
+ * Fornece API orientada a objetos com suporte a métodos estáticos e de instância.
+ */
+class SreHandlers {
+  static buildSuccessResponse(id, data) {
+    return buildSuccessResponse(id, data);
+  }
+
+  static buildErrorResponse(id, code, message, data = null) {
+    return buildErrorResponse(id, code, message, data);
+  }
+
+  static handleOtelTrace(id, args) {
+    return handleOtelTrace(id, args);
+  }
+
+  static handlePerfBenchmark(id, args) {
+    return handlePerfBenchmark(id, args);
+  }
+
+  static handleCircuitBreaker(id, args) {
+    return handleCircuitBreaker(id, args);
+  }
+
+  static handleSreTelemetry(id, args) {
+    return handleSreTelemetry(id, args);
+  }
+
+  static handleSreRemediate(id, args) {
+    return handleSreRemediate(id, args);
+  }
+
+  buildSuccessResponse(id, data) {
+    return SreHandlers.buildSuccessResponse(id, data);
+  }
+
+  buildErrorResponse(id, code, message, data = null) {
+    return SreHandlers.buildErrorResponse(id, code, message, data);
+  }
+
+  handleOtelTrace(id, args) {
+    return SreHandlers.handleOtelTrace(id, args);
+  }
+
+  handlePerfBenchmark(id, args) {
+    return SreHandlers.handlePerfBenchmark(id, args);
+  }
+
+  handleCircuitBreaker(id, args) {
+    return SreHandlers.handleCircuitBreaker(id, args);
+  }
+
+  handleSreTelemetry(id, args) {
+    return SreHandlers.handleSreTelemetry(id, args);
+  }
+
+  handleSreRemediate(id, args) {
+    return SreHandlers.handleSreRemediate(id, args);
+  }
+}
+
+module.exports = {
+  SreHandlers,
+  buildSuccessResponse,
+  buildErrorResponse,
+  handleOtelTrace,
+  handlePerfBenchmark,
+  handleCircuitBreaker,
+  handleSreTelemetry,
+  handleSreRemediate
+};