Enhance logging in server and storage manager for better debugging and monitoring. Added detailed debug and error messages in GetQuarantinedServers and ListQuarantinedUpstreamServers methods, along with improvements in state management for tray UI updates.

Author: Dumbris

internal/server/server.go

@@ -651,34 +651,50 @@ func (s *Server) GetAllServers() ([]map[string]interface{}, error) {
 
 // GetQuarantinedServers returns information about quarantined servers for tray UI
 func (s *Server) GetQuarantinedServers() ([]map[string]interface{}, error) {
+	s.logger.Debug("GetQuarantinedServers called")
+
 	// Check if storage manager is available
 	if s.storageManager == nil {
+		s.logger.Warn("Storage manager is nil in GetQuarantinedServers")
 		return []map[string]interface{}{}, nil
 	}
 
+	s.logger.Debug("Calling storage manager ListQuarantinedUpstreamServers")
 	quarantinedServers, err := s.storageManager.ListQuarantinedUpstreamServers()
 	if err != nil {
 		// Handle database closed gracefully
 		if strings.Contains(err.Error(), "database not open") || strings.Contains(err.Error(), "closed") {
 			s.logger.Debug("Database not available for GetQuarantinedServers, returning empty list")
 			return []map[string]interface{}{}, nil
 		}
+		s.logger.Error("Failed to get quarantined servers from storage", zap.Error(err))
 		return nil, err
 	}
 
+	s.logger.Debug("Retrieved quarantined servers from storage",
+		zap.Int("count", len(quarantinedServers)))
+
 	var result []map[string]interface{}
 	for _, server := range quarantinedServers {
-		result = append(result, map[string]interface{}{
+		serverMap := map[string]interface{}{
 			"name":        server.Name,
 			"url":         server.URL,
 			"command":     server.Command,
 			"protocol":    server.Protocol,
 			"enabled":     server.Enabled,
 			"quarantined": server.Quarantined,
 			"created":     server.Created,
-		})
+		}
+		result = append(result, serverMap)
+
+		s.logger.Debug("Added quarantined server to result",
+			zap.String("server", server.Name),
+			zap.Bool("quarantined", server.Quarantined))
 	}
 
+	s.logger.Debug("GetQuarantinedServers completed",
+		zap.Int("total_result_count", len(result)))
+
 	return result, nil
 }
 
@@ -722,11 +738,19 @@ func (s *Server) QuarantineServer(serverName string, quarantined bool) error {
 		zap.String("server", serverName),
 		zap.Bool("quarantined", quarantined))
 
+	s.logger.Debug("Calling storage manager QuarantineUpstreamServer",
+		zap.String("server", serverName),
+		zap.Bool("quarantined", quarantined))
+
 	if err := s.storageManager.QuarantineUpstreamServer(serverName, quarantined); err != nil {
 		s.logger.Error("Failed to update server quarantine state in storage", zap.Error(err))
 		return fmt.Errorf("failed to update quarantine state for server '%s' in storage: %w", serverName, err)
 	}
 
+	s.logger.Debug("Successfully updated quarantine state in storage, saving configuration",
+		zap.String("server", serverName),
+		zap.Bool("quarantined", quarantined))
+
 	if err := s.SaveConfiguration(); err != nil {
 		s.logger.Error("Failed to save configuration after quarantine state change", zap.Error(err))
 	}

internal/storage/manager.go

@@ -139,13 +139,25 @@ func (m *Manager) ListQuarantinedUpstreamServers() ([]*config.ServerConfig, erro
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 
+	m.logger.Debug("ListQuarantinedUpstreamServers called")
+
 	records, err := m.db.ListUpstreams()
 	if err != nil {
+		m.logger.Errorw("Failed to list upstreams for quarantine filtering",
+			"error", err)
 		return nil, err
 	}
 
+	m.logger.Debugw("Retrieved all upstream records for quarantine filtering",
+		"total_records", len(records))
+
 	var quarantinedServers []*config.ServerConfig
 	for _, record := range records {
+		m.logger.Debugw("Checking server quarantine status",
+			"server", record.Name,
+			"quarantined", record.Quarantined,
+			"enabled", record.Enabled)
+
 		if record.Quarantined {
 			quarantinedServers = append(quarantinedServers, &config.ServerConfig{
 				Name:        record.Name,
@@ -160,9 +172,16 @@ func (m *Manager) ListQuarantinedUpstreamServers() ([]*config.ServerConfig, erro
 				Created:     record.Created,
 				Updated:     record.Updated,
 			})
+
+			m.logger.Debugw("Added server to quarantined list",
+				"server", record.Name,
+				"total_quarantined_so_far", len(quarantinedServers))
 		}
 	}
 
+	m.logger.Debugw("ListQuarantinedUpstreamServers completed",
+		"total_quarantined", len(quarantinedServers))
+
 	return quarantinedServers, nil
 }
 
@@ -226,14 +245,39 @@ func (m *Manager) QuarantineUpstreamServer(name string, quarantined bool) error
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
+	m.logger.Debugw("QuarantineUpstreamServer called",
+		"server", name,
+		"quarantined", quarantined)
+
 	record, err := m.db.GetUpstream(name)
 	if err != nil {
+		m.logger.Errorw("Failed to get upstream record for quarantine operation",
+			"server", name,
+			"error", err)
 		return err
 	}
 
+	m.logger.Debugw("Retrieved upstream record for quarantine",
+		"server", name,
+		"current_quarantined", record.Quarantined,
+		"new_quarantined", quarantined)
+
 	record.Quarantined = quarantined
 	record.Updated = time.Now()
-	return m.db.SaveUpstream(record)
+
+	if err := m.db.SaveUpstream(record); err != nil {
+		m.logger.Errorw("Failed to save quarantine status to database",
+			"server", name,
+			"quarantined", quarantined,
+			"error", err)
+		return err
+	}
+
+	m.logger.Debugw("Successfully saved quarantine status to database",
+		"server", name,
+		"quarantined", quarantined)
+
+	return nil
 }
 
 // Tool statistics operations