@archznn/xavva 3.1.3 → 3.2.0

package/src/services/PerformanceProfiler.ts

@@ -0,0 +1,267 @@
+/**
+ * Profiler de Performance
+ * 
+ * Mede tempo de execução de operações e gera relatórios
+ * Uso: xavva build --profile ou xavva deploy --profile
+ */
+
+import { Logger } from "../logging";
+
+interface PhaseTiming {
+    phase: string;
+    startTime: number;
+    endTime?: number;
+    duration?: number;
+    parent?: string;
+}
+
+interface ProfilerConfig {
+    enabled: boolean;
+    verbose: boolean;
+}
+
+export class PerformanceProfiler {
+    private timings: Map<string, PhaseTiming> = new Map();
+    private completedTimings: PhaseTiming[] = [];
+    private stack: string[] = [];
+    private config: ProfilerConfig;
+    private logger = Logger.getInstance();
+    private globalStart: number = 0;
+
+    constructor(config: Partial<ProfilerConfig> = {}) {
+        this.config = {
+            enabled: true,
+            verbose: false,
+            ...config,
+        };
+    }
+
+    /**
+     * Inicia profiling global
+     */
+    start(): void {
+        if (!this.config.enabled) return;
+        this.globalStart = performance.now();
+        this.timings.clear();
+        this.completedTimings = [];
+        this.stack = [];
+    }
+
+    /**
+     * Inicia uma fase
+     */
+    startPhase(phase: string): void {
+        if (!this.config.enabled) return;
+
+        const parent = this.stack.length > 0 ? this.stack[this.stack.length - 1] : undefined;
+        
+        const timing: PhaseTiming = {
+            phase,
+            startTime: performance.now(),
+            parent,
+        };
+
+        this.timings.set(phase, timing);
+        this.stack.push(phase);
+
+        if (this.config.verbose) {
+            this.logger.debug(`[Profiler] Iniciando: ${phase}`);
+        }
+    }
+
+    /**
+     * Finaliza uma fase
+     */
+    endPhase(phase?: string): void {
+        if (!this.config.enabled) return;
+
+        const phaseName = phase || this.stack.pop();
+        if (!phaseName) return;
+
+        const timing = this.timings.get(phaseName);
+        if (!timing) return;
+
+        timing.endTime = performance.now();
+        timing.duration = timing.endTime - timing.startTime;
+
+        this.completedTimings.push({ ...timing });
+        this.timings.delete(phaseName);
+
+        if (this.config.verbose) {
+            this.logger.debug(`[Profiler] Finalizado: ${phaseName} (${timing.duration.toFixed(2)}ms)`);
+        }
+    }
+
+    /**
+     * Executa função dentro de uma fase
+     */
+    async withPhase<T>(phase: string, fn: () => Promise<T>): Promise<T> {
+        this.startPhase(phase);
+        try {
+            return await fn();
+        } finally {
+            this.endPhase(phase);
+        }
+    }
+
+    /**
+     * Executa função síncrona dentro de uma fase
+     */
+    withPhaseSync<T>(phase: string, fn: () => T): T {
+        this.startPhase(phase);
+        try {
+            return fn();
+        } finally {
+            this.endPhase(phase);
+        }
+    }
+
+    /**
+     * Gera relatório de performance
+     */
+    generateReport(): void {
+        if (!this.config.enabled) return;
+
+        const totalTime = performance.now() - this.globalStart;
+
+        this.logger.newline();
+        this.logger.section("📊 Profile de Performance");
+
+        // Ordena por duração (decrescente)
+        const sorted = [...this.completedTimings].sort((a, b) => 
+            (b.duration || 0) - (a.duration || 0)
+        );
+
+        // Agrupa por nível
+        const rootPhases = sorted.filter(t => !t.parent);
+        
+        for (const phase of rootPhases) {
+            this.printPhase(phase, sorted, 0, totalTime);
+        }
+
+        // Linha de total
+        this.logger.divider();
+        this.printTimingLine("TOTAL", totalTime, totalTime, 0, true);
+
+        // Estatísticas
+        this.printStats();
+    }
+
+    private printPhase(phase: PhaseTiming, all: PhaseTiming[], level: number, total: number): void {
+        this.printTimingLine(phase.phase, phase.duration || 0, total, level);
+
+        // Filhos
+        const children = all.filter(t => t.parent === phase.phase);
+        for (const child of children) {
+            this.printPhase(child, all, level + 1, total);
+        }
+    }
+
+    private printTimingLine(name: string, duration: number, total: number, level: number, isTotal = false): void {
+        const indent = "  ".repeat(level);
+        const percent = total > 0 ? (duration / total) * 100 : 0;
+        const bar = this.renderBar(percent);
+        
+        const timeStr = this.formatDuration(duration);
+        const percentStr = percent.toFixed(1).padStart(5);
+        
+        const nameFormatted = isTotal 
+            ? `${name}`
+            : `${indent}${name}`;
+        
+        this.logger.info(`${nameFormatted.padEnd(25)} ${timeStr.padStart(10)} ${bar} ${percentStr}%`);
+    }
+
+    private renderBar(percent: number): string {
+        const width = 20;
+        const filled = Math.round((percent / 100) * width);
+        const empty = width - filled;
+        
+        const bar = "█".repeat(filled) + "░".repeat(empty);
+        return `[${bar}]`;
+    }
+
+    private formatDuration(ms: number): string {
+        if (ms < 1000) {
+            return `${ms.toFixed(0)}ms`;
+        } else if (ms < 60000) {
+            return `${(ms / 1000).toFixed(2)}s`;
+        } else {
+            const mins = Math.floor(ms / 60000);
+            const secs = ((ms % 60000) / 1000).toFixed(1);
+            return `${mins}m ${secs}s`;
+        }
+    }
+
+    private printStats(): void {
+        const times = this.completedTimings.map(t => t.duration || 0);
+        
+        if (times.length === 0) return;
+
+        const avg = times.reduce((a, b) => a + b, 0) / times.length;
+        const max = Math.max(...times);
+        const min = Math.min(...times);
+
+        this.logger.newline();
+        this.logger.info("📈 Estatísticas:");
+        this.logger.info(`   Fases: ${times.length}`);
+        this.logger.info(`   Média: ${this.formatDuration(avg)}`);
+        this.logger.info(`   Mín: ${this.formatDuration(min)}`);
+        this.logger.info(`   Máx: ${this.formatDuration(max)}`);
+    }
+
+    /**
+     * Exporta dados para JSON
+     */
+    exportJSON(): object {
+        const totalTime = performance.now() - this.globalStart;
+        
+        return {
+            totalTime,
+            phases: this.completedTimings.map(t => ({
+                phase: t.phase,
+                duration: t.duration,
+                parent: t.parent,
+            })),
+            timestamp: new Date().toISOString(),
+        };
+    }
+
+    /**
+     * Limpa dados
+     */
+    reset(): void {
+        this.timings.clear();
+        this.completedTimings = [];
+        this.stack = [];
+        this.globalStart = 0;
+    }
+
+    /**
+     * Verifica se profiling está ativo
+     */
+    isEnabled(): boolean {
+        return this.config.enabled;
+    }
+
+    /**
+     * Ativa/desativa profiling
+     */
+    setEnabled(enabled: boolean): void {
+        this.config.enabled = enabled;
+    }
+}
+
+// Singleton global
+let globalProfiler: PerformanceProfiler | null = null;
+
+export function getProfiler(config?: Partial<ProfilerConfig>): PerformanceProfiler {
+    if (!globalProfiler) {
+        globalProfiler = new PerformanceProfiler(config);
+    }
+    return globalProfiler;
+}
+
+export function resetProfiler(): void {
+    globalProfiler = null;
+}

