xypriss 2.0.0 → 2.1.1

package/dist/esm/src/server/components/fastapi/UltraFastRequestProcessor.js

@@ -1,647 +0,0 @@
-import * as os from 'os';
-import { createHash } from 'crypto';
-import { readCache, writeCache, getCacheStats } from '../../../../mods/security/src/components/cache/index.js';
-import { PerformanceMonitor } from '../../optimization/performance-monitor.js';
-import { WorkerPool } from './modules/UFRP/WorkerPool.js';
-
-/**
- * XyPrissJS - Ultra-Fast Request Processor (Optimized Production Version)
- * High-performance request processing using existing XyPrissJS components
- */
-class UltraFastRequestProcessor {
-    constructor(config) {
-        this.requestPatterns = new Map();
-        this.activeRequests = new Map();
-        this.circuitBreaker = new Map();
-        this.stats = {
-            cacheHits: 0,
-            cacheMisses: 0,
-            totalRequests: 0,
-            successfulRequests: 0,
-            failedRequests: 0,
-            avgResponseTime: 0,
-            totalResponseTime: 0,
-            peakConcurrency: 0,
-            currentConcurrency: 0,
-        };
-        this.intervals = [];
-        this.isShuttingDown = false;
-        this.config = this.createFinalConfig(config);
-        this.maxConcurrency = this.config.workers?.maxConcurrentTasks || 1000;
-        // Initialize optimized worker pool
-        this.workerPool = new WorkerPool({
-            cpu: this.config.workers?.cpu ||
-                Math.max(2, Math.floor(os.cpus().length * 0.8)),
-            io: this.config.workers?.io ||
-                Math.max(4, Math.floor(os.cpus().length * 0.6)),
-            maxConcurrentTasks: this.maxConcurrency,
-        });
-        // Initialize performance monitor with optimized settings
-        this.performanceMonitor = new PerformanceMonitor({
-            ...this.config.performance,
-            // Note: bufferSize and sampleRate are handled internally by PerformanceMonitor
-        });
-        // Start optimized pattern analysis
-        if (this.config.prediction?.enabled) {
-            this.startOptimizedPatternAnalysis();
-        }
-        // Start cleanup processes
-        this.startCleanupProcesses();
-    }
-    createFinalConfig(config) {
-        const isLegacy = config && ("cpuWorkers" in config || "ioWorkers" in config);
-        if (isLegacy) {
-            return this.convertLegacyConfig(config);
-        }
-        return this.createDefaultConfig(config);
-    }
-    convertLegacyConfig(legacy) {
-        return {
-            cache: {
-                maxSize: legacy.maxCacheSize || 50000,
-                defaultTTL: legacy.cacheTTL || 300000,
-                enableCompression: legacy.enableCompression ?? true,
-                compressionThreshold: 1024,
-            },
-            performance: {
-                enabled: true,
-                metrics: [
-                    "cpu",
-                    "memory",
-                    "responseTime",
-                    "requests",
-                    "errors",
-                ],
-                interval: 10000, // Reduced frequency for production
-                alerts: [],
-            },
-            workers: {
-                cpu: legacy.cpuWorkers ||
-                    Math.max(2, Math.floor(os.cpus().length * 0.8)),
-                io: legacy.ioWorkers ||
-                    Math.max(4, Math.floor(os.cpus().length * 0.6)),
-                maxConcurrentTasks: legacy.maxConcurrentTasks || 1000,
-            },
-            prediction: {
-                enabled: legacy.enablePrediction ?? true,
-                patternRetentionTime: 1800000, // 30 minutes
-                analysisInterval: 300000, // 5 minutes
-                hotPatternThreshold: 50, // Increased threshold
-            },
-        };
-    }
-    createDefaultConfig(override) {
-        const cpuCount = os.cpus().length;
-        const defaults = {
-            cache: {
-                maxSize: 50000,
-                defaultTTL: 300000,
-                enableCompression: true,
-                compressionThreshold: 1024,
-            },
-            performance: {
-                enabled: true,
-                metrics: [
-                    "cpu",
-                    "memory",
-                    "responseTime",
-                    "requests",
-                    "errors",
-                ],
-                interval: 10000,
-                alerts: [],
-            },
-            workers: {
-                cpu: Math.max(2, Math.floor(cpuCount * 0.8)),
-                io: Math.max(4, Math.floor(cpuCount * 0.6)),
-                maxConcurrentTasks: 1000,
-            },
-            prediction: {
-                enabled: true,
-                patternRetentionTime: 1800000,
-                analysisInterval: 300000,
-                hotPatternThreshold: 50,
-            },
-        };
-        return this.deepMerge(defaults, override || {});
-    }
-    deepMerge(target, source) {
-        const result = { ...target };
-        for (const key in source) {
-            if (source[key] &&
-                typeof source[key] === "object" &&
-                !Array.isArray(source[key])) {
-                result[key] = this.deepMerge(target[key] || {}, source[key]);
-            }
-            else {
-                result[key] = source[key];
-            }
-        }
-        return result;
-    }
-    startOptimizedPatternAnalysis() {
-        const interval = setInterval(() => {
-            if (!this.isShuttingDown) {
-                this.analyzeRequestPatterns();
-                this.updateCircuitBreakers();
-            }
-        }, this.config.prediction?.analysisInterval || 300000);
-        this.intervals.push(interval);
-    }
-    startCleanupProcesses() {
-        // Pattern cleanup
-        const patternCleanup = setInterval(() => {
-            if (!this.isShuttingDown) {
-                this.cleanupOldPatterns();
-            }
-        }, 600000); // Every 10 minutes
-        // Active requests cleanup (for orphaned requests)
-        const requestCleanup = setInterval(() => {
-            if (!this.isShuttingDown) {
-                this.cleanupOrphanedRequests();
-            }
-        }, 60000); // Every minute
-        this.intervals.push(patternCleanup, requestCleanup);
-    }
-    analyzeRequestPatterns() {
-        const now = Date.now();
-        const patterns = Array.from(this.requestPatterns.entries());
-        for (const [patternKey, pattern] of patterns) {
-            const timeSpan = Math.max(1, (now - pattern.lastSeen) / 60000);
-            pattern.frequency = pattern.count / timeSpan;
-            pattern.priority = this.calculateOptimizedPriority(pattern);
-            // Update success rate
-            pattern.successRate =
-                pattern.count > 0
-                    ? ((pattern.count - pattern.errorCount) / pattern.count) *
-                        100
-                    : 100;
-        }
-        // Prune low-priority patterns to manage memory
-        this.prunePatterns(patterns);
-    }
-    calculateOptimizedPriority(pattern) {
-        const now = Date.now();
-        const recency = Math.max(1, (now - pattern.lastSeen) / 60000);
-        const frequency = pattern.frequency || 1;
-        const speed = 1000 / Math.max(pattern.avgResponseTime, 1);
-        const reliability = pattern.successRate / 100;
-        const resourceEfficiency = 1 /
-            Math.max(pattern.resourceUsage.cpu + pattern.resourceUsage.memory, 1);
-        return ((pattern.count *
-            frequency *
-            speed *
-            reliability *
-            resourceEfficiency) /
-            recency);
-    }
-    prunePatterns(patterns) {
-        const maxPatterns = 10000; // Limit memory usage
-        if (patterns.length <= maxPatterns)
-            return;
-        // Sort by priority (ascending) and remove lowest priority patterns
-        patterns.sort((a, b) => a[1].priority - b[1].priority);
-        const toRemove = patterns.slice(0, patterns.length - maxPatterns);
-        for (const [key] of toRemove) {
-            this.requestPatterns.delete(key);
-        }
-    }
-    updateCircuitBreakers() {
-        const now = Date.now();
-        const resetTime = 60000; // 1 minute
-        for (const [pattern, breaker] of this.circuitBreaker.entries()) {
-            if (breaker.isOpen && now - breaker.lastFailure > resetTime) {
-                breaker.isOpen = false;
-                breaker.failures = 0;
-            }
-        }
-    }
-    cleanupOldPatterns() {
-        const now = Date.now();
-        const retentionTime = this.config.prediction?.patternRetentionTime || 1800000;
-        for (const [patternKey, pattern] of this.requestPatterns.entries()) {
-            if (now - pattern.lastSeen > retentionTime) {
-                this.requestPatterns.delete(patternKey);
-            }
-        }
-        // Also cleanup circuit breakers
-        for (const [pattern, breaker] of this.circuitBreaker.entries()) {
-            if (now - breaker.lastFailure > retentionTime) {
-                this.circuitBreaker.delete(pattern);
-            }
-        }
-    }
-    cleanupOrphanedRequests() {
-        const now = Date.now();
-        const maxAge = 300000; // 5 minutes
-        for (const [reqId, context] of this.activeRequests.entries()) {
-            if (now - context.startTime > maxAge) {
-                this.activeRequests.delete(reqId);
-                this.stats.currentConcurrency = Math.max(0, this.stats.currentConcurrency - 1);
-            }
-        }
-    }
-    middleware() {
-        return async (req, res, next) => {
-            if (this.isShuttingDown) {
-                res.status(503).json({ error: "Service shutting down" });
-                return;
-            }
-            // Check concurrency limit
-            if (this.stats.currentConcurrency >= this.maxConcurrency) {
-                res.status(429).json({ error: "Too many concurrent requests" });
-                return;
-            }
-            const requestId = this.generateRequestId();
-            const startTime = Date.now();
-            const context = {
-                startTime,
-                cacheKey: this.generateOptimizedCacheKey(req),
-                pattern: this.generatePattern(req),
-                priority: this.calculateRequestPriority(req),
-                workerType: this.determineWorkerType(req),
-                taskType: this.determineTaskType(req),
-            };
-            this.activeRequests.set(requestId, context);
-            this.stats.currentConcurrency++;
-            this.stats.totalRequests++;
-            this.stats.peakConcurrency = Math.max(this.stats.peakConcurrency, this.stats.currentConcurrency);
-            try {
-                // Check circuit breaker
-                if (this.isCircuitOpen(context.pattern)) {
-                    throw new Error("Circuit breaker open");
-                }
-                // Try cache first
-                const cachedResult = await this.tryCache(context.cacheKey);
-                if (cachedResult) {
-                    await this.sendCachedResponse(res, cachedResult, requestId, context);
-                    return;
-                }
-                // Process request
-                const result = await this.processOptimizedRequest(req, context);
-                // Cache result if successful
-                if (result && !res.headersSent) {
-                    await this.cacheResult(context.cacheKey, result);
-                    await this.sendProcessedResponse(res, result, requestId, context);
-                }
-                else if (!res.headersSent) {
-                    // If we couldn't process the request, pass it to the next middleware
-                    next();
-                    return;
-                }
-                this.recordSuccess(context, Date.now() - startTime);
-            }
-            catch (error) {
-                this.recordFailure(context, error, Date.now() - startTime);
-                if (!res.headersSent) {
-                    this.sendErrorResponse(res, error, requestId);
-                }
-            }
-            finally {
-                this.activeRequests.delete(requestId);
-                this.stats.currentConcurrency = Math.max(0, this.stats.currentConcurrency - 1);
-            }
-        };
-    }
-    generateRequestId() {
-        return `req_${Date.now()}_${Math.random()
-            .toString(36)
-            .substring(2, 11)}`;
-    }
-    generateOptimizedCacheKey(req) {
-        // More efficient cache key generation
-        const keyParts = [
-            req.method,
-            req.path,
-            req.headers["content-type"] || "",
-        ];
-        // Only include query params for GET requests
-        if (req.method === "GET" && Object.keys(req.query).length > 0) {
-            keyParts.push(JSON.stringify(req.query));
-        }
-        return createHash("sha256")
-            .update(keyParts.join("|"))
-            .digest("base64url"); // More URL-safe encoding
-    }
-    async tryCache(cacheKey) {
-        try {
-            const result = await readCache(cacheKey);
-            if (result &&
-                typeof result === "object" &&
-                Object.keys(result).length > 0) {
-                this.stats.cacheHits++;
-                return result;
-            }
-        }
-        catch (error) {
-            // Cache miss or error, continue with processing
-        }
-        this.stats.cacheMisses++;
-        return null;
-    }
-    async processOptimizedRequest(req, context) {
-        ({
-            id: this.generateRequestId(),
-            type: context.taskType,
-            priority: context.priority,
-            workerType: context.workerType,
-            createdAt: Date.now(),
-            data: {
-                method: req.method,
-                path: req.path,
-                query: req.query,
-                body: req.body,
-                headers: this.sanitizeHeaders(req.headers),
-            },
-        });
-        // TODO: Implement actual request processing logic
-        // For now, return null to pass control to next middleware
-        return null;
-    }
-    createTimeoutPromise(ms) {
-        return new Promise((_, reject) => {
-            setTimeout(() => reject(new Error("Request timeout")), ms);
-        });
-    }
-    async cacheResult(cacheKey, result) {
-        try {
-            await writeCache(cacheKey, result, {
-                ttl: this.config.cache?.defaultTTL || 300000,
-            });
-        }
-        catch (error) {
-            // Log cache write errors but don't fail the request
-            console.warn("Cache write failed:", error);
-        }
-    }
-    async sendCachedResponse(res, result, requestId, context) {
-        const responseTime = Date.now() - context.startTime;
-        res.setHeader("X-Cache", "HIT");
-        res.setHeader("X-Response-Time", `${responseTime}ms`);
-        res.setHeader("X-Request-ID", requestId);
-        res.json(result);
-    }
-    async sendProcessedResponse(res, result, requestId, context) {
-        const responseTime = Date.now() - context.startTime;
-        res.setHeader("X-Cache", "MISS");
-        res.setHeader("X-Response-Time", `${responseTime}ms`);
-        res.setHeader("X-Request-ID", requestId);
-        res.json(result);
-    }
-    sendErrorResponse(res, error, requestId) {
-        const statusCode = error.statusCode || 500;
-        res.status(statusCode).json({
-            error: error.message || "Internal server error",
-            requestId,
-            timestamp: Date.now(),
-        });
-    }
-    isCircuitOpen(pattern) {
-        const breaker = this.circuitBreaker.get(pattern);
-        return breaker?.isOpen || false;
-    }
-    recordSuccess(context, responseTime) {
-        this.stats.successfulRequests++;
-        this.stats.totalResponseTime += responseTime;
-        this.stats.avgResponseTime =
-            this.stats.totalResponseTime / this.stats.totalRequests;
-        this.updateRequestPattern(context, responseTime, true);
-    }
-    recordFailure(context, error, responseTime) {
-        this.stats.failedRequests++;
-        this.stats.totalResponseTime += responseTime;
-        this.stats.avgResponseTime =
-            this.stats.totalResponseTime / this.stats.totalRequests;
-        this.updateRequestPattern(context, responseTime, false);
-        this.updateCircuitBreaker(context.pattern);
-    }
-    updateRequestPattern(context, responseTime, success) {
-        const pattern = this.requestPatterns.get(context.pattern) ||
-            this.createNewPattern(context);
-        pattern.count++;
-        pattern.lastSeen = Date.now();
-        pattern.avgResponseTime = this.updateAverage(pattern.avgResponseTime, responseTime, pattern.count);
-        if (!success) {
-            pattern.errorCount++;
-            pattern.lastErrorTime = Date.now();
-        }
-        pattern.successRate =
-            ((pattern.count - pattern.errorCount) / pattern.count) * 100;
-        pattern.priority = this.calculateOptimizedPriority(pattern);
-        this.requestPatterns.set(context.pattern, pattern);
-    }
-    createNewPattern(context) {
-        return {
-            count: 0,
-            lastSeen: 0,
-            avgResponseTime: 0,
-            priority: 0,
-            method: context.pattern.split(":")[0],
-            path: context.pattern.split(":")[1],
-            frequency: 0,
-            trend: "stable",
-            successRate: 100,
-            errorCount: 0,
-            peakUsage: 0,
-            resourceUsage: { cpu: 0, memory: 0 },
-        };
-    }
-    updateCircuitBreaker(pattern) {
-        const breaker = this.circuitBreaker.get(pattern) || {
-            failures: 0,
-            lastFailure: 0,
-            isOpen: false,
-        };
-        breaker.failures++;
-        breaker.lastFailure = Date.now();
-        if (breaker.failures >= 5) {
-            // Open circuit after 5 failures
-            breaker.isOpen = true;
-        }
-        this.circuitBreaker.set(pattern, breaker);
-    }
-    determineTaskType(req) {
-        if (req.path.includes("/validate") || req.path.includes("/verify"))
-            return "validate";
-        switch (req.method) {
-            case "GET":
-            case "HEAD":
-                return "read";
-            case "POST":
-            case "PUT":
-            case "PATCH":
-                return "write";
-            case "DELETE":
-                return "delete";
-            default:
-                return "process";
-        }
-    }
-    calculateRequestPriority(req) {
-        let priority = 5; // Default priority
-        // Critical paths get highest priority
-        if (req.path.includes("/health") || req.path.includes("/status")) {
-            priority = 0;
-        }
-        else if (req.path.includes("/auth") || req.path.includes("/login")) {
-            priority = 1;
-        }
-        else if (req.path.includes("/api/admin")) {
-            priority = 2;
-        }
-        else if (req.method === "GET") {
-            priority = 3;
-        }
-        else if (req.method === "POST" || req.method === "PUT") {
-            priority = 4;
-        }
-        // Adjust based on content type
-        if (req.headers["content-type"]?.includes("application/json")) {
-            priority = Math.max(0, priority - 1);
-        }
-        return priority;
-    }
-    determineWorkerType(req) {
-        // CPU-intensive operations
-        const cpuPaths = [
-            "/validate",
-            "/compute",
-            "/transform",
-            "/encrypt",
-            "/hash",
-            "/compress",
-        ];
-        if (cpuPaths.some((path) => req.path.includes(path))) {
-            return "cpu";
-        }
-        // Default to I/O for database, file system, network operations
-        return "io";
-    }
-    generatePattern(req) {
-        return [
-            req.method,
-            req.route?.path || req.path,
-            req.headers["content-type"] || "",
-        ].join(":");
-    }
-    updateAverage(currentAvg, newValue, count) {
-        return (currentAvg * (count - 1) + newValue) / count;
-    }
-    sanitizeHeaders(headers) {
-        const sanitized = {};
-        const allowedHeaders = [
-            "content-type",
-            "accept",
-            "authorization",
-            "user-agent",
-            "x-forwarded-for",
-            "x-real-ip",
-            "accept-encoding",
-        ];
-        for (const key of allowedHeaders) {
-            if (headers[key]) {
-                sanitized[key] = String(headers[key]);
-            }
-        }
-        return sanitized;
-    }
-    getStats() {
-        const performanceMetrics = this.performanceMonitor.getMetrics();
-        const patternStats = this.getOptimizedPatternStats();
-        const workerPoolStats = this.workerPool.getStats();
-        const cacheStats = getCacheStats();
-        return {
-            cache: {
-                hits: this.stats.cacheHits,
-                misses: this.stats.cacheMisses,
-                hitRate: this.stats.totalRequests > 0
-                    ? (this.stats.cacheHits / this.stats.totalRequests) *
-                        100
-                    : 0,
-                stats: cacheStats,
-            },
-            requests: {
-                total: this.stats.totalRequests,
-                successful: this.stats.successfulRequests,
-                failed: this.stats.failedRequests,
-                successRate: this.stats.totalRequests > 0
-                    ? (this.stats.successfulRequests /
-                        this.stats.totalRequests) *
-                        100
-                    : 0,
-                avgResponseTime: this.stats.avgResponseTime,
-                currentConcurrency: this.stats.currentConcurrency,
-                peakConcurrency: this.stats.peakConcurrency,
-            },
-            patterns: patternStats,
-            performance: performanceMetrics,
-            workerPool: workerPoolStats,
-            circuitBreakers: {
-                total: this.circuitBreaker.size,
-                open: Array.from(this.circuitBreaker.values()).filter((b) => b.isOpen).length,
-            },
-            memory: {
-                activeRequests: this.activeRequests.size,
-                patterns: this.requestPatterns.size,
-                circuitBreakers: this.circuitBreaker.size,
-            },
-        };
-    }
-    getOptimizedPatternStats() {
-        const now = Date.now();
-        const activePatterns = Array.from(this.requestPatterns.values()).filter((pattern) => now - pattern.lastSeen < 600000);
-        const hotPatterns = activePatterns.filter((p) => p.priority > (this.config.prediction?.hotPatternThreshold || 50));
-        return {
-            totalPatterns: this.requestPatterns.size,
-            activePatterns: activePatterns.length,
-            hotPatterns: hotPatterns.length,
-            avgSuccessRate: activePatterns.length > 0
-                ? activePatterns.reduce((sum, p) => sum + p.successRate, 0) / activePatterns.length
-                : 100,
-            avgResponseTime: activePatterns.length > 0
-                ? activePatterns.reduce((sum, p) => sum + p.avgResponseTime, 0) / activePatterns.length
-                : 0,
-            topPatterns: hotPatterns
-                .sort((a, b) => b.priority - a.priority)
-                .slice(0, 10)
-                .map((p) => ({
-                method: p.method,
-                path: p.path,
-                priority: p.priority,
-                successRate: p.successRate,
-                avgResponseTime: p.avgResponseTime,
-                frequency: p.frequency,
-            })),
-        };
-    }
-    async destroy() {
-        this.isShuttingDown = true;
-        try {
-            // Wait for active requests to complete (with timeout)
-            const maxWaitTime = 30000; // 30 seconds
-            const checkInterval = 100;
-            let waited = 0;
-            while (this.activeRequests.size > 0 && waited < maxWaitTime) {
-                await new Promise((resolve) => setTimeout(resolve, checkInterval));
-                waited += checkInterval;
-            }
-            // Clear all intervals
-            this.intervals.forEach((interval) => clearInterval(interval));
-            this.intervals = [];
-            // Stop performance monitor
-            this.performanceMonitor.stop();
-            // Note: WorkerPool doesn't require explicit shutdown as it doesn't create actual worker threads
-            // Clear all maps
-            this.requestPatterns.clear();
-            this.activeRequests.clear();
-            this.circuitBreaker.clear();
-            console.log("UltraFastRequestProcessor shutdown complete");
-        }
-        catch (error) {
-            console.error("Error during shutdown:", error);
-        }
-    }
-}
-
-export { UltraFastRequestProcessor };
-//# sourceMappingURL=UltraFastRequestProcessor.js.map