agent-master-devsecops 0.0.0-stage → 5.1.0

package/scripts/core/otel_tracer.js

@@ -0,0 +1,335 @@
+#!/usr/bin/env node
+/**
+ * scripts/otel_tracer.js
+ * 
+ * Tracer Distribuído OpenTelemetry Nativo (AGDEV-24 / I-8).
+ * Suporte a W3C TraceContext (traceparent), hierarquia de spans (parent-child),
+ * exportação OTLP JSON e renderização de flamegraphs para playbooks de SRE.
+ */
+
+const crypto = require('crypto');
+const { version: PKG_VERSION } = require('../../package.json');
+const { createSarifReport } = require('./sarif_engine.js');
+
+function getOfficialOtelApi() {
+  try {
+    return require('@opentelemetry/api');
+  } catch (_) {
+    return null;
+  }
+}
+
+function isOfficialOtelApiAvailable() {
+  return getOfficialOtelApi() !== null;
+}
+
+function generateTraceId() {
+  return crypto.randomBytes(16).toString('hex');
+}
+
+function generateSpanId() {
+  return crypto.randomBytes(8).toString('hex');
+}
+
+function formatTraceparent(traceId, spanId, sampled = true) {
+  const flags = sampled ? '01' : '00';
+  return `00-${traceId}-${spanId}-${flags}`;
+}
+
+function parseTraceparent(traceparent) {
+  if (!traceparent || typeof traceparent !== 'string') return null;
+  const parts = traceparent.split('-');
+  if (parts.length !== 4) return null;
+  return {
+    version: parts[0],
+    traceId: parts[1],
+    spanId: parts[2],
+    flags: parts[3],
+    sampled: parts[3] === '01'
+  };
+}
+
+class Span {
+  constructor(name, tracer, options = {}) {
+    this.name = name;
+    this.tracer = tracer;
+    this.traceId = options.traceId || tracer.traceId;
+    this.spanId = generateSpanId();
+    this.parentSpanId = options.parentSpanId || null;
+    this.startTime = options.startTime || Date.now();
+    this.endTime = null;
+    this.durationMs = 0;
+    this.attributes = Object.assign({}, options.attributes || {});
+    this.events = [];
+    this.status = { code: 'UNSET' };
+  }
+
+  setAttribute(key, value) {
+    this.attributes[key] = value;
+    return this;
+  }
+
+  addEvent(name, attributes = {}) {
+    this.events.push({
+      name,
+      time: Date.now(),
+      attributes
+    });
+    return this;
+  }
+
+  setStatus(code, message = '') {
+    this.status = { code, message };
+    return this;
+  }
+
+  end(endTime = Date.now()) {
+    this.endTime = endTime;
+    this.durationMs = Math.max(0, this.endTime - this.startTime);
+    this.tracer._recordSpan(this);
+    return this;
+  }
+}
+
+class Tracer {
+  constructor(serviceName, options = {}) {
+    this.serviceName = serviceName;
+    this.traceId = options.traceId || generateTraceId();
+    this.spans = [];
+  }
+
+  startSpan(name, options = {}) {
+    return new Span(name, this, options);
+  }
+
+  _recordSpan(span) {
+    this.spans.push(span);
+  }
+
+  getTraceContext(activeSpan = null) {
+    const spanId = activeSpan ? activeSpan.spanId : (this.spans[0] ? this.spans[0].spanId : generateSpanId());
+    return {
+      traceId: this.traceId,
+      spanId,
+      traceparent: formatTraceparent(this.traceId, spanId)
+    };
+  }
+
+  analyzeBottlenecks(thresholdMs = 50) {
+    const bottlenecks = [];
+    const totalDuration = this.spans.reduce((max, s) => Math.max(max, (s.endTime || s.startTime) - this.spans[0].startTime), 0) || 1;
+
+    for (const span of this.spans) {
+      const percentage = Math.round((span.durationMs / totalDuration) * 100);
+      if (span.durationMs >= thresholdMs || percentage >= 40) {
+        bottlenecks.push({
+          name: span.name,
+          durationMs: span.durationMs,
+          percentageTotal: percentage,
+          severity: percentage >= 70 ? 'CRÍTICA' : (percentage >= 40 ? 'ALTA' : 'MÉDIA'),
+          spanId: span.spanId
+        });
+      }
+    }
+
+    return bottlenecks;
+  }
+
+  renderFlamegraphAscii() {
+    if (this.spans.length === 0) return 'Trace vazio.';
+
+    const sorted = [...this.spans].sort((a, b) => a.startTime - b.startTime);
+    const traceStart = sorted[0].startTime;
+    const traceEnd = Math.max(...sorted.map(s => s.endTime || s.startTime));
+    const totalDuration = Math.max(1, traceEnd - traceStart);
+
+    let ascii = `=== FLAMEGRAPH DISTRIBUÍDO [Trace: ${this.traceId}] (${totalDuration}ms) ===\n`;
+
+    sorted.forEach((span, index) => {
+      const offsetMs = span.startTime - traceStart;
+      const offsetChars = Math.floor((offsetMs / totalDuration) * 30);
+      const barLength = Math.max(1, Math.floor((span.durationMs / totalDuration) * 40));
+      const indent = ' '.repeat(offsetChars);
+      const bar = '█'.repeat(barLength);
+
+      ascii += `[${String(index + 1).padStart(2, '0')}] ${indent}${bar} ${span.name} (${span.durationMs}ms)\n`;
+    });
+
+    return ascii;
+  }
+
+  exportOtlpJson() {
+    return {
+      resourceSpans: [
+        {
+          resource: {
+            attributes: [
+              { key: 'service.name', value: { stringValue: this.serviceName } }
+            ]
+          },
+          scopeSpans: [
+            {
+              scope: { name: 'agent-master-devsecops-tracer', version: PKG_VERSION },
+              spans: this.spans.map(s => ({
+                traceId: s.traceId,
+                spanId: s.spanId,
+                parentSpanId: s.parentSpanId,
+                name: s.name,
+                startTimeUnixNano: String(s.startTime * 1000000),
+                endTimeUnixNano: String((s.endTime || s.startTime) * 1000000),
+                attributes: Object.entries(s.attributes).map(([k, v]) => ({
+                  key: k,
+                  value: { stringValue: String(v) }
+                })),
+                status: s.status
+              }))
+            }
+          ]
+        }
+      ]
+    };
+  }
+
+  async sendToOtlpEndpoint(endpointUrl, options = {}) {
+    const payload = JSON.stringify(this.exportOtlpJson());
+    const parsedUrl = new URL(endpointUrl);
+    const transport = parsedUrl.protocol === 'https:' ? require('node:https') : require('node:http');
+    const timeoutMs = options.timeoutMs || 5000;
+    const customHeaders = options.headers || {};
+
+    return new Promise((resolve, reject) => {
+      const req = transport.request(parsedUrl, {
+        method: 'POST',
+        headers: Object.assign({
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(payload),
+          'User-Agent': `agent-master-otel-tracer/${PKG_VERSION}`
+        }, customHeaders),
+        timeout: timeoutMs
+      }, (res) => {
+        let responseBody = '';
+        res.setEncoding('utf8');
+        res.on('data', chunk => { responseBody += chunk; });
+        res.on('end', () => {
+          const success = res.statusCode >= 200 && res.statusCode < 300;
+          resolve({
+            success,
+            statusCode: res.statusCode,
+            statusMessage: res.statusMessage,
+            body: responseBody
+          });
+        });
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error(`Timeout ao exportar spans para OTLP endpoint: ${endpointUrl} (${timeoutMs}ms)`));
+      });
+
+      req.on('error', (err) => {
+        reject(new Error(`Falha de conexão ao exportar OTLP para ${endpointUrl}: ${err.message}`));
+      });
+
+      req.write(payload);
+      req.end();
+    });
+  }
+
+  auditToSarif(bottleneckThresholdMs = 50) {
+    const bottlenecks = this.analyzeBottlenecks(bottleneckThresholdMs);
+    const findings = [];
+
+    for (const b of bottlenecks) {
+      findings.push({
+        ruleId: 'RULE-TRACE-001',
+        name: 'DistributedSpanBottleneck',
+        severity: 'WARNING',
+        message: `Span [${b.name}] consumiu ${b.durationMs}ms (${b.pctOfTotalTrace}% do trace total), excedendo o limiar de ${bottleneckThresholdMs}ms.`,
+        remediation: 'Otimize chamadas concorrentes ou adicione cache em operações I/O pesadas.'
+      });
+    }
+
+    return createSarifReport({
+      toolName: 'agent-master-otel-tracer',
+      rules: [
+        {
+          id: 'RULE-TRACE-001',
+          name: 'DistributedSpanBottleneck',
+          description: 'Identifica spans distribuídos que excedem o tempo de resposta aceitável',
+          severity: 'MEDIUM',
+          cwe: 'CWE-400'
+        }
+      ],
+      findings,
+      properties: {
+        serviceName: this.serviceName,
+        totalSpans: this.spans.length,
+        bottlenecksCount: bottlenecks.length
+      }
+    });
+  }
+
+  formatReport() {
+    return [
+      `### Relatório de Rastreabilidade Distribuída (OpenTelemetry)`,
+      `- **Serviço:** \`${this.serviceName}\``,
+      `- **Spans Registrados:** ${this.spans.length}`,
+      '```text',
+      this.renderFlamegraphAscii(),
+      '```'
+    ].join('\n');
+  }
+}
+
+
+function simulateMultiAgentTrace(serviceName = 'agent-pipeline') {
+  const tracer = new Tracer(serviceName);
+
+  // 1. Root span: Requisição do Usuário
+  const root = tracer.startSpan('user_goal_execution').setAttribute('agent.role', 'Orchestrator');
+  
+  // 2. Sub-span: Arquiteto planeja
+  const planSpan = tracer.startSpan('architect_plan', { parentSpanId: root.spanId })
+    .setAttribute('agent.role', 'Arquiteto')
+    .setAttribute('model', 'Claude 3.5 Sonnet');
+  // Simula 25ms
+  planSpan.end(planSpan.startTime + 25);
+
+  // 3. Sub-span: DevSecOps implementa
+  const devSpan = tracer.startSpan('devsecops_implementation', { parentSpanId: root.spanId })
+    .setAttribute('agent.role', 'DevSecOps Lead');
+  devSpan.end(devSpan.startTime + 60);
+
+  // 4. Sub-span: QA audita
+  const revSpan = tracer.startSpan('qa_audit', { parentSpanId: root.spanId })
+    .setAttribute('agent.role', 'QA Independente');
+  revSpan.end(revSpan.startTime + 15);
+
+  // 5. Finaliza root span
+  root.end(root.startTime + 105);
+
+  return tracer;
+}
+
+async function runCli() {
+  const tracer = simulateMultiAgentTrace();
+  console.log(tracer.renderFlamegraphAscii());
+  console.log('\nGargalos Identificados (Threshold 30ms):');
+  console.log(JSON.stringify(tracer.analyzeBottlenecks(30), null, 2));
+}
+
+if (require.main === module) {
+  runCli().catch(console.error);
+}
+
+module.exports = {
+  generateTraceId,
+  generateSpanId,
+  formatTraceparent,
+  parseTraceparent,
+  Span,
+  Tracer,
+  simulateMultiAgentTrace,
+  getOfficialOtelApi,
+  isOfficialOtelApiAvailable
+};

