@lazyneoaz/testfca 1.0.0

package/src/utils/monitoring.js

@@ -0,0 +1,333 @@
+"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

@@ -0,0 +1,319 @@
+"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) { // Reduced delays
+        const delay = Math.floor(Math.random() * (max - min + 1)) + min;
+        await new Promise(resolve => setTimeout(resolve, delay));
+    }
+
+    /**
+     * 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()
+};