Add detailed Prowlarr status reporting and UI updates

- Implemented Prowlarr status polling in the frontend, refreshing every 30 seconds when the home section is active.
- Enhanced the backend API to return detailed indexer information, including active, throttled, and failed indexers.
- Updated the UI to display connection status, indexer statistics, and health status with improved error handling and user feedback.
- Added manual refresh functionality for Prowlarr data in the UI.

Author: Admin9705

frontend/static/js/new-main.js

@@ -4642,6 +4642,150 @@ let huntarrUI = {
             // Fall back to loading Swaparr status/info
             this.loadSwaparrStatus();
         }
+    },
+
+    // Setup Prowlarr status polling
+    setupProwlarrStatusPolling: function() {
+        console.log('[huntarrUI] Setting up Prowlarr status polling');
+        
+        // Load initial status
+        this.loadProwlarrStatus();
+        
+        // Set up polling to refresh Prowlarr status every 30 seconds
+        // Only poll when home section is active to reduce unnecessary requests
+        this.prowlarrPollingInterval = setInterval(() => {
+            if (this.currentSection === 'home') {
+                this.loadProwlarrStatus();
+            }
+        }, 30000);
+        
+        // Set up refresh button handler
+        const refreshButton = document.getElementById('refresh-prowlarr-data');
+        if (refreshButton) {
+            refreshButton.addEventListener('click', () => {
+                console.log('[huntarrUI] Manual Prowlarr refresh triggered');
+                this.loadProwlarrStatus();
+            });
+        }
+    },
+
+    // Load and update Prowlarr status card
+    loadProwlarrStatus: function() {
+        console.log('[huntarrUI] Loading Prowlarr status');
+        
+        HuntarrUtils.fetchWithTimeout('./api/prowlarr/stats')
+            .then(response => response.json())
+            .then(data => {
+                console.log('[huntarrUI] Prowlarr stats received:', data);
+                
+                const prowlarrCard = document.getElementById('prowlarrStatusCard');
+                if (!prowlarrCard) {
+                    console.log('[huntarrUI] Prowlarr card not found in DOM');
+                    return;
+                }
+
+                if (data.success && data.stats) {
+                    const stats = data.stats;
+                    
+                    // Show the card since we have data
+                    prowlarrCard.style.display = 'block';
+                    
+                    // Update connection status
+                    const connectionStatus = document.getElementById('prowlarrConnectionStatus');
+                    if (connectionStatus) {
+                        if (stats.connected) {
+                            connectionStatus.textContent = '🟢 Connected';
+                            connectionStatus.className = 'status-badge connected';
+                        } else {
+                            connectionStatus.textContent = '🔴 Disconnected';
+                            connectionStatus.className = 'status-badge disconnected';
+                        }
+                    }
+                    
+                    // Update stats display
+                    const updateElement = (id, value, tooltip = '') => {
+                        const element = document.getElementById(id);
+                        if (element) {
+                            element.textContent = value || '--';
+                            if (tooltip) {
+                                element.title = tooltip;
+                            }
+                        }
+                    };
+                    
+                    // Update basic stats
+                    updateElement('prowlarr-active-indexers', stats.active_indexers);
+                    updateElement('prowlarr-total-calls', stats.total_api_calls);
+                    updateElement('prowlarr-throttled', stats.throttled_indexers);
+                    updateElement('prowlarr-failed', stats.failed_indexers);
+                    
+                    // Update detailed tooltips with indexer names if available
+                    if (stats.indexer_details) {
+                        const activeNames = stats.indexer_details.active?.map(idx => idx.name).join(', ') || 'None';
+                        const throttledNames = stats.indexer_details.throttled?.map(idx => idx.name).join(', ') || 'None';
+                        const failedNames = stats.indexer_details.failed?.map(idx => idx.name).join(', ') || 'None';
+                        
+                        updateElement('prowlarr-active-indexers', stats.active_indexers, `Active: ${activeNames}`);
+                        updateElement('prowlarr-throttled', stats.throttled_indexers, `Throttled: ${throttledNames}`);
+                        updateElement('prowlarr-failed', stats.failed_indexers, `Failed: ${failedNames}`);
+                    }
+                    
+                    // Update health status
+                    const healthStatus = document.getElementById('prowlarr-health-status');
+                    if (healthStatus) {
+                        healthStatus.textContent = stats.health_status || 'Unknown';
+                        
+                        // Color-code health status
+                        healthStatus.className = 'health-status-text';
+                        if (stats.health_status?.includes('healthy')) {
+                            healthStatus.style.color = '#10b981'; // Green
+                        } else if (stats.health_status?.includes('throttled')) {
+                            healthStatus.style.color = '#f59e0b'; // Amber
+                        } else if (stats.health_status?.includes('failed') || stats.health_status?.includes('disabled')) {
+                            healthStatus.style.color = '#ef4444'; // Red
+                        } else {
+                            healthStatus.style.color = '#9ca3af'; // Gray
+                        }
+                    }
+                    
+                } else {
+                    // Handle error case
+                    console.log('[huntarrUI] Error in Prowlarr stats:', data.message || 'Unknown error');
+                    
+                    // Still show the card but with error states
+                    prowlarrCard.style.display = 'block';
+                    
+                    const connectionStatus = document.getElementById('prowlarrConnectionStatus');
+                    if (connectionStatus) {
+                        connectionStatus.textContent = '🔴 Error';
+                        connectionStatus.className = 'status-badge error';
+                    }
+                    
+                    // Set all stats to error state
+                    ['prowlarr-active-indexers', 'prowlarr-total-calls', 'prowlarr-throttled', 'prowlarr-failed'].forEach(id => {
+                        const element = document.getElementById(id);
+                        if (element) {
+                            element.textContent = '--';
+                            element.title = data.message || 'Connection error';
+                        }
+                    });
+                    
+                    const healthStatus = document.getElementById('prowlarr-health-status');
+                    if (healthStatus) {
+                        healthStatus.textContent = data.message || 'Connection error';
+                        healthStatus.style.color = '#ef4444'; // Red
+                    }
+                }
+            })
+            .catch(error => {
+                console.error('[huntarrUI] Error loading Prowlarr status:', error);
+                
+                // Hide the card on error
+                const prowlarrCard = document.getElementById('prowlarrStatusCard');
+                if (prowlarrCard) {
+                    prowlarrCard.style.display = 'none';
+                }
+            });
     }
 };
 