package/scripts/core/perf_benchmark.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+/**
+ * scripts/perf_benchmark.js
+ * 
+ * Scanner de Regressão de Performance em CI (AGDEV-25 / I-9).
+ * Executa micro-benchmarks comparativos de latência e consumo de RAM/Heap,
+ * detectando e bloqueando regressões superiores a 10% em relação ao baseline de referência.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { createSarifReport } = require('./sarif_engine.js');
+
+const ROOT_DIR = path.resolve(__dirname, '../..');
+const BASELINE_FILE = path.join(ROOT_DIR, 'benchmarks', 'baseline.json');
+
+function runBenchmark(iterations = 100) {
+  const { processMessage } = require('../mcp_server.js');
+  const { generateCompactPrompt } = require('./context_compressor.js');
+
+  const startMem = process.memoryUsage();
+  const startTime = process.hrtime.bigint();
+
+  // Benchmark 1: Processamento de JSON-RPC Initialize e Tools List
+  for (let i = 0; i < iterations; i++) {
+    processMessage({ jsonrpc: '2.0', id: i, method: 'tools/list' });
+    processMessage({ jsonrpc: '2.0', id: i, method: 'tools/call', params: { name: 'agent_full_dev_status', arguments: {} } });
+  }
+
+  // Benchmark 2: Compactação Semântica de Prompt
+  for (let i = 0; i < Math.floor(iterations / 2); i++) {
+    generateCompactPrompt();
+  }
+
+  const endTime = process.hrtime.bigint();
+  const endMem = process.memoryUsage();
+
+  const durationNs = Number(endTime - startTime);
+  const durationMs = durationNs / 1000000;
+  const avgLatencyUs = Math.round((durationNs / (iterations * 2)) / 1000);
+  const heapUsedMb = Math.round((endMem.heapUsed / (1024 * 1024)) * 100) / 100;
+  const opsPerSec = Math.round(((iterations * 2.5) / (durationMs / 1000)));
+
+  return {
+    iterations,
+    totalDurationMs: Math.round(durationMs * 100) / 100,
+    avgLatencyUs,
+    opsPerSec,
+    heapUsedMb
+  };
+}
+
+function comparePerformance(current, baseline, maxDegradationPct = 10) {
+  const latencyDeltaPct = Math.round(((current.avgLatencyUs - baseline.avgLatencyUs) / baseline.avgLatencyUs) * 100);
+  const memoryDeltaPct = Math.round(((current.heapUsedMb - baseline.heapUsedMb) / (baseline.heapUsedMb || 1)) * 100);
+
+  const hasLatencyRegression = latencyDeltaPct > maxDegradationPct;
+  const hasMemoryRegression = memoryDeltaPct > (maxDegradationPct * 2); // 20% tolerância para GC jitter
+  const passed = !hasLatencyRegression && !hasMemoryRegression;
+
+  return {
+    passed,
+    verdict: passed ? 'APROVADO' : 'REGRESSÃO_DETECTADA',
+    thresholdPct: maxDegradationPct,
+    current,
+    baseline,
+    deltas: {
+      latencyDeltaPct,
+      memoryDeltaPct
+    }
+  };
+}
+
+function formatPerfReport(comparison) {
+  let report = '================================================================================\n';
+  report += `RELATÓRIO DE PERFORMANCE & REGRESSÃO DE CI: [ ${comparison.verdict} ]\n`;
+  report += '================================================================================\n\n';
+
+  report += `Limiar Máximo de Degradação Permitido: ${comparison.thresholdPct}%\n\n`;
+
+  report += 'MÉTRICAS COMPARATIVAS:\n';
+  report += `- Latência Média por Operação: ${comparison.current.avgLatencyUs}µs (Baseline: ${comparison.baseline.avgLatencyUs}µs) -> Variação: ${comparison.deltas.latencyDeltaPct > 0 ? '+' : ''}${comparison.deltas.latencyDeltaPct}%\n`;
+  report += `- Throughput (Ops/sec): ${comparison.current.opsPerSec} ops/s (Baseline: ${comparison.baseline.opsPerSec} ops/s)\n`;
+  report += `- Memória Heap Utilizada: ${comparison.current.heapUsedMb} MB (Baseline: ${comparison.baseline.heapUsedMb} MB) -> Variação: ${comparison.deltas.memoryDeltaPct > 0 ? '+' : ''}${comparison.deltas.memoryDeltaPct}%\n\n`;
+
+  if (comparison.passed) {
+    report += 'STATUS: Nenhuma degradação crítica detectada. Aprovado para merge na esteira de CI.\n';
+  } else {
+    report += 'ALERTA SRE: Regressão superior a 10% identificada! Merge bloqueado conforme política DevSecOps.\n';
+  }
+
+  report += '================================================================================\n';
+  return report;
+}
+
+function getOrInitBaseline() {
+  const benchDir = path.dirname(BASELINE_FILE);
+  if (!fs.existsSync(benchDir)) {
+    fs.mkdirSync(benchDir, { recursive: true });
+  }
+
+  if (fs.existsSync(BASELINE_FILE)) {
+    try {
+      return JSON.parse(fs.readFileSync(BASELINE_FILE, 'utf8'));
+    } catch (err) {
+      void err;
+    }
+  }
+
+  // Baseline padrão de referência calibrado para Node.js 22
+  const initialBaseline = {
+    iterations: 100,
+    totalDurationMs: 15.0,
+    avgLatencyUs: 60,
+    opsPerSec: 15000,
+    heapUsedMb: 18.5
+  };
+
+  fs.writeFileSync(BASELINE_FILE, JSON.stringify(initialBaseline, null, 2), 'utf8');
+  return initialBaseline;
+}
+
+async function runCli() {
+  const args = process.argv.slice(2);
+  const baseline = getOrInitBaseline();
+  const current = runBenchmark(100);
+
+  if (args.includes('--save-baseline')) {
+    fs.writeFileSync(BASELINE_FILE, JSON.stringify(current, null, 2), 'utf8');
+    console.log(`[Perf Scanner] Novo baseline salvo com sucesso em ${BASELINE_FILE}`);
+    return;
+  }
+
+  const comparison = comparePerformance(current, baseline, 15);
+  const report = formatPerfReport(comparison);
+  console.log(report);
+
+  if (args.includes('--strict') && !comparison.passed) {
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  runCli().catch(err => {
+    console.error(err);
+    process.exit(1);
+  });
+}
+
+function auditToSarif(iterations = 50, thresholdPct = 15) {
+  const baseline = getOrInitBaseline();
+  const current = runBenchmark(iterations);
+  const comparison = comparePerformance(current, baseline, thresholdPct);
+  const findings = [];
+
+  if (!comparison.passed) {
+    findings.push({
+      ruleId: 'RULE-PERF-001',
+      name: 'PerformanceRegressionDetected',
+      severity: 'WARNING',
+      message: `Regressão de performance detectada: Latência +${comparison.deltas.latencyDeltaPct}% (Limiar: ${thresholdPct}%).`,
+      remediation: 'Investigue o overhead recente ou recalibre o baseline em benchmarks/baseline.json.'
+    });
+  }
+
+  return createSarifReport({
+    toolName: 'agent-master-perf-benchmark',
+    rules: [
+      {
+        id: 'RULE-PERF-001',
+        name: 'PerformanceRegressionDetected',
+        description: 'Bloqueia merges com regressão de latência ou memória superior ao limiar permitido',
+        severity: 'MEDIUM',
+        cwe: 'CWE-400'
+      }
+    ],
+    findings,
+    properties: {
+      passed: comparison.passed,
+      avgLatencyUs: current.avgLatencyUs,
+      baselineLatencyUs: baseline.avgLatencyUs,
+      opsPerSec: current.opsPerSec
+    }
+  });
+}
+
+class PerfBenchmark {
+  static runBenchmark(iterations) {
+    return runBenchmark(iterations);
+  }
+  static comparePerformance(current, baseline, threshold) {
+    return comparePerformance(current, baseline, threshold);
+  }
+  static formatReport(comparison) {
+    return formatPerfReport(comparison);
+  }
+  static auditToSarif(iterations, threshold) {
+    return auditToSarif(iterations, threshold);
+  }
+}
+
+module.exports = {
+  PerfBenchmark,
+  runBenchmark,
+  comparePerformance,
+  formatPerfReport,
+  formatReport: formatPerfReport,
+  auditToSarif,
+  getOrInitBaseline,
+  BASELINE_FILE
+};
+