Refactor logging for server configuration and file operations

- Simplified logging messages by removing debug prefixes and enhancing clarity.
- Updated log levels for configuration changes and reloads to improve traceability.
- Streamlined logging in the upstream manager for better consistency.

Author: Dumbris

internal/server/server.go

@@ -346,16 +346,11 @@ func (s *Server) loadConfiguredServers() error {
 			storedServer.Protocol != serverCfg.Protocol
 
 		if hasChanged {
-			s.logger.Info("CONFIG_DEBUG: Server configuration changed, updating storage",
+			s.logger.Info("Server configuration changed, updating storage",
 				zap.String("server", serverCfg.Name),
 				zap.Bool("new", !existsInStorage),
 				zap.Bool("enabled_changed", existsInStorage && storedServer.Enabled != serverCfg.Enabled),
 				zap.Bool("quarantined_changed", existsInStorage && storedServer.Quarantined != serverCfg.Quarantined))
-		} else {
-			s.logger.Info("CONFIG_DEBUG: Server configuration unchanged, but still processing",
-				zap.String("server", serverCfg.Name),
-				zap.Bool("enabled", serverCfg.Enabled),
-				zap.Bool("quarantined", serverCfg.Quarantined))
 		}
 
 		// Always sync config to storage (ensures consistency)
@@ -368,9 +363,6 @@ func (s *Server) loadConfiguredServers() error {
 		if serverCfg.Enabled {
 			// Add server to upstream manager regardless of quarantine status
 			// Quarantined servers are kept connected for inspection but blocked for execution
-			s.logger.Info("CONFIG_DEBUG: Calling AddServer on upstream manager",
-				zap.String("server", serverCfg.Name),
-				zap.Bool("config_changed", hasChanged))
 			if err := s.upstreamManager.AddServer(serverCfg.Name, serverCfg); err != nil {
 				s.logger.Error("Failed to add/update upstream server", zap.Error(err), zap.String("server", serverCfg.Name))
 			}
@@ -380,8 +372,6 @@ func (s *Server) loadConfiguredServers() error {
 			}
 		} else {
 			// Remove from upstream manager only if disabled (not quarantined)
-			s.logger.Info("CONFIG_DEBUG: Removing disabled server from upstream manager",
-				zap.String("server", serverCfg.Name))
 			s.upstreamManager.RemoveServer(serverCfg.Name)
 			s.logger.Info("Server is disabled, removing from active connections", zap.String("server", serverCfg.Name))
 		}
@@ -750,11 +740,7 @@ func (s *Server) EnableServer(serverName string, enabled bool) error {
 
 // QuarantineServer quarantines/unquarantines a server
 func (s *Server) QuarantineServer(serverName string, quarantined bool) error {
-	s.logger.Info("CONFIG_DEBUG: QuarantineServer called - request to change server quarantine state",
-		zap.String("server", serverName),
-		zap.Bool("quarantined", quarantined))
-
-	s.logger.Debug("CONFIG_DEBUG: Calling storage manager QuarantineUpstreamServer",
+	s.logger.Info("Request to change server quarantine state",
 		zap.String("server", serverName),
 		zap.Bool("quarantined", quarantined))
 
@@ -763,15 +749,11 @@ func (s *Server) QuarantineServer(serverName string, quarantined bool) error {
 		return fmt.Errorf("failed to update quarantine state for server '%s' in storage: %w", serverName, err)
 	}
 
-	s.logger.Debug("CONFIG_DEBUG: Successfully updated quarantine state in storage, about to save 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))
 	}
 
-	s.logger.Info("CONFIG_DEBUG: Successfully persisted server quarantine state change. This will trigger file watcher to reload config.",
+	s.logger.Info("Successfully persisted server quarantine state change",
 		zap.String("server", serverName),
 		zap.Bool("quarantined", quarantined))
 
@@ -951,7 +933,7 @@ func (s *Server) SaveConfiguration() error {
 		return fmt.Errorf("configuration file path is not available")
 	}
 
-	s.logger.Info("CONFIG_DEBUG: SaveConfiguration called - saving configuration to file", zap.String("path", configPath))
+	s.logger.Debug("Saving configuration to file", zap.String("path", configPath))
 
 	// Ensure we have the latest server list from the storage manager
 	latestServers, err := s.storageManager.ListUpstreamServers()
@@ -961,16 +943,12 @@ func (s *Server) SaveConfiguration() error {
 	}
 	s.config.Servers = latestServers
 
-	s.logger.Info("CONFIG_DEBUG: About to save config file - this will trigger file watcher",
-		zap.String("path", configPath),
-		zap.Int("server_count", len(latestServers)))
-
 	return config.SaveConfig(s.config, configPath)
 }
 
 // ReloadConfiguration reloads the configuration from disk
 func (s *Server) ReloadConfiguration() error {
-	s.logger.Info("CONFIG_DEBUG: ReloadConfiguration called - config as source of truth")
+	s.logger.Info("Reloading configuration from disk")
 
 	// Store old config for comparison
 	oldServerCount := len(s.config.Servers)
@@ -986,7 +964,6 @@ func (s *Server) ReloadConfiguration() error {
 	s.config = newConfig
 
 	// Reload configured servers (this is where the comprehensive sync happens)
-	s.logger.Info("CONFIG_DEBUG: About to call loadConfiguredServers from ReloadConfiguration")
 	if err := s.loadConfiguredServers(); err != nil {
 		return fmt.Errorf("failed to reload servers: %w", err)
 	}
@@ -1001,7 +978,7 @@ func (s *Server) ReloadConfiguration() error {
 		}
 	}()
 
-	s.logger.Info("CONFIG_DEBUG: Configuration reload completed",
+	s.logger.Info("Configuration reload completed",
 		zap.String("path", configPath),
 		zap.Int("old_server_count", oldServerCount),
 		zap.Int("new_server_count", len(newConfig.Servers)),

internal/tray/tray.go

@@ -261,15 +261,15 @@ func (a *App) watchConfigFile() {
 			}
 
 			if event.Has(fsnotify.Write) || event.Has(fsnotify.Create) {
-				a.logger.Info("CONFIG_DEBUG: Config file changed, reloading configuration", zap.String("event", event.String()))
+				a.logger.Debug("Config file changed, reloading configuration", zap.String("event", event.String()))
 
 				// Add a small delay to ensure file write is complete
 				time.Sleep(500 * time.Millisecond)
 
 				if err := a.server.ReloadConfiguration(); err != nil {
 					a.logger.Error("Failed to reload configuration", zap.Error(err))
 				} else {
-					a.logger.Info("CONFIG_DEBUG: Configuration reloaded successfully")
+					a.logger.Debug("Configuration reloaded successfully")
 					// Force a menu refresh after config reload
 					a.forceRefresh = true
 					a.refreshMenusImmediate()

internal/upstream/manager.go

@@ -64,34 +64,23 @@ func (m *Manager) AddServerConfig(id string, serverConfig *config.ServerConfig)
 			existingConfig.Quarantined != serverConfig.Quarantined
 
 		if configChanged {
-			m.logger.Info("UPSTREAM_DEBUG: Server configuration changed, disconnecting existing client",
+			m.logger.Info("Server configuration changed, disconnecting existing client",
 				zap.String("id", id),
 				zap.String("name", serverConfig.Name),
 				zap.String("current_state", existingClient.GetState().String()),
-				zap.Bool("is_connected", existingClient.IsConnected()),
-				zap.Bool("url_changed", existingConfig.URL != serverConfig.URL),
-				zap.Bool("protocol_changed", existingConfig.Protocol != serverConfig.Protocol),
-				zap.Bool("command_changed", existingConfig.Command != serverConfig.Command),
-				zap.Bool("enabled_changed", existingConfig.Enabled != serverConfig.Enabled),
-				zap.Bool("quarantined_changed", existingConfig.Quarantined != serverConfig.Quarantined))
+				zap.Bool("is_connected", existingClient.IsConnected()))
 			_ = existingClient.Disconnect()
 			delete(m.clients, id)
 		} else {
-			m.logger.Info("UPSTREAM_DEBUG: Server configuration unchanged, keeping existing client",
+			m.logger.Debug("Server configuration unchanged, keeping existing client",
 				zap.String("id", id),
 				zap.String("name", serverConfig.Name),
 				zap.String("current_state", existingClient.GetState().String()),
-				zap.Bool("is_connected", existingClient.IsConnected()),
-				zap.Bool("enabled", serverConfig.Enabled),
-				zap.Bool("quarantined", serverConfig.Quarantined))
+				zap.Bool("is_connected", existingClient.IsConnected()))
 			// Update the client's config reference to the new config but don't recreate the client
 			existingClient.config = serverConfig
 			return nil
 		}
-	} else {
-		m.logger.Info("UPSTREAM_DEBUG: No existing client found, creating new client",
-			zap.String("id", id),
-			zap.String("name", serverConfig.Name))
 	}
 
 	// Create new client but don't connect yet
@@ -116,11 +105,9 @@ func (m *Manager) AddServerConfig(id string, serverConfig *config.ServerConfig)
 	}
 
 	m.clients[id] = client
-	m.logger.Info("UPSTREAM_DEBUG: Added new client configuration",
+	m.logger.Info("Added upstream server configuration",
 		zap.String("id", id),
-		zap.String("name", serverConfig.Name),
-		zap.Bool("enabled", serverConfig.Enabled),
-		zap.Bool("quarantined", serverConfig.Quarantined))
+		zap.String("name", serverConfig.Name))
 
 	return nil
 }
@@ -157,7 +144,7 @@ func (m *Manager) AddServer(id string, serverConfig *config.ServerConfig) error
 	}
 
 	if !serverConfig.Enabled {
-		m.logger.Info("UPSTREAM_DEBUG: Server is disabled, skipping connection",
+		m.logger.Debug("Skipping connection for disabled server",
 			zap.String("id", id),
 			zap.String("name", serverConfig.Name))
 		return nil
@@ -166,25 +153,19 @@ func (m *Manager) AddServer(id string, serverConfig *config.ServerConfig) error
 	// Check if client exists and is already connected
 	if client, exists := m.GetClient(id); exists {
 		if client.IsConnected() {
-			m.logger.Info("UPSTREAM_DEBUG: Server is already connected, skipping connection attempt",
+			m.logger.Debug("Server is already connected, skipping connection attempt",
 				zap.String("id", id),
-				zap.String("name", serverConfig.Name),
-				zap.String("state", client.GetState().String()))
+				zap.String("name", serverConfig.Name))
 			return nil
 		}
 
-		m.logger.Info("UPSTREAM_DEBUG: Server exists but not connected, attempting connection",
-			zap.String("id", id),
-			zap.String("name", serverConfig.Name),
-			zap.String("state", client.GetState().String()))
-
 		// Connect to server
 		ctx := context.Background()
 		if err := client.Connect(ctx); err != nil {
 			return fmt.Errorf("failed to connect to server %s: %w", serverConfig.Name, err)
 		}
 	} else {
-		m.logger.Error("UPSTREAM_DEBUG: Client not found after AddServerConfig - this should not happen",
+		m.logger.Error("Client not found after AddServerConfig - this should not happen",
 			zap.String("id", id),
 			zap.String("name", serverConfig.Name))
 	}
@@ -198,15 +179,11 @@ func (m *Manager) RemoveServer(id string) {
 	defer m.mu.Unlock()
 
 	if client, exists := m.clients[id]; exists {
-		m.logger.Info("UPSTREAM_DEBUG: Removing server, disconnecting client",
+		m.logger.Info("Removing upstream server",
 			zap.String("id", id),
-			zap.String("state", client.GetState().String()),
-			zap.Bool("is_connected", client.IsConnected()))
+			zap.String("state", client.GetState().String()))
 		_ = client.Disconnect()
 		delete(m.clients, id)
-		m.logger.Info("UPSTREAM_DEBUG: Removed upstream server", zap.String("id", id))
-	} else {
-		m.logger.Info("UPSTREAM_DEBUG: Server not found for removal", zap.String("id", id))
 	}
 }