src/primary/apps/prowlarr_routes.py

@@ -205,33 +205,44 @@ def get_prowlarr_stats():
                         indexers = indexers_response.json()
                         stats['total_indexers'] = len(indexers)
 
-                        # Count active, throttled, and failed indexers
-                        active_count = 0
-                        throttled_count = 0
-                        failed_count = 0
+                        # Process indexers and collect detailed information
+                        active_indexers = []
+                        throttled_indexers = []
+                        failed_indexers = []
 
                         for indexer in indexers:
+                            indexer_info = {
+                                'name': indexer.get('name', 'Unknown'),
+                                'protocol': indexer.get('protocol', 'unknown'),
+                                'id': indexer.get('id')
+                            }
+                            
                             if indexer.get('enable', False):
-                                active_count += 1
+                                active_indexers.append(indexer_info)
 
                             # Check for throttling/rate limiting
                             capabilities = indexer.get('capabilities', {})
                             if capabilities.get('limitsexceeded', False):
-                                throttled_count += 1
+                                throttled_indexers.append(indexer_info)
 
                             # Check for failures - look for disabled indexers or low priority
                             if not indexer.get('enable', False):
-                                failed_count += 1
+                                failed_indexers.append(indexer_info)
 
-                        stats['active_indexers'] = active_count
-                        stats['throttled_indexers'] = throttled_count
-                        stats['failed_indexers'] = failed_count
+                        stats['active_indexers'] = len(active_indexers)
+                        stats['throttled_indexers'] = len(throttled_indexers)
+                        stats['failed_indexers'] = len(failed_indexers)
+                        stats['indexer_details'] = {
+                            'active': active_indexers,
+                            'throttled': throttled_indexers,
+                            'failed': failed_indexers
+                        }
 
                         # Update health status based on indexer health
-                        if throttled_count > 0:
-                            stats['health_status'] = f'{throttled_count} indexer(s) throttled'
-                        elif failed_count > 0:
-                            stats['health_status'] = f'{failed_count} indexer(s) disabled'
+                        if len(throttled_indexers) > 0:
+                            stats['health_status'] = f'{len(throttled_indexers)} indexer(s) throttled'
+                        elif len(failed_indexers) > 0:
+                            stats['health_status'] = f'{len(failed_indexers)} indexer(s) disabled'
                         else:
                             stats['health_status'] = 'All indexers healthy'