snow-flow 1.1.0

package/dist/api/performance-optimizer.js

@@ -0,0 +1,701 @@
+"use strict";
+/**
+ * Performance Optimization and Caching Strategy
+ * Advanced caching and performance optimization for ServiceNow API calls
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceOptimizer = void 0;
+const logger_js_1 = require("../utils/logger.js");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class PerformanceOptimizer {
+    constructor(client, config) {
+        this.cache = new Map();
+        this.batchQueue = new Map();
+        this.rateLimiter = new Map();
+        this.connectionPool = new Map();
+        this.client = client;
+        this.logger = new logger_js_1.Logger('PerformanceOptimizer');
+        this.config = {
+            max_size: 1000,
+            default_ttl: 300000, // 5 minutes
+            cleanup_interval: 60000, // 1 minute
+            persistence_enabled: true,
+            compression_enabled: true,
+            ...config
+        };
+        this.metrics = {
+            cache_hit_rate: 0,
+            cache_miss_rate: 0,
+            average_response_time: 0,
+            api_call_count: 0,
+            cache_size: 0,
+            memory_usage: 0,
+            bandwidth_saved: 0
+        };
+        this.startCleanupTimer();
+        this.loadPersistedCache();
+    }
+    /**
+     * Optimized API call with caching and performance monitoring
+     */
+    async optimizedAPICall(request) {
+        const startTime = Date.now();
+        const cacheKey = request.cache_key || this.generateCacheKey(request);
+        // Check cache first
+        if (request.cacheable) {
+            const cached = this.getFromCache(cacheKey);
+            if (cached) {
+                const responseTime = Date.now() - startTime;
+                this.updateMetrics(true, responseTime);
+                return {
+                    success: true,
+                    data: cached,
+                    cached: true,
+                    response_time: responseTime,
+                    cache_hit: true
+                };
+            }
+        }
+        // Apply rate limiting
+        if (this.isRateLimited(request.url)) {
+            await this.waitForRateLimit(request.url);
+        }
+        try {
+            // Execute API call
+            const response = await this.executeAPICall(request);
+            const responseTime = Date.now() - startTime;
+            // Cache successful responses
+            if (request.cacheable && response.success && response.data) {
+                this.setInCache(cacheKey, response.data, {
+                    ttl: this.getTTLForRequest(request),
+                    tags: this.getTagsForRequest(request)
+                });
+            }
+            this.updateMetrics(false, responseTime);
+            return {
+                ...response,
+                cached: false,
+                response_time: responseTime,
+                cache_hit: false
+            };
+        }
+        catch (error) {
+            const responseTime = Date.now() - startTime;
+            this.updateMetrics(false, responseTime);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                cached: false,
+                response_time: responseTime,
+                cache_hit: false
+            };
+        }
+    }
+    /**
+     * Batch multiple API requests for better performance
+     */
+    async batchAPIRequests(requests) {
+        const batchId = this.generateBatchId();
+        const batchRequest = {
+            id: batchId,
+            requests: requests.sort((a, b) => b.priority - a.priority),
+            priority: 'medium',
+            timeout: 30000,
+            retry_count: 0
+        };
+        this.batchQueue.set(batchId, batchRequest);
+        try {
+            // Group requests by type for optimization
+            const groupedRequests = this.groupRequestsByType(requests);
+            const results = [];
+            // Execute groups in parallel
+            const groupPromises = Object.entries(groupedRequests).map(async ([type, groupRequests]) => {
+                return await this.executeBatchGroup(groupRequests, type);
+            });
+            const groupResults = await Promise.all(groupPromises);
+            // Flatten results
+            for (const groupResult of groupResults) {
+                results.push(...groupResult);
+            }
+            return results;
+        }
+        finally {
+            this.batchQueue.delete(batchId);
+        }
+    }
+    /**
+     * Preload commonly accessed data
+     */
+    async preloadData(preloadConfig) {
+        const preloadTasks = [];
+        if (preloadConfig.action_types) {
+            preloadTasks.push(this.preloadActionTypes());
+        }
+        if (preloadConfig.trigger_types) {
+            preloadTasks.push(this.preloadTriggerTypes());
+        }
+        if (preloadConfig.flow_templates) {
+            preloadTasks.push(this.preloadFlowTemplates());
+        }
+        if (preloadConfig.user_preferences) {
+            preloadTasks.push(this.preloadUserPreferences());
+        }
+        await Promise.all(preloadTasks);
+        this.logger.info('Data preloading completed');
+    }
+    /**
+     * Analyze performance and provide optimization suggestions
+     */
+    analyzePerformance() {
+        const bottlenecks = [];
+        const optimizationHints = [];
+        // Analyze cache hit rate
+        if (this.metrics.cache_hit_rate < 0.5) {
+            bottlenecks.push('Low cache hit rate');
+            optimizationHints.push({
+                type: 'cache',
+                description: 'Increase cache TTL for frequently accessed data',
+                estimated_improvement: 0.3,
+                implementation_complexity: 'low'
+            });
+        }
+        // Analyze response times
+        if (this.metrics.average_response_time > 2000) {
+            bottlenecks.push('High response times');
+            optimizationHints.push({
+                type: 'parallel',
+                description: 'Implement parallel processing for independent requests',
+                estimated_improvement: 0.5,
+                implementation_complexity: 'medium'
+            });
+        }
+        // Analyze cache size
+        if (this.cache.size > this.config.max_size * 0.8) {
+            bottlenecks.push('Cache nearing capacity');
+            optimizationHints.push({
+                type: 'compress',
+                description: 'Enable compression for cached data',
+                estimated_improvement: 0.4,
+                implementation_complexity: 'medium'
+            });
+        }
+        // Analyze API call patterns
+        const batchableRequests = this.identifyBatchableRequests();
+        if (batchableRequests.length > 0) {
+            optimizationHints.push({
+                type: 'batch',
+                description: `Batch ${batchableRequests.length} similar requests`,
+                estimated_improvement: 0.6,
+                implementation_complexity: 'high'
+            });
+        }
+        return {
+            metrics: this.metrics,
+            bottlenecks,
+            optimization_hints: optimizationHints
+        };
+    }
+    /**
+     * Implement adaptive caching based on usage patterns
+     */
+    optimizeCaching() {
+        const cacheAnalysis = this.analyzeCacheUsage();
+        // Adjust TTL based on access patterns
+        for (const [key, entry] of this.cache) {
+            const accessFrequency = entry.access_count / (Date.now() - entry.timestamp.getTime());
+            if (accessFrequency > 0.01) { // Frequently accessed
+                entry.ttl = this.config.default_ttl * 2;
+            }
+            else if (accessFrequency < 0.001) { // Rarely accessed
+                entry.ttl = this.config.default_ttl * 0.5;
+            }
+        }
+        // Implement cache warming for predicted requests
+        this.warmCache(cacheAnalysis.predicted_requests);
+    }
+    /**
+     * Get from cache with LRU eviction
+     */
+    getFromCache(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return null;
+        }
+        // Check if expired
+        if (Date.now() - entry.timestamp.getTime() > entry.ttl) {
+            this.cache.delete(key);
+            return null;
+        }
+        // Update access statistics
+        entry.access_count++;
+        entry.last_accessed = new Date();
+        return entry.value;
+    }
+    /**
+     * Set in cache with size management
+     */
+    setInCache(key, value, options = {}) {
+        // Check if cache is full
+        if (this.cache.size >= this.config.max_size) {
+            this.evictLeastRecent();
+        }
+        const entry = {
+            key,
+            value,
+            timestamp: new Date(),
+            ttl: options.ttl || this.config.default_ttl,
+            access_count: 1,
+            last_accessed: new Date(),
+            tags: options.tags || [],
+            size: this.estimateSize(value)
+        };
+        this.cache.set(key, entry);
+        this.updateCacheMetrics();
+    }
+    /**
+     * Execute API call with connection pooling
+     */
+    async executeAPICall(request) {
+        const connection = this.getPooledConnection(request.url);
+        try {
+            let response;
+            switch (request.method) {
+                case 'GET':
+                    response = await this.client.getRecords(this.extractTable(request.url), request.data);
+                    break;
+                case 'POST':
+                    response = await this.client.createRecord(this.extractTable(request.url), request.data);
+                    break;
+                case 'PUT':
+                case 'PATCH':
+                    response = await this.client.updateRecord(this.extractTable(request.url), request.data.sys_id, request.data);
+                    break;
+                case 'DELETE':
+                    response = await this.client.deleteRecord(this.extractTable(request.url), request.data.sys_id);
+                    break;
+                default:
+                    throw new Error(`Unsupported method: ${request.method}`);
+            }
+            return {
+                success: response.success,
+                data: response.data,
+                error: response.error
+            };
+        }
+        finally {
+            this.returnPooledConnection(request.url, connection);
+        }
+    }
+    /**
+     * Group requests by type for batch processing
+     */
+    groupRequestsByType(requests) {
+        const groups = {};
+        for (const request of requests) {
+            const type = `${request.method}_${this.extractTable(request.url)}`;
+            if (!groups[type]) {
+                groups[type] = [];
+            }
+            groups[type].push(request);
+        }
+        return groups;
+    }
+    /**
+     * Execute batch group with parallel processing
+     */
+    async executeBatchGroup(requests, type) {
+        const batchSize = this.getBatchSizeForType(type);
+        const results = [];
+        // Process requests in batches
+        for (let i = 0; i < requests.length; i += batchSize) {
+            const batch = requests.slice(i, i + batchSize);
+            const batchPromises = batch.map(request => this.optimizedAPICall(request));
+            const batchResults = await Promise.all(batchPromises);
+            results.push(...batchResults);
+        }
+        return results;
+    }
+    /**
+     * Preload action types
+     */
+    async preloadActionTypes() {
+        const request = {
+            id: 'preload_action_types',
+            method: 'GET',
+            url: '/api/now/table/sys_hub_action_type_base',
+            cacheable: true,
+            priority: 1
+        };
+        await this.optimizedAPICall(request);
+    }
+    /**
+     * Preload trigger types
+     */
+    async preloadTriggerTypes() {
+        const request = {
+            id: 'preload_trigger_types',
+            method: 'GET',
+            url: '/api/now/table/sys_hub_trigger_type',
+            cacheable: true,
+            priority: 1
+        };
+        await this.optimizedAPICall(request);
+    }
+    /**
+     * Preload flow templates
+     */
+    async preloadFlowTemplates() {
+        const request = {
+            id: 'preload_flow_templates',
+            method: 'GET',
+            url: '/api/now/table/sys_hub_flow_template',
+            cacheable: true,
+            priority: 1
+        };
+        await this.optimizedAPICall(request);
+    }
+    /**
+     * Preload user preferences
+     */
+    async preloadUserPreferences() {
+        const request = {
+            id: 'preload_user_preferences',
+            method: 'GET',
+            url: '/api/now/table/sys_user_preference',
+            cacheable: true,
+            priority: 1
+        };
+        await this.optimizedAPICall(request);
+    }
+    /**
+     * Analyze cache usage patterns
+     */
+    analyzeCacheUsage() {
+        const sortedEntries = Array.from(this.cache.entries())
+            .sort((a, b) => b[1].access_count - a[1].access_count);
+        const mostAccessed = sortedEntries.slice(0, 10).map(([key]) => key);
+        const leastAccessed = sortedEntries.slice(-10).map(([key]) => key);
+        // Predict likely requests based on patterns
+        const predictedRequests = this.predictLikelyRequests(mostAccessed);
+        return {
+            most_accessed: mostAccessed,
+            least_accessed: leastAccessed,
+            predicted_requests: predictedRequests
+        };
+    }
+    /**
+     * Warm cache with predicted requests
+     */
+    async warmCache(predictedRequests) {
+        const warmingTasks = predictedRequests.map(async (cacheKey) => {
+            if (!this.cache.has(cacheKey)) {
+                const request = this.reconstructRequestFromCacheKey(cacheKey);
+                if (request) {
+                    await this.optimizedAPICall(request);
+                }
+            }
+        });
+        await Promise.all(warmingTasks);
+    }
+    /**
+     * Evict least recently used entries
+     */
+    evictLeastRecent() {
+        const entries = Array.from(this.cache.entries())
+            .sort((a, b) => a[1].last_accessed.getTime() - b[1].last_accessed.getTime());
+        const entriesToEvict = entries.slice(0, Math.ceil(this.config.max_size * 0.1));
+        for (const [key] of entriesToEvict) {
+            this.cache.delete(key);
+        }
+    }
+    /**
+     * Update performance metrics
+     */
+    updateMetrics(cacheHit, responseTime) {
+        this.metrics.api_call_count++;
+        if (cacheHit) {
+            this.metrics.cache_hit_rate = (this.metrics.cache_hit_rate * (this.metrics.api_call_count - 1) + 1) / this.metrics.api_call_count;
+        }
+        else {
+            this.metrics.cache_miss_rate = (this.metrics.cache_miss_rate * (this.metrics.api_call_count - 1) + 1) / this.metrics.api_call_count;
+        }
+        this.metrics.average_response_time = (this.metrics.average_response_time * (this.metrics.api_call_count - 1) + responseTime) / this.metrics.api_call_count;
+    }
+    /**
+     * Update cache metrics
+     */
+    updateCacheMetrics() {
+        this.metrics.cache_size = this.cache.size;
+        this.metrics.memory_usage = Array.from(this.cache.values())
+            .reduce((total, entry) => total + entry.size, 0);
+    }
+    /**
+     * Generate cache key for request
+     */
+    generateCacheKey(request) {
+        const keyParts = [
+            request.method,
+            request.url,
+            JSON.stringify(request.data),
+            JSON.stringify(request.headers)
+        ];
+        return Buffer.from(keyParts.join('|')).toString('base64');
+    }
+    /**
+     * Get TTL for specific request type
+     */
+    getTTLForRequest(request) {
+        const url = request.url.toLowerCase();
+        if (url.includes('action_type') || url.includes('trigger_type')) {
+            return 3600000; // 1 hour for metadata
+        }
+        if (url.includes('flow_template')) {
+            return 1800000; // 30 minutes for templates
+        }
+        if (url.includes('user_preference')) {
+            return 600000; // 10 minutes for preferences
+        }
+        return this.config.default_ttl;
+    }
+    /**
+     * Get tags for request
+     */
+    getTagsForRequest(request) {
+        const tags = [];
+        const url = request.url.toLowerCase();
+        if (url.includes('action_type'))
+            tags.push('action_type');
+        if (url.includes('trigger_type'))
+            tags.push('trigger_type');
+        if (url.includes('flow'))
+            tags.push('flow');
+        if (url.includes('user'))
+            tags.push('user');
+        return tags;
+    }
+    /**
+     * Estimate size of cached value
+     */
+    estimateSize(value) {
+        return JSON.stringify(value).length * 2; // Rough estimate
+    }
+    /**
+     * Extract table name from URL
+     */
+    extractTable(url) {
+        const match = url.match(/\/table\/([^\/\?]+)/);
+        return match ? match[1] : 'unknown';
+    }
+    /**
+     * Get batch size for request type
+     */
+    getBatchSizeForType(type) {
+        if (type.includes('GET'))
+            return 10;
+        if (type.includes('POST'))
+            return 5;
+        if (type.includes('PUT') || type.includes('PATCH'))
+            return 3;
+        if (type.includes('DELETE'))
+            return 3;
+        return 5;
+    }
+    /**
+     * Check if request is rate limited
+     */
+    isRateLimited(url) {
+        const domain = this.extractDomain(url);
+        const lastRequest = this.rateLimiter.get(domain);
+        if (!lastRequest)
+            return false;
+        const timeSinceLastRequest = Date.now() - lastRequest;
+        return timeSinceLastRequest < 100; // 100ms rate limit
+    }
+    /**
+     * Wait for rate limit to clear
+     */
+    async waitForRateLimit(url) {
+        const domain = this.extractDomain(url);
+        const lastRequest = this.rateLimiter.get(domain);
+        if (lastRequest) {
+            const waitTime = 100 - (Date.now() - lastRequest);
+            if (waitTime > 0) {
+                await new Promise(resolve => setTimeout(resolve, waitTime));
+            }
+        }
+        this.rateLimiter.set(domain, Date.now());
+    }
+    /**
+     * Extract domain from URL
+     */
+    extractDomain(url) {
+        try {
+            return new URL(url).hostname;
+        }
+        catch {
+            return 'default';
+        }
+    }
+    /**
+     * Get pooled connection
+     */
+    getPooledConnection(url) {
+        const domain = this.extractDomain(url);
+        return this.connectionPool.get(domain) || {};
+    }
+    /**
+     * Return pooled connection
+     */
+    returnPooledConnection(url, connection) {
+        const domain = this.extractDomain(url);
+        this.connectionPool.set(domain, connection);
+    }
+    /**
+     * Identify batchable requests
+     */
+    identifyBatchableRequests() {
+        // Implementation would analyze request patterns
+        return [];
+    }
+    /**
+     * Predict likely requests based on patterns
+     */
+    predictLikelyRequests(mostAccessed) {
+        // Implementation would use ML or pattern analysis
+        return mostAccessed.slice(0, 5);
+    }
+    /**
+     * Reconstruct request from cache key
+     */
+    reconstructRequestFromCacheKey(cacheKey) {
+        try {
+            const decoded = Buffer.from(cacheKey, 'base64').toString();
+            const [method, url, data, headers] = decoded.split('|');
+            return {
+                id: 'reconstructed',
+                method: method,
+                url,
+                data: JSON.parse(data),
+                headers: JSON.parse(headers),
+                cacheable: true,
+                priority: 1
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Start cleanup timer
+     */
+    startCleanupTimer() {
+        this.cleanupTimer = setInterval(() => {
+            this.cleanupExpiredEntries();
+        }, this.config.cleanup_interval);
+    }
+    /**
+     * Cleanup expired entries
+     */
+    cleanupExpiredEntries() {
+        const now = Date.now();
+        const expiredKeys = [];
+        for (const [key, entry] of this.cache) {
+            if (now - entry.timestamp.getTime() > entry.ttl) {
+                expiredKeys.push(key);
+            }
+        }
+        for (const key of expiredKeys) {
+            this.cache.delete(key);
+        }
+        if (expiredKeys.length > 0) {
+            this.logger.debug(`Cleaned up ${expiredKeys.length} expired cache entries`);
+            this.updateCacheMetrics();
+        }
+    }
+    /**
+     * Load persisted cache
+     */
+    loadPersistedCache() {
+        if (!this.config.persistence_enabled)
+            return;
+        try {
+            const cacheFile = path_1.default.join(process.cwd(), '.snow-flow', 'cache', 'performance_cache.json');
+            if (fs_1.default.existsSync(cacheFile)) {
+                const cacheData = JSON.parse(fs_1.default.readFileSync(cacheFile, 'utf-8'));
+                for (const [key, entry] of Object.entries(cacheData)) {
+                    this.cache.set(key, {
+                        ...entry,
+                        timestamp: new Date(entry.timestamp),
+                        last_accessed: new Date(entry.last_accessed)
+                    });
+                }
+                this.logger.info(`Loaded ${this.cache.size} entries from persisted cache`);
+            }
+        }
+        catch (error) {
+            this.logger.warn('Failed to load persisted cache:', error);
+        }
+    }
+    /**
+     * Save cache to disk
+     */
+    saveCacheToDisk() {
+        if (!this.config.persistence_enabled)
+            return;
+        try {
+            const cacheDir = path_1.default.join(process.cwd(), '.snow-flow', 'cache');
+            if (!fs_1.default.existsSync(cacheDir)) {
+                fs_1.default.mkdirSync(cacheDir, { recursive: true });
+            }
+            const cacheFile = path_1.default.join(cacheDir, 'performance_cache.json');
+            const cacheData = Object.fromEntries(this.cache.entries());
+            fs_1.default.writeFileSync(cacheFile, JSON.stringify(cacheData, null, 2));
+            this.logger.info(`Saved ${this.cache.size} entries to persisted cache`);
+        }
+        catch (error) {
+            this.logger.warn('Failed to save cache to disk:', error);
+        }
+    }
+    /**
+     * Clear cache
+     */
+    clearCache(tags) {
+        if (!tags || tags.length === 0) {
+            this.cache.clear();
+            this.logger.info('Cleared all cache entries');
+        }
+        else {
+            const keysToDelete = [];
+            for (const [key, entry] of this.cache) {
+                if (entry.tags.some(tag => tags.includes(tag))) {
+                    keysToDelete.push(key);
+                }
+            }
+            for (const key of keysToDelete) {
+                this.cache.delete(key);
+            }
+            this.logger.info(`Cleared ${keysToDelete.length} cache entries with tags: ${tags.join(', ')}`);
+        }
+        this.updateCacheMetrics();
+    }
+    /**
+     * Destroy optimizer and cleanup
+     */
+    destroy() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+        }
+        this.saveCacheToDisk();
+        this.cache.clear();
+        this.batchQueue.clear();
+        this.rateLimiter.clear();
+        this.connectionPool.clear();
+        this.logger.info('Performance optimizer destroyed');
+    }
+}
+exports.PerformanceOptimizer = PerformanceOptimizer;
+//# sourceMappingURL=performance-optimizer.js.map