package/src/services/ProjectService.ts

@@ -1,8 +1,11 @@
 import { existsSync, readdirSync, statSync, readFileSync } from "fs";
 import path from "path";
 import type { ProjectConfig } from "../types/config";
+import { Logger } from "../logging";
 
 export class ProjectService {
+    private logger = Logger.getInstance();
+
     constructor(private config: ProjectConfig) {}
 
     getBuildOutputDir(): string {

package/src/services/TestService.ts

@@ -3,7 +3,7 @@
  * Suporta Maven e Gradle com modo watch
  */
 
-import { Logger } from "../utils/ui";
+import { Logger, C } from "../utils/ui";
 import { spawn } from "child_process";
 import { watch, type FSWatcher } from "fs";
 import path from "path";
@@ -287,8 +287,8 @@ export class TestService {
         }
 
         Logger.info("Total", result.totalTests);
-        Logger.info("Passed", `${Logger.C.success}${result.passed}${Logger.C.reset}`);
-        Logger.info("Failed", result.failed > 0 ? `${Logger.C.error}${result.failed}${Logger.C.reset}` : "0");
+        Logger.info("Passed", `${C.success}${result.passed}${C.reset}`);
+        Logger.info("Failed", result.failed > 0 ? `${C.error}${result.failed}${C.reset}` : "0");
         Logger.info("Skipped", result.skipped);
         Logger.info("Duration", `${(result.duration / 1000).toFixed(2)}s`);
 

package/src/services/TomcatService.ts

@@ -1,7 +1,9 @@
 import type { TomcatConfig, AppConfig } from "../types";
 import { getHotswapAgentUrl, VERSIONS } from "../config/versions";
 import { NetworkError } from "../errors/XavvaError";
-import { Logger } from "../utils/ui";
+import { Logger } from "../logging";
+import { Logger as LoggerLegacy } from "../utils/ui";
+import { NOISE_PATTERNS } from "../logging/constants";
 import { ProgressBar, ThemedSpinner } from "../utils/ProgressBar";
 import type { Subprocess } from "bun";
 import { ProjectService } from "./ProjectService";
@@ -20,11 +22,12 @@ import {
 export class TomcatService {
 	private activeConfig: TomcatConfig;
 	private currentProcess: Subprocess | null = null;
-	private stopStartupSpinner?: (success?: boolean) => void;
+	private startupSpinner?: { stop: (success?: boolean) => void; update: (msg: string) => void };
 	public onReady?: () => void;
 	private pid: number | null = null;
 	private projectService: ProjectService | null = null;
 	private hasReadyBeenCalled: boolean = false;
+	private logger = Logger.getInstance();
 
 	constructor(customConfig: TomcatConfig) {
 		this.activeConfig = customConfig;
@@ -82,7 +85,7 @@ export class TomcatService {
 			}
 			
 			if (pid) {
-				Logger.step(`Freeing port ${this.activeConfig.port}`);
+				this.logger.step(`Liberando porta ${this.activeConfig.port}`);
 				const killCmd = getKillCommand(pid);
 				Bun.spawnSync(killCmd);
 			}
@@ -126,13 +129,13 @@ export class TomcatService {
 
 			await Promise.all(tasks);
 		} catch (e) {
-			Logger.warn("Não foi possível limpar totalmente a pasta webapps ou cache.");
+			this.logger.warn("Não foi possível limpar totalmente a pasta webapps ou cache.");
 		}
 	}
 
 	stop() {
 		if (this.currentProcess) {
-			Logger.warn("Stopping active server...");
+			this.logger.warn("Parando servidor ativo...");
 			this.currentProcess.kill();
 			this.currentProcess = null;
 		}
@@ -210,7 +213,7 @@ export class TomcatService {
 			Logger.success(`HotswapAgent v${VERSIONS.HOTSWAP_AGENT.VERSION} instalado!`);
 			return agentPath;
 		} catch (e: any) {
-			Logger.warn("Falha ao baixar HotswapAgent. Usando hot swap padrão da JVM.");
+			this.logger.warn("Falha ao baixar HotswapAgent. Usando hot swap padrão da JVM.");
 			
 			// Limpa arquivo parcial se existir
 			if (existsSync(agentPath)) {
@@ -314,13 +317,13 @@ export class TomcatService {
 		}
 
 		if (config.project.debug) {
-			Logger.debug(`Java Debugger habilitado na porta ${config.project.debugPort}`);
+			this.logger.debug(`Porta do debugger ${config.project.debugPort}`);
 			env.JPDA_ADDRESS = String(config.project.debugPort);
 			env.JPDA_TRANSPORT = "dt_socket";
 		}
 
 		if ((config.project.cleanLogs || config.project.quiet) && !config.project.verbose) {
-			this.stopStartupSpinner = Logger.spinner("Starting Tomcat server");
+			this.startupSpinner = this.logger.spinner("Iniciando servidor Tomcat");
 		}
 
 		this.currentProcess = Bun.spawn([binPath, ...args], {
@@ -359,9 +362,9 @@ export class TomcatService {
 				// Detect startup completion
 				if (cleanLine.includes("Server startup in") || cleanLine.includes("SEVERE") || cleanLine.includes("Exception")) {
 					const isSuccess = cleanLine.includes("Server startup in");
-					if (this.stopStartupSpinner) {
-						this.stopStartupSpinner(isSuccess);
-						this.stopStartupSpinner = undefined;
+					if (this.startupSpinner) {
+						this.startupSpinner.stop(isSuccess);
+						this.startupSpinner = undefined;
 					}
 					if (isSuccess && this.onReady && !this.hasReadyBeenCalled) {
 						this.hasReadyBeenCalled = true;
@@ -371,10 +374,12 @@ export class TomcatService {
 
 				// Verbose: formata logs do Tomcat
 				if (verbose) {
-					if (Logger.isTomcatNoise(cleanLine)) {
-						continue; // Silencia noise completamente
+					// No modo verbose, só filtra o noise básico (CATALINA_, JRE_HOME, etc)
+					// Logs do HOTSWAP e outros são mostrados
+					if (LoggerLegacy.isTomcatNoise(cleanLine) && !LoggerLegacy.isTomcatVerboseLog(cleanLine)) {
+						continue; // Silencia noise básico
 					}
-					const formatted = Logger.formatTomcatLog(cleanLine);
+					const formatted = LoggerLegacy.formatTomcatLog(cleanLine);
 					if (formatted) {
 						console.log(formatted);
 					}
@@ -384,30 +389,46 @@ export class TomcatService {
 				// Clean mode: filtra noise
 				if (clean) {
 					// Sempre filtra noise do sistema
-					if (Logger.isSystemNoise(cleanLine)) continue;
+					if (NOISE_PATTERNS.system.some(n => cleanLine.includes(n))) continue;
 
 					// Quiet mode: só mostra essencial
-					if (quiet && !Logger.isEssential(cleanLine)) {
+					if (quiet && !LoggerLegacy.isEssential(cleanLine)) {
 						if (cleanLine.includes("INFO") && !cleanLine.includes("ERROR")) continue;
 					}
 
 					// Grep filter
 					if (grep && !cleanLine.toLowerCase().includes(grep.toLowerCase())) {
-						if (!Logger.isEssential(cleanLine)) continue;
+						if (!LoggerLegacy.isEssential(cleanLine)) continue;
 					}
 					
-					const summarized = Logger.summarize(cleanLine);
-					if (summarized) {
-						// Só mostra se não for vazio (rate limiting)
-						if (summarized.trim()) Logger.log(summarized);
+					const summarized = LoggerLegacy.summarize(cleanLine);
+					if (summarized && summarized.trim()) {
+						// Para o spinner antes de mostrar log para não quebrar a interface
+						if (this.startupSpinner) {
+							this.startupSpinner.stop(true);
+							this.startupSpinner = undefined;
+						}
+						console.log(summarized);
 					}
 				} else {
-					// Non-clean: mostra tudo mas formata
-					if (Logger.isSystemNoise(cleanLine)) {
-						// Silencia completamente noise em non-clean também
+					// Modo normal (não verbose, não clean): filtra mais agressivamente
+					// Só mostra logs essenciais e resumos
+					if (NOISE_PATTERNS.system.some(n => cleanLine.includes(n))) {
 						continue;
 					}
-					Logger.log(cleanLine);
+					
+					// No modo normal, só mostra se for essencial ou tiver resumo
+					const summarized = LoggerLegacy.summarize(cleanLine);
+					if (summarized && summarized.trim()) {
+						// Para o spinner antes de mostrar log
+						if (this.startupSpinner) {
+							this.startupSpinner.stop(true);
+							this.startupSpinner = undefined;
+						}
+						console.log(summarized);
+					}
+					// Silencia logs não essenciais no modo normal
+					// (WARNING, ADVERTÊNCIA, INFO genérico, etc. só aparecem no verbose)
 				}
 			}
 		}