@cexy/hoonfca 1.0.1 → 1.0.3

package/src/utils/monitoring.js

@@ -1,333 +0,0 @@
-"use strict";
-
-const utils = require('./index');
-
-class ProductionMonitor {
-    constructor() {
-        this.metrics = {
-            requests: {
-                total: 0,
-                success: 0,
-                failed: 0,
-                byEndpoint: new Map()
-            },
-            errors: {
-                total: 0,
-                byType: new Map(),
-                byCode: new Map(),
-                recent: []
-            },
-            performance: {
-                avgResponseTime: 0,
-                slowRequests: [],
-                requestTimes: []
-            },
-            session: {
-                loginTime: null,
-                lastActivity: null,
-                tokenRefreshCount: 0,
-                reconnectCount: 0
-            },
-            rateLimiting: {
-                hitCount: 0,
-                cooldowns: 0,
-                delayedRequests: 0
-            }
-        };
-        
-        this.config = {
-            logLevel: 'info',
-            enableMetrics: true,
-            enableErrorTracking: true,
-            performanceThreshold: 5000,
-            errorRetentionCount: 100,
-            metricsInterval: 60000
-        };
-        
-        this.startTime = Date.now();
-        this.metricsInterval = null;
-    }
-
-    setConfig(options) {
-        Object.assign(this.config, options);
-    }
-
-    trackRequest(endpoint, success, responseTime, error = null) {
-        if (!this.config.enableMetrics) return;
-        
-        this.metrics.requests.total++;
-        if (success) {
-            this.metrics.requests.success++;
-        } else {
-            this.metrics.requests.failed++;
-        }
-        
-        if (!this.metrics.requests.byEndpoint.has(endpoint)) {
-            this.metrics.requests.byEndpoint.set(endpoint, {
-                total: 0,
-                success: 0,
-                failed: 0,
-                avgTime: 0
-            });
-        }
-        
-        const endpointStats = this.metrics.requests.byEndpoint.get(endpoint);
-        endpointStats.total++;
-        if (success) {
-            endpointStats.success++;
-        } else {
-            endpointStats.failed++;
-        }
-        
-        endpointStats.avgTime = 
-            (endpointStats.avgTime * (endpointStats.total - 1) + responseTime) / endpointStats.total;
-        
-        this.trackPerformance(endpoint, responseTime);
-        
-        if (error) {
-            this.trackError(error, endpoint);
-        }
-        
-        this.metrics.session.lastActivity = Date.now();
-    }
-
-    trackPerformance(endpoint, responseTime) {
-        this.metrics.performance.requestTimes.push(responseTime);
-        
-        if (this.metrics.performance.requestTimes.length > 1000) {
-            this.metrics.performance.requestTimes.shift();
-        }
-        
-        const sum = this.metrics.performance.requestTimes.reduce((a, b) => a + b, 0);
-        this.metrics.performance.avgResponseTime = 
-            sum / this.metrics.performance.requestTimes.length;
-        
-        if (responseTime > this.config.performanceThreshold) {
-            this.metrics.performance.slowRequests.push({
-                endpoint,
-                responseTime,
-                timestamp: Date.now()
-            });
-            
-            if (this.metrics.performance.slowRequests.length > 50) {
-                this.metrics.performance.slowRequests.shift();
-            }
-            
-            utils.warn("Performance", `Slow request: ${endpoint} took ${responseTime}ms`);
-        }
-    }
-
-    trackError(error, context = '') {
-        if (!this.config.enableErrorTracking) return;
-        
-        this.metrics.errors.total++;
-        
-        const errorType = error.errorType || error.name || 'UnknownError';
-        const errorCode = error.errorCode || error.code || 'N/A';
-        
-        this.metrics.errors.byType.set(
-            errorType,
-            (this.metrics.errors.byType.get(errorType) || 0) + 1
-        );
-        
-        this.metrics.errors.byCode.set(
-            errorCode,
-            (this.metrics.errors.byCode.get(errorCode) || 0) + 1
-        );
-        
-        this.metrics.errors.recent.push({
-            type: errorType,
-            code: errorCode,
-            message: error.message,
-            context,
-            timestamp: Date.now(),
-            stack: error.stack
-        });
-        
-        if (this.metrics.errors.recent.length > this.config.errorRetentionCount) {
-            this.metrics.errors.recent.shift();
-        }
-    }
-
-    trackRateLimit(type, threadID = null) {
-        this.metrics.rateLimiting.hitCount++;
-        
-        if (type === 'cooldown') {
-            this.metrics.rateLimiting.cooldowns++;
-        } else if (type === 'delayed') {
-            this.metrics.rateLimiting.delayedRequests++;
-        }
-    }
-
-    trackTokenRefresh() {
-        this.metrics.session.tokenRefreshCount++;
-    }
-
-    trackReconnect() {
-        this.metrics.session.reconnectCount++;
-    }
-
-    setLoginTime() {
-        this.metrics.session.loginTime = Date.now();
-    }
-
-    getMetrics() {
-        const uptime = Date.now() - this.startTime;
-        const sessionDuration = this.metrics.session.loginTime 
-            ? Date.now() - this.metrics.session.loginTime 
-            : 0;
-        
-        return {
-            uptime,
-            sessionDuration,
-            requests: {
-                ...this.metrics.requests,
-                byEndpoint: Object.fromEntries(this.metrics.requests.byEndpoint),
-                successRate: this.metrics.requests.total > 0
-                    ? (this.metrics.requests.success / this.metrics.requests.total * 100).toFixed(2) + '%'
-                    : 'N/A'
-            },
-            errors: {
-                ...this.metrics.errors,
-                byType: Object.fromEntries(this.metrics.errors.byType),
-                byCode: Object.fromEntries(this.metrics.errors.byCode),
-                errorRate: this.metrics.requests.total > 0
-                    ? (this.metrics.errors.total / this.metrics.requests.total * 100).toFixed(2) + '%'
-                    : 'N/A'
-            },
-            performance: this.metrics.performance,
-            session: this.metrics.session,
-            rateLimiting: this.metrics.rateLimiting
-        };
-    }
-
-    getHealth() {
-        const metrics = this.getMetrics();
-        const health = {
-            status: 'healthy',
-            checks: {},
-            timestamp: Date.now()
-        };
-        
-        const errorRate = this.metrics.requests.total > 0
-            ? (this.metrics.errors.total / this.metrics.requests.total) * 100
-            : 0;
-        
-        health.checks.errorRate = {
-            status: errorRate < 5 ? 'pass' : errorRate < 15 ? 'warn' : 'fail',
-            value: errorRate.toFixed(2) + '%',
-            threshold: '5%'
-        };
-        
-        health.checks.performance = {
-            status: this.metrics.performance.avgResponseTime < 2000 ? 'pass' : 
-                    this.metrics.performance.avgResponseTime < 5000 ? 'warn' : 'fail',
-            value: Math.round(this.metrics.performance.avgResponseTime) + 'ms',
-            threshold: '2000ms'
-        };
-        
-        health.checks.session = {
-            status: this.metrics.session.loginTime ? 'pass' : 'fail',
-            value: this.metrics.session.loginTime ? 'active' : 'not logged in'
-        };
-        
-        health.checks.rateLimiting = {
-            status: this.metrics.rateLimiting.hitCount < 100 ? 'pass' : 
-                    this.metrics.rateLimiting.hitCount < 500 ? 'warn' : 'fail',
-            value: this.metrics.rateLimiting.hitCount,
-            threshold: '100 hits'
-        };
-        
-        const failedChecks = Object.values(health.checks).filter(c => c.status === 'fail').length;
-        const warnChecks = Object.values(health.checks).filter(c => c.status === 'warn').length;
-        
-        if (failedChecks > 0) {
-            health.status = 'unhealthy';
-        } else if (warnChecks > 0) {
-            health.status = 'degraded';
-        }
-        
-        return health;
-    }
-
-    reset() {
-        this.metrics.requests.total = 0;
-        this.metrics.requests.success = 0;
-        this.metrics.requests.failed = 0;
-        this.metrics.requests.byEndpoint.clear();
-        this.metrics.errors.total = 0;
-        this.metrics.errors.byType.clear();
-        this.metrics.errors.byCode.clear();
-        this.metrics.errors.recent = [];
-        this.metrics.performance.slowRequests = [];
-        this.metrics.performance.requestTimes = [];
-        this.metrics.rateLimiting.hitCount = 0;
-        this.metrics.rateLimiting.cooldowns = 0;
-        this.metrics.rateLimiting.delayedRequests = 0;
-        
-        utils.success("Monitoring", "All metrics have been reset successfully");
-    }
-
-    displayHealthStatus() {
-        const health = this.getHealth();
-        console.log('\n' + '='.repeat(60));
-        if (health.status === 'healthy') {
-            console.log('SYSTEM HEALTH: HEALTHY');
-        } else if (health.status === 'degraded') {
-            console.log('SYSTEM HEALTH: DEGRADED');
-        } else {
-            console.log('SYSTEM HEALTH: UNHEALTHY');
-        }
-        console.log('='.repeat(60));
-        Object.entries(health.checks).forEach(([name, check]) => {
-            const nameFormatted = name.charAt(0).toUpperCase() + name.slice(1);
-            console.log(`\n${nameFormatted}:`);
-            console.log(`  Status: ${check.status.toUpperCase()}`);
-            console.log(`  Value: ${check.value}`);
-            if (check.threshold) {
-                console.log(`  Threshold: ${check.threshold}`);
-            }
-        });
-        console.log('\n' + '='.repeat(60) + '\n');
-        return health;
-    }
-
-    startPeriodicReporting(interval = 60000) {
-        if (this.metricsInterval) {
-            clearInterval(this.metricsInterval);
-        }
-        
-        this.metricsInterval = setInterval(() => {
-            const metrics = this.getMetrics();
-            console.log('\n' + '='.repeat(60));
-            console.log('PERFORMANCE METRICS REPORT');
-            console.log('='.repeat(60));
-            console.log('\nRequests:');
-            console.log(`  Total: ${metrics.requests.total}`);
-            console.log(`  Success Rate: ${metrics.requests.successRate}`);
-            console.log('\nErrors:');
-            console.log(`  Total: ${metrics.errors.total}`);
-            console.log(`  Error Rate: ${metrics.errors.errorRate}`);
-            console.log('\nPerformance:');
-            const avgTime = Math.round(metrics.performance.avgResponseTime);
-            console.log(`  Avg Response Time: ${avgTime}ms`);
-            console.log('\nRate Limiting:');
-            console.log(`  Total Hits: ${metrics.rateLimiting.hitCount}`);
-            console.log('='.repeat(60) + '\n');
-        }, interval);
-    }
-
-    stopPeriodicReporting() {
-        if (this.metricsInterval) {
-            clearInterval(this.metricsInterval);
-            this.metricsInterval = null;
-        }
-    }
-}
-
-const globalMonitor = new ProductionMonitor();
-
-module.exports = {
-    ProductionMonitor,
-    globalMonitor
-};

package/src/utils/rateLimiter.js

@@ -1,319 +0,0 @@
-"use strict";
-
-/**
- * Adaptive Rate Limiting Manager - Optimized for Performance
- * Sliding-window per-minute and per-second rate limiting to prevent
- * Facebook from flagging automated behaviour.
- */
-
-class RateLimiter {
-    constructor() {
-        this.threadCooldowns = new Map();
-        this.endpointCooldowns = new Map();
-        this.errorCache = new Map();
-
-        this.ERROR_CACHE_TTL = 300000;
-        this.COOLDOWN_DURATION = 60000;
-        this.MAX_REQUESTS_PER_MINUTE = 80; // Increased from 50 for better throughput
-        this.MAX_CONCURRENT_REQUESTS = 8; // Increased from 5
-
-        this.activeRequests = 0;
-
-        // Sliding window: store timestamps of recent requests
-        this._requestWindow = [];
-        this._WINDOW_MS = 60000;
-
-        // Per-endpoint sliding windows
-        this._endpointWindows = new Map();
-        this._MAX_PER_ENDPOINT_PER_MINUTE = 30; // Increased from 20
-        
-        // Fast path cache for cooldown checks
-        this._cooldownCache = new Map();
-        this._COOLDOWN_CACHE_TTL = 500; // 500ms cache for cooldown checks
-    }
-
-    configure(opts = {}) {
-        if (typeof opts.maxConcurrentRequests === 'number' && opts.maxConcurrentRequests > 0 && opts.maxConcurrentRequests <= 50) {
-            this.MAX_CONCURRENT_REQUESTS = Math.floor(opts.maxConcurrentRequests);
-        }
-        if (typeof opts.maxRequestsPerMinute === 'number' && opts.maxRequestsPerMinute > 0 && opts.maxRequestsPerMinute <= 1000) {
-            this.MAX_REQUESTS_PER_MINUTE = Math.floor(opts.maxRequestsPerMinute);
-        }
-        if (typeof opts.requestCooldownMs === 'number' && opts.requestCooldownMs >= 0 && opts.requestCooldownMs <= 10 * 60 * 1000) {
-            this.COOLDOWN_DURATION = Math.floor(opts.requestCooldownMs);
-        }
-        if (typeof opts.errorCacheTtlMs === 'number' && opts.errorCacheTtlMs >= 0 && opts.errorCacheTtlMs <= 24 * 60 * 60 * 1000) {
-            this.ERROR_CACHE_TTL = Math.floor(opts.errorCacheTtlMs);
-        }
-    }
-
-    // ─── Thread cooldowns ─────────────────────────────────────────────────────
-
-    isThreadOnCooldown(threadID) {
-        const now = Date.now();
-        // Fast path: check cache first
-        const cacheKey = `t:${threadID}`;
-        const cached = this._cooldownCache.get(cacheKey);
-        if (cached && now - cached.ts < this._COOLDOWN_CACHE_TTL) {
-            return cached.result;
-        }
-        
-        const cooldownEnd = this.threadCooldowns.get(threadID);
-        let result = false;
-        if (!cooldownEnd) {
-            result = false;
-        } else if (now >= cooldownEnd) {
-            this.threadCooldowns.delete(threadID);
-            result = false;
-        } else {
-            result = true;
-        }
-        
-        this._cooldownCache.set(cacheKey, { ts: now, result });
-        return result;
-    }
-
-    setThreadCooldown(threadID, duration = null) {
-        this.threadCooldowns.set(threadID, Date.now() + (duration || this.COOLDOWN_DURATION));
-        // Invalidate cache
-        this._cooldownCache.delete(`t:${threadID}`);
-    }
-
-    // ─── Endpoint cooldowns ───────────────────────────────────────────────────
-
-    isEndpointOnCooldown(endpoint) {
-        const now = Date.now();
-        // Fast path: check cache
-        const cacheKey = `e:${endpoint}`;
-        const cached = this._cooldownCache.get(cacheKey);
-        if (cached && now - cached.ts < this._COOLDOWN_CACHE_TTL) {
-            return cached.result;
-        }
-        
-        const cooldownEnd = this.endpointCooldowns.get(endpoint);
-        let result = false;
-        if (!cooldownEnd) {
-            result = false;
-        } else if (now >= cooldownEnd) {
-            this.endpointCooldowns.delete(endpoint);
-            result = false;
-        } else {
-            result = true;
-        }
-        
-        this._cooldownCache.set(cacheKey, { ts: now, result });
-        return result;
-    }
-
-    setEndpointCooldown(endpoint, duration = null) {
-        this.endpointCooldowns.set(endpoint, Date.now() + (duration || this.COOLDOWN_DURATION));
-        this._cooldownCache.delete(`e:${endpoint}`);
-    }
-
-    // ─── Error suppression ────────────────────────────────────────────────────
-
-    shouldSuppressError(key) {
-        const cachedTime = this.errorCache.get(key);
-        if (!cachedTime) {
-            this.errorCache.set(key, Date.now());
-            return false;
-        }
-        if (Date.now() - cachedTime > this.ERROR_CACHE_TTL) {
-            this.errorCache.set(key, Date.now());
-            return false;
-        }
-        return true;
-    }
-
-    // ─── Sliding-window rate checking ─────────────────────────────────────────
-
-    /**
-     * Prune timestamps older than the window and return the current count.
-     * Optimized with batch pruning.
-     */
-    _pruneWindow(arr) {
-        const cutoff = Date.now() - this._WINDOW_MS;
-        // Binary search for the first valid timestamp
-        let left = 0, right = arr.length;
-        while (left < right) {
-            const mid = Math.floor((left + right) / 2);
-            if (arr[mid] < cutoff) {
-                left = mid + 1;
-            } else {
-                right = mid;
-            }
-        }
-        if (left > 0) {
-            arr.splice(0, left);
-        }
-        return arr.length;
-    }
-
-    isGloballyRateLimited() {
-        const count = this._pruneWindow(this._requestWindow);
-        return count >= this.MAX_REQUESTS_PER_MINUTE;
-    }
-
-    isEndpointRateLimited(endpoint) {
-        if (!this._endpointWindows.has(endpoint)) return false;
-        const count = this._pruneWindow(this._endpointWindows.get(endpoint));
-        return count >= this._MAX_PER_ENDPOINT_PER_MINUTE;
-    }
-
-    _recordRequest(endpoint) {
-        const now = Date.now();
-        this._requestWindow.push(now);
-        // Prune less frequently for better performance
-        if (this._requestWindow.length > this.MAX_REQUESTS_PER_MINUTE * 3) {
-            this._pruneWindow(this._requestWindow);
-        }
-        if (endpoint) {
-            if (!this._endpointWindows.has(endpoint)) {
-                this._endpointWindows.set(endpoint, []);
-            }
-            const ew = this._endpointWindows.get(endpoint);
-            ew.push(now);
-            if (ew.length > this._MAX_PER_ENDPOINT_PER_MINUTE * 3) {
-                this._pruneWindow(ew);
-            }
-        }
-    }
-
-    // ─── Adaptive delay ───────────────────────────────────────────────────────
-
-    getAdaptiveDelay(retryCount, errorCode = null) {
-        const baseDelays = [1000, 2500, 5000, 10000]; // Reduced base delays
-        const base = baseDelays[Math.min(retryCount, baseDelays.length - 1)];
-
-        if (errorCode === 1545012 || errorCode === 1675004) {
-            return base * 1.5; // Reduced from 2x
-        }
-        if (errorCode === 368 || errorCode === 10) {
-            return base * 2; // Reduced from 3x
-        }
-        return base;
-    }
-
-    async addHumanizedDelay(min = 100, max = 350) {
-        // Speed mode: humanized send delay disabled — no artificial wait.
-        return;
-    }
-
-    /**
-     * Check global and concurrent rate limits.
-     * Will wait until below limit, then record the request.
-     */
-    async checkRateLimit(skipHumanDelay = false, endpoint = null) {
-        // Fast path: try immediate slot acquisition
-        if (this.activeRequests < this.MAX_CONCURRENT_REQUESTS) {
-            if (!this.isGloballyRateLimited()) {
-                if (!endpoint || !this.isEndpointRateLimited(endpoint)) {
-                    if (!skipHumanDelay) {
-                        await this.addHumanizedDelay();
-                    }
-                    this.activeRequests++;
-                    this._recordRequest(endpoint);
-                    return () => {
-                        this.activeRequests = Math.max(0, this.activeRequests - 1);
-                    };
-                }
-            }
-        }
-
-        // Slow path: wait for slot
-        while (this.activeRequests >= this.MAX_CONCURRENT_REQUESTS) {
-            await new Promise(resolve => setTimeout(resolve, 50)); // Reduced from 100ms
-        }
-
-        // Wait for per-minute global window to clear
-        let waitCycles = 0;
-        const maxCycles = 120; // Increased from 60
-        while (this.isGloballyRateLimited()) {
-            if (waitCycles++ > maxCycles) break;
-            await new Promise(resolve => setTimeout(resolve, 500)); // Reduced from 1000ms
-        }
-
-        // Wait for per-endpoint window to clear
-        if (endpoint) {
-            let epCycles = 0;
-            const maxEpCycles = 60; // Increased from 30
-            while (this.isEndpointRateLimited(endpoint)) {
-                if (epCycles++ > maxEpCycles) break;
-                await new Promise(resolve => setTimeout(resolve, 500));
-            }
-        }
-
-        if (!skipHumanDelay) {
-            await this.addHumanizedDelay();
-        }
-
-        this.activeRequests++;
-        this._recordRequest(endpoint);
-
-        return () => {
-            this.activeRequests = Math.max(0, this.activeRequests - 1);
-        };
-    }
-
-    // ─── Cleanup ──────────────────────────────────────────────────────────────
-
-    cleanup() {
-        const now = Date.now();
-
-        for (const [key, time] of this.errorCache.entries()) {
-            if (now - time > this.ERROR_CACHE_TTL) this.errorCache.delete(key);
-        }
-        for (const [key, time] of this.threadCooldowns.entries()) {
-            if (now >= time) this.threadCooldowns.delete(key);
-        }
-        for (const [key, time] of this.endpointCooldowns.entries()) {
-            if (now >= time) this.endpointCooldowns.delete(key);
-        }
-
-        // Prune all endpoint windows
-        for (const [key, arr] of this._endpointWindows.entries()) {
-            this._pruneWindow(arr);
-            if (arr.length === 0) this._endpointWindows.delete(key);
-        }
-        this._pruneWindow(this._requestWindow);
-        
-        // Clear cooldown cache
-        this._cooldownCache.clear();
-    }
-
-    getStats() {
-        this._pruneWindow(this._requestWindow);
-        return {
-            activeRequests: this.activeRequests,
-            maxConcurrentRequests: this.MAX_CONCURRENT_REQUESTS,
-            maxRequestsPerMinute: this.MAX_REQUESTS_PER_MINUTE,
-            requestsInLastMinute: this._requestWindow.length,
-            threadCooldowns: this.threadCooldowns.size,
-            endpointCooldowns: this.endpointCooldowns.size,
-            errorCacheSize: this.errorCache.size
-        };
-    }
-
-    getCooldownRemaining(threadID) {
-        const cooldownEnd = this.threadCooldowns.get(threadID);
-        if (!cooldownEnd) return 0;
-        return Math.max(0, cooldownEnd - Date.now());
-    }
-
-    getEndpointCooldownRemaining(endpoint) {
-        const cooldownEnd = this.endpointCooldowns.get(endpoint);
-        if (!cooldownEnd) return 0;
-        return Math.max(0, cooldownEnd - Date.now());
-    }
-}
-
-const globalRateLimiter = new RateLimiter();
-
-setInterval(() => globalRateLimiter.cleanup(), 60000);
-
-module.exports = {
-    RateLimiter,
-    globalRateLimiter,
-    configureRateLimiter: (opts) => globalRateLimiter.configure(opts),
-    getRateLimiterStats: () => globalRateLimiter.getStats()
-};