@aztec/end-to-end 0.0.1-commit.88e6f9396 → 0.0.1-commit.8c0b8ff

package/src/fixtures/elu_monitor.ts

@@ -1,126 +0,0 @@
-import { appendFileSync } from 'node:fs';
-import { type EventLoopUtilization, type IntervalHistogram, monitorEventLoopDelay, performance } from 'node:perf_hooks';
-
-const NANOS_PER_MS = 1_000_000;
-
-/** Samples event-loop utilization, delay histogram, and heap usage per test, writing columnar text to a file. */
-export class EluMonitor {
-  private filePath: string;
-  private intervalMs: number;
-  private timer: ReturnType<typeof setInterval> | undefined;
-  private lastELU: EventLoopUtilization | undefined;
-  private histogram: IntervalHistogram;
-  private testName: string | undefined;
-  private testStart: number | undefined;
-  private eluSamples: number[] = [];
-
-  constructor(filePath: string, intervalMs?: number) {
-    this.filePath = filePath;
-    this.intervalMs = intervalMs ?? 2000;
-    this.histogram = monitorEventLoopDelay({ resolution: 20 });
-  }
-
-  /** Begin sampling for a test. Writes a header line and starts the periodic sampler. */
-  startTest(testName: string): void {
-    this.stopTest();
-
-    this.testName = testName;
-    this.testStart = performance.now();
-    this.eluSamples = [];
-
-    appendFileSync(this.filePath, `\n=== Test: ${testName} ===\n`);
-    appendFileSync(
-      this.filePath,
-      padColumns('TIME', 'ELU', 'EL_DLY_P50', 'EL_DLY_P99', 'EL_DLY_MAX', 'HEAP_MB') + '\n',
-    );
-
-    this.lastELU = performance.eventLoopUtilization();
-    this.histogram.enable();
-
-    this.timer = setInterval(() => this.sample(), this.intervalMs);
-    // Allow the process to exit even if the timer is still running.
-    this.timer.unref();
-  }
-
-  /** Stop sampling and write a summary line. */
-  stopTest(): void {
-    if (!this.timer) {
-      return;
-    }
-
-    // Take a final sample before stopping.
-    this.sample();
-
-    clearInterval(this.timer);
-    this.timer = undefined;
-    this.histogram.disable();
-    this.histogram.reset();
-
-    this.writeSummary();
-
-    this.lastELU = undefined;
-    this.testName = undefined;
-    this.testStart = undefined;
-    this.eluSamples = [];
-  }
-
-  /** Alias for stopTest — call on process exit to flush any remaining data. */
-  stop(): void {
-    this.stopTest();
-  }
-
-  private sample(): void {
-    const newELU = performance.eventLoopUtilization();
-    const delta = performance.eventLoopUtilization(newELU, this.lastELU);
-    this.lastELU = newELU;
-
-    const elu = delta.utilization;
-    this.eluSamples.push(elu);
-
-    const p50 = this.histogram.percentile(50) / NANOS_PER_MS;
-    const p99 = this.histogram.percentile(99) / NANOS_PER_MS;
-    const max = this.histogram.max / NANOS_PER_MS;
-    const heapMb = Math.round(process.memoryUsage().heapUsed / (1024 * 1024));
-
-    const now = new Date();
-    const time = [now.getHours(), now.getMinutes(), now.getSeconds()].map(n => String(n).padStart(2, '0')).join(':');
-
-    const line = padColumns(
-      time,
-      elu.toFixed(2),
-      `${p50.toFixed(1)}ms`,
-      `${p99.toFixed(1)}ms`,
-      `${max.toFixed(1)}ms`,
-      String(heapMb),
-    );
-    appendFileSync(this.filePath, line + '\n');
-
-    // Reset histogram so next sample only reflects the new interval.
-    this.histogram.reset();
-  }
-
-  private writeSummary(): void {
-    if (this.eluSamples.length === 0 || this.testStart === undefined) {
-      return;
-    }
-
-    const mean = this.eluSamples.reduce((a, b) => a + b, 0) / this.eluSamples.length;
-    const maxElu = Math.max(...this.eluSamples);
-    const sorted = [...this.eluSamples].sort((a, b) => a - b);
-    const p90Elu = sorted[Math.floor(sorted.length * 0.9)] ?? maxElu;
-    const durationS = ((performance.now() - this.testStart) / 1000).toFixed(1);
-
-    let summary = `--- Summary: mean_elu=${mean.toFixed(2)} max_elu=${maxElu.toFixed(2)} p90_elu=${p90Elu.toFixed(2)} duration=${durationS}s`;
-    if (maxElu > 0.85) {
-      summary += ' WARNING:ELU>0.85';
-    }
-    summary += ' ---\n';
-
-    appendFileSync(this.filePath, summary);
-  }
-}
-
-function padColumns(...cols: string[]): string {
-  const widths = [11, 7, 12, 12, 12, 8];
-  return cols.map((col, i) => col.padEnd(widths[i] ?? 10)).join('');
-}

package/src/spartan/utils/pod_logs.ts

@@ -1,99 +0,0 @@
-import type { Logger } from '@aztec/foundation/log';
-
-import { exec } from 'child_process';
-import { promisify } from 'util';
-
-import { getSequencers } from './nodes.js';
-
-const execAsync = promisify(exec);
-
-/** Parsed l2-block-built stats from a sequencer pod log line. */
-export type BlockBuiltLogEntry = {
-  blockNumber: number;
-  txCount: number;
-  duration: number;
-  publicProcessDuration: number;
-  manaPerSec: number;
-  privateLogCount: number;
-  publicLogCount: number;
-  contractClassLogCount: number;
-  contractClassLogSize: number;
-};
-
-const FIELDS: (keyof BlockBuiltLogEntry)[] = [
-  'blockNumber',
-  'txCount',
-  'duration',
-  'publicProcessDuration',
-  'manaPerSec',
-  'privateLogCount',
-  'publicLogCount',
-  'contractClassLogCount',
-  'contractClassLogSize',
-];
-
-/**
- * Fetches l2-block-built log entries from sequencer pods for given block numbers.
- * Queries all validator pods (only the proposer will have the log for a given block).
- *
- * @param namespace - Kubernetes namespace
- * @param sinceTime - ISO 8601 timestamp to limit log search (e.g., from before block building was re-enabled)
- * @param blockNumbers - Set of block numbers to filter for
- * @param logger - Logger instance
- * @returns Array of parsed BlockBuiltLogEntry, de-duplicated by blockNumber, sorted ascending
- */
-export async function fetchBlockBuiltLogs(
-  namespace: string,
-  sinceTime: string,
-  blockNumbers: Set<number>,
-  logger: Logger,
-): Promise<BlockBuiltLogEntry[]> {
-  const pods = await getSequencers(namespace);
-  const entriesByBlock = new Map<number, BlockBuiltLogEntry>();
-
-  // Subtract 60s from sinceTime to account for clock skew between test runner and k8s pods.
-  // Block number filtering ensures we only match the right blocks, so extra lines are harmless.
-  const sinceDate = new Date(new Date(sinceTime).getTime() - 60_000);
-  const sinceFlag = sinceDate.toISOString();
-
-  for (const pod of pods) {
-    try {
-      const cmd = `kubectl logs ${pod} -n ${namespace} -c aztec --since-time=${sinceFlag}`;
-      logger.info(`Fetching logs: ${cmd}`);
-      const { stdout } = await execAsync(cmd, { maxBuffer: 10 * 1024 * 1024 });
-
-      const lines = stdout.split('\n');
-      const matchingLines = lines.filter(l => l.includes('l2-block-built'));
-      logger.info(`Pod ${pod}: ${lines.length} log lines, ${matchingLines.length} contain l2-block-built`);
-
-      for (const line of matchingLines) {
-        try {
-          const parsed = JSON.parse(line);
-          if (parsed.eventName !== 'l2-block-built' || !blockNumbers.has(parsed.blockNumber)) {
-            continue;
-          }
-          if (entriesByBlock.has(parsed.blockNumber)) {
-            continue;
-          }
-          const entry: BlockBuiltLogEntry = {} as BlockBuiltLogEntry;
-          for (const field of FIELDS) {
-            entry[field] = parsed[field] ?? 0;
-          }
-          entriesByBlock.set(entry.blockNumber, entry);
-          logger.verbose(`Parsed l2-block-built log for block ${entry.blockNumber}`, entry);
-        } catch {
-          // Not valid JSON, skip
-        }
-      }
-    } catch (err) {
-      logger.warn(`Failed to fetch logs from pod ${pod}: ${err}`);
-    }
-  }
-
-  if (entriesByBlock.size < blockNumbers.size) {
-    const missing = [...blockNumbers].filter(bn => !entriesByBlock.has(bn));
-    logger.warn(`Missing l2-block-built logs for block(s): ${missing.join(', ')}`);
-  }
-
-  return [...entriesByBlock.values()].sort((a, b) => a.blockNumber - b.blockNumber);
-}