fortify2-js
Version:
MOST POWERFUL JavaScript Security Library! Military-grade cryptography + 19 enhanced object methods + quantum-resistant algorithms + perfect TypeScript support. More powerful than Lodash with built-in security.
296 lines (293 loc) • 11.1 kB
JavaScript
import { PerformanceProfiler } from '../../optimization/PerformanceProfiler.js';
import { ExecutionPredictor } from '../../optimization/ExecutionPredictor.js';
import { RequestPreCompiler } from '../../optimization/RequestPreCompiler.js';
import { UltraFastExpressOptimizer } from '../../optimization/UltraFastOptimizer.js';
import { logger } from '../../utils/Logger.js';
/**
* PerformanceManager - Handles all performance optimization for FastApi.ts
* Manages profiling, prediction, compilation, and optimization statistics
*/
class PerformanceManager {
constructor(options, dependencies) {
this.optimizationEnabled = true;
this.optimizationStats = {
totalRequests: 0,
ultraFastRequests: 0,
fastRequests: 0,
standardRequests: 0,
optimizationFailures: 0,
avgOptimizationOverhead: 0,
};
this.options = options;
this.dependencies = dependencies;
this.initializePerformanceComponents();
this.addPerformanceMethodsToApp();
}
/**
* Initialize performance optimization components
*/
initializePerformanceComponents() {
logger.debug("performance", "Initializing performance optimization components...");
// Initialize performance profiler
this.performanceProfiler = new PerformanceProfiler();
// Initialize execution predictor
this.executionPredictor = new ExecutionPredictor();
// Initialize request pre-compiler
this.requestPreCompiler = new RequestPreCompiler(this.dependencies.cacheManager.getCache(), {
enabled: this.options.performance?.preCompilerEnabled !== false,
learningPeriod: this.options.performance?.learningPeriod || 60000, // 1 minute for faster learning
optimizationThreshold: this.options.performance?.optimizationThreshold || 1, // Optimize after just 1 request
maxCompiledRoutes: this.options.performance?.maxCompiledRoutes || 1000,
aggressiveOptimization: this.options.performance?.aggressiveOptimization !== false, // Default to aggressive
predictivePreloading: this.options.performance?.predictivePreloading !== false, // Default to enabled
// System info for library-agnostic responses
systemInfo: {
serviceName: this.options.server?.serviceName ||
"FastApi.ts Service",
version: this.options.server?.version || "1.0.0",
environment: this.options.env ||
process.env.NODE_ENV ||
"development",
customHealthData: this.options.performance?.customHealthData,
customStatusData: this.options.performance?.customStatusData,
},
});
// Initialize UltraFastOptimizer if enabled
if (this.isUltraFastOptimizerEnabled()) {
this.ultraFastOptimizer = new UltraFastExpressOptimizer(this.getUltraFastOptimizerConfig());
}
logger.debug("performance", "Performance optimization components initialized");
}
/**
* Add performance-related methods to the Express app
*/
addPerformanceMethodsToApp() {
// Request pre-compiler access
this.dependencies.app.getRequestPreCompiler = () => {
return this.requestPreCompiler;
};
}
/**
* Check if UltraFastOptimizer should be enabled
*/
isUltraFastOptimizerEnabled() {
const config = this.options.performance?.optimizationEnabled ?? true;
return config;
}
/**
* Get UltraFastOptimizer configuration
*/
getUltraFastOptimizerConfig() {
const config = this.options.performance?.optimizationEnabled;
if (typeof config === "boolean" || !config) {
// Use default configuration
return {
cache: {
enabled: true,
defaultTTL: 60000,
maxSize: 1000,
maxMemoryMB: 100,
},
performance: {
enablePrecompilation: true,
asyncTimeout: 5000,
},
monitoring: {
enabled: true,
logInterval: 30000,
},
};
}
// Use provided configuration with defaults (config is object here)
const objConfig = config; // Type assertion to handle union type
return {
cache: {
enabled: true,
defaultTTL: 60000,
maxSize: 1000,
maxMemoryMB: 100,
...(objConfig.cache || {}),
},
performance: {
enablePrecompilation: true,
asyncTimeout: 5000,
},
monitoring: {
enabled: true,
logInterval: 30000,
onStats: objConfig.monitoring?.metricsCallback,
...(objConfig.monitoring || {}),
},
};
}
/**
* Get performance profiler instance
*/
getPerformanceProfiler() {
return this.performanceProfiler;
}
/**
* Get execution predictor instance
*/
getExecutionPredictor() {
return this.executionPredictor;
}
/**
* Get request pre-compiler instance
*/
getRequestPreCompiler() {
return this.requestPreCompiler;
}
/**
* Get UltraFastOptimizer instance
*/
getUltraFastOptimizer() {
return this.ultraFastOptimizer;
}
/**
* Get optimization enabled status
*/
isOptimizationEnabled() {
return this.optimizationEnabled;
}
/**
* Set optimization enabled status
*/
setOptimizationEnabled(enabled) {
this.optimizationEnabled = enabled;
}
/**
* Get optimization statistics
*/
getOptimizationStats() {
return { ...this.optimizationStats };
}
/**
* Update optimization statistics
*/
updateOptimizationStats(type) {
switch (type) {
case "total":
this.optimizationStats.totalRequests++;
break;
case "ultra-fast":
this.optimizationStats.ultraFastRequests++;
break;
case "fast":
this.optimizationStats.fastRequests++;
break;
case "standard":
this.optimizationStats.standardRequests++;
break;
case "failure":
this.optimizationStats.optimizationFailures++;
break;
}
}
/**
* Reset optimization statistics
*/
resetOptimizationStats() {
this.optimizationStats = {
totalRequests: 0,
ultraFastRequests: 0,
fastRequests: 0,
standardRequests: 0,
optimizationFailures: 0,
avgOptimizationOverhead: 0,
};
this.performanceProfiler.clearMetrics();
}
/**
* Get comprehensive performance statistics
*/
getPerformanceStats() {
const profilerStats = this.performanceProfiler.getStats();
const predictorStats = this.executionPredictor.getStats();
const compilerStats = this.requestPreCompiler.getStats();
const ultraFastStats = this.ultraFastOptimizer?.getStats();
return {
optimization: {
enabled: this.optimizationEnabled,
stats: this.optimizationStats,
profiler: profilerStats,
predictor: predictorStats,
compiler: compilerStats,
ultraFast: ultraFastStats,
targetAchievement: {
ultraFastTarget: profilerStats.ultraFastTargetRate,
fastTarget: profilerStats.fastTargetRate,
overallSuccess: profilerStats.optimizationSuccessRate,
ultraFastOptimizationRate: ultraFastStats?.optimizedRate || 0,
},
},
};
}
/**
* Get real-time performance metrics
*/
getRealTimeMetrics(limit = 50) {
const recentMetrics = this.performanceProfiler.getDetailedMetrics(limit);
const currentStats = this.performanceProfiler.getStats();
return {
recentRequests: recentMetrics,
currentPerformance: {
p50: currentStats.p50ResponseTime,
p95: currentStats.p95ResponseTime,
p99: currentStats.p99ResponseTime,
avgResponseTime: currentStats.avgResponseTime,
},
cachePerformance: {
overallHitRate: currentStats.overallCacheHitRate,
l1HitRate: currentStats.l1CacheHitRate,
l2HitRate: currentStats.l2CacheHitRate,
l3HitRate: currentStats.l3CacheHitRate,
},
optimizationEffectiveness: {
ultraFastRequests: this.optimizationStats.ultraFastRequests,
fastRequests: this.optimizationStats.fastRequests,
standardRequests: this.optimizationStats.standardRequests,
optimizationFailures: this.optimizationStats.optimizationFailures,
},
};
}
/**
* Analyze request performance and update patterns
*/
analyzeRequestPerformance(req, responseTime, cacheHit) {
try {
this.executionPredictor.updatePattern(req, responseTime, cacheHit);
this.requestPreCompiler.analyzeRequest(req, null, () => { });
}
catch (error) {
logger.warn("performance", "Failed to analyze request performance:", error.message);
}
}
/**
* Get performance recommendations
*/
getPerformanceRecommendations() {
const recommendations = [];
const stats = this.getPerformanceStats();
// Check ultra-fast target achievement
if (stats.optimization.targetAchievement.ultraFastTarget < 0.8) {
recommendations.push("Consider enabling more aggressive caching for ultra-fast responses");
}
// Check cache hit rates
if (stats.optimization.profiler.overallCacheHitRate < 0.7) {
recommendations.push("Cache hit rate is low - consider adjusting cache TTL or warming strategies");
}
// Check optimization failures
if (this.optimizationStats.optimizationFailures >
this.optimizationStats.totalRequests * 0.1) {
recommendations.push("High optimization failure rate - review error logs and consider fallback strategies");
}
// Check response times
if (stats.optimization.profiler.avgResponseTime > 50) {
recommendations.push("Average response time is high - consider optimizing slow endpoints");
}
return recommendations;
}
}
export { PerformanceManager };
//# sourceMappingURL=PerformanceManager.js.map