Add logging and fix /agents/ route error

internal/api/api.go

@@ -2,9 +2,12 @@ package api
 
 import (
 	"encoding/json"
+	"log/slog"
+	"net/http"
+
+	"github.com/go-chi/chi/v5"
 	"nerd-monitor/internal/stats"
 	"nerd-monitor/internal/store"
-	"net/http"
 )
 
 // Handler manages HTTP requests.
@@ -19,86 +22,115 @@ func New(s *store.Store) *Handler {
 
 // ReportStats handles agent stats reports.
 func (h *Handler) ReportStats(w http.ResponseWriter, r *http.Request) {
+	slog.Debug("Incoming stats report request", "method", r.Method, "path", r.URL.Path, "remoteAddr", r.RemoteAddr)
+
 	agentID := r.URL.Query().Get("id")
 	if agentID == "" {
+		slog.Warn("Missing agent ID in stats report", "remoteAddr", r.RemoteAddr)
 		http.Error(w, "missing agent id", http.StatusBadRequest)
 		return
 	}
 
 	var stat stats.Stats
 	if err := json.NewDecoder(r.Body).Decode(&stat); err != nil {
+		slog.Error("Invalid request body in stats report", "agentID", agentID, "error", err)
 		http.Error(w, "invalid request body", http.StatusBadRequest)
 		return
 	}
 
+	slog.Debug("Updating agent stats", "agentID", agentID, "hostname", stat.Hostname, "cpu", stat.CPUUsage)
 	h.store.UpdateAgent(agentID, &stat)
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
+	slog.Debug("Stats report processed successfully", "agentID", agentID)
 }
 
 // GetAgent returns stats for a single agent.
 func (h *Handler) GetAgent(w http.ResponseWriter, r *http.Request) {
+	slog.Debug("Incoming get agent request", "method", r.Method, "path", r.URL.Path, "remoteAddr", r.RemoteAddr)
+
 	agentID := r.URL.Query().Get("id")
 	if agentID == "" {
+		slog.Warn("Missing agent ID in get agent request", "remoteAddr", r.RemoteAddr)
 		http.Error(w, "missing agent id", http.StatusBadRequest)
 		return
 	}
 
+	slog.Debug("Retrieving agent stats", "agentID", agentID)
 	agent := h.store.GetAgent(agentID)
 	if agent == nil {
+		slog.Warn("Agent not found", "agentID", agentID)
 		http.Error(w, "agent not found", http.StatusNotFound)
 		return
 	}
 
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(agent)
+	slog.Debug("Agent stats retrieved successfully", "agentID", agentID)
 }
 
 // ListAgents returns all agents.
 func (h *Handler) ListAgents(w http.ResponseWriter, r *http.Request) {
+	slog.Debug("Incoming list agents request", "method", r.Method, "path", r.URL.Path, "remoteAddr", r.RemoteAddr)
+
+	slog.Debug("Retrieving all agents")
 	agents := h.store.GetAllAgents()
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(agents)
+	slog.Debug("All agents listed successfully", "count", len(agents))
 }
 
 // DeleteAgent removes an agent.
 func (h *Handler) DeleteAgent(w http.ResponseWriter, r *http.Request) {
+	slog.Debug("Incoming delete agent request", "method", r.Method, "path", r.URL.Path, "remoteAddr", r.RemoteAddr)
+
 	agentID := r.URL.Query().Get("id")
 	if agentID == "" {
+		slog.Warn("Missing agent ID in delete agent request", "remoteAddr", r.RemoteAddr)
 		http.Error(w, "missing agent id", http.StatusBadRequest)
 		return
 	}
 
+	slog.Info("Deleting agent", "agentID", agentID)
 	h.store.DeleteAgent(agentID)
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(map[string]string{"status": "deleted"})
+	slog.Info("Agent deleted successfully", "agentID", agentID)
 }
 
 // UpdateHostname updates the hostname for an agent.
 func (h *Handler) UpdateHostname(w http.ResponseWriter, r *http.Request) {
+	slog.Debug("Incoming update hostname request", "method", r.Method, "path", r.URL.Path, "remoteAddr", r.RemoteAddr)
+
 	if r.Method != http.MethodPost {
+		slog.Warn("Invalid method for update hostname", "method", r.Method)
 		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
 		return
 	}
 
-	agentID := r.PathValue("id")
+	agentID := chi.URLParam(r, "id")
 	if agentID == "" {
+		slog.Warn("Missing agent ID in update hostname request", "remoteAddr", r.RemoteAddr)
 		http.Error(w, "missing agent id", http.StatusBadRequest)
 		return
 	}
 
 	hostname := r.FormValue("hostname")
 	if hostname == "" {
+		slog.Warn("Missing hostname in update request", "agentID", agentID)
 		http.Error(w, "missing hostname", http.StatusBadRequest)
 		return
 	}
 
+	slog.Info("Updating agent hostname", "agentID", agentID, "newHostname", hostname)
 	err := h.store.UpdateHostname(agentID, hostname)
 	if err != nil {
+		slog.Warn("Failed to update hostname - agent not found", "agentID", agentID, "error", err)
 		http.Error(w, "agent not found", http.StatusNotFound)
 		return
 	}
 
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(map[string]string{"status": "updated"})
+	slog.Info("Agent hostname updated successfully", "agentID", agentID, "hostname", hostname)
 }

internal/auth/middleware.go

@@ -3,6 +3,7 @@ package auth
 import (
 	"crypto/rand"
 	"encoding/hex"
+	"log/slog"
 	"net/http"
 	"sync"
 	"time"
@@ -36,11 +37,13 @@ func New(username, password string) *Manager {
 // Login validates credentials and creates a session.
 func (m *Manager) Login(username, password string) (string, error) {
 	if username != m.username || password != m.password {
+		slog.Debug("Login failed - invalid credentials", "username", username)
 		return "", ErrInvalidCredentials
 	}
 
 	token, err := generateToken()
 	if err != nil {
+		slog.Error("Failed to generate session token", "error", err)
 		return "", err
 	}
 
@@ -52,6 +55,7 @@ func (m *Manager) Login(username, password string) (string, error) {
 		ExpiresAt: time.Now().Add(m.expiryDur),
 	}
 
+	slog.Debug("Login successful, session created", "username", username, "token", token[:8]+"...")
 	return token, nil
 }
 
@@ -62,10 +66,17 @@ func (m *Manager) Validate(token string) bool {
 
 	session, ok := m.sessions[token]
 	if !ok {
+		slog.Debug("Session validation failed - token not found", "token", token[:8]+"...")
 		return false
 	}
 
-	return session.ExpiresAt.After(time.Now())
+	if !session.ExpiresAt.After(time.Now()) {
+		slog.Debug("Session validation failed - token expired", "token", token[:8]+"...", "expiredAt", session.ExpiresAt)
+		return false
+	}
+
+	slog.Debug("Session validation successful", "token", token[:8]+"...")
+	return true
 }
 
 // Logout invalidates a session.
@@ -74,16 +85,24 @@ func (m *Manager) Logout(token string) {
 	defer m.mu.Unlock()
 
 	delete(m.sessions, token)
+	slog.Debug("Session logged out", "token", token[:8]+"...")
 }
 
 // Middleware returns a Chi middleware for authentication.
 func (m *Manager) Middleware(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		cookie, err := r.Cookie("session_token")
-		if err != nil || !m.Validate(cookie.Value) {
+		if err != nil {
+			slog.Debug("Authentication failed - no session cookie", "path", r.URL.Path, "remoteAddr", r.RemoteAddr)
 			http.Redirect(w, r, "/login", http.StatusSeeOther)
 			return
 		}
+		if !m.Validate(cookie.Value) {
+			slog.Debug("Authentication failed - invalid session", "path", r.URL.Path, "remoteAddr", r.RemoteAddr)
+			http.Redirect(w, r, "/login", http.StatusSeeOther)
+			return
+		}
+		slog.Debug("Authentication successful", "path", r.URL.Path, "remoteAddr", r.RemoteAddr)
 		next.ServeHTTP(w, r)
 	})
 }

internal/store/store.go

@@ -2,6 +2,7 @@ package store
 
 import (
 	"errors"
+	"log/slog"
 	"sync"
 	"time"
 
@@ -53,6 +54,7 @@ func (s *Store) UpdateAgent(id string, stat *stats.Stats) {
 		DiskTotal: stat.DiskTotal,
 		LastSeen:  time.Now(),
 	}
+	slog.Debug("Agent stats updated", "agentID", id, "hostname", stat.Hostname, "cpu", stat.CPUUsage)
 }
 
 // GetAgent retrieves agent stats by ID.
@@ -60,7 +62,13 @@ func (s *Store) GetAgent(id string) *AgentStats {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 
-	return s.agents[id]
+	agent := s.agents[id]
+	if agent != nil {
+		slog.Debug("Agent retrieved", "agentID", id, "hostname", agent.Hostname)
+	} else {
+		slog.Debug("Agent not found", "agentID", id)
+	}
+	return agent
 }
 
 // GetAllAgents returns all agents.
@@ -72,6 +80,7 @@ func (s *Store) GetAllAgents() []*AgentStats {
 	for _, agent := range s.agents {
 		agents = append(agents, agent)
 	}
+	slog.Debug("All agents retrieved", "count", len(agents))
 	return agents
 }
 
@@ -81,6 +90,7 @@ func (s *Store) DeleteAgent(id string) {
 	defer s.mu.Unlock()
 
 	delete(s.agents, id)
+	slog.Debug("Agent deleted", "agentID", id)
 }
 
 // UpdateHostname updates the hostname for an agent.
@@ -90,9 +100,11 @@ func (s *Store) UpdateHostname(id string, hostname string) error {
 
 	agent, exists := s.agents[id]
 	if !exists {
+		slog.Debug("Agent not found for hostname update", "agentID", id)
 		return ErrAgentNotFound
 	}
 
 	agent.Hostname = hostname
+	slog.Debug("Agent hostname updated", "agentID", id, "hostname", hostname)
 	return nil
 }

internal/ui/handlers.go

@@ -2,9 +2,11 @@ package ui
 
 import (
 	"context"
+	"log/slog"
 	"net/http"
 	"time"
 
+	"github.com/go-chi/chi/v5"
 	"nerd-monitor/internal/auth"
 	"nerd-monitor/internal/store"
 	"nerd-monitor/views"
@@ -26,30 +28,42 @@ func New(s *store.Store, a *auth.Manager) *Handler {
 
 // Dashboard renders the dashboard page.
 func (h *Handler) Dashboard(w http.ResponseWriter, r *http.Request) {
+	slog.Debug("Incoming dashboard request", "method", r.Method, "path", r.URL.Path, "remoteAddr", r.RemoteAddr)
+
+	slog.Debug("Rendering dashboard", "agentCount", len(h.store.GetAllAgents()), "staleAgentCount", len(h.getStaleAgents()))
 	agents := h.store.GetAllAgents()
 	staleAgents := h.getStaleAgents()
 
 	component := views.Dashboard(agents, staleAgents)
 	component.Render(context.Background(), w)
+	slog.Debug("Dashboard rendered successfully")
 }
 
 // AgentDetail renders the agent detail page.
 func (h *Handler) AgentDetail(w http.ResponseWriter, r *http.Request) {
-	agentID := r.PathValue("id")
+	slog.Debug("Incoming agent detail request", "method", r.Method, "path", r.URL.Path, "remoteAddr", r.RemoteAddr)
+
+	agentID := chi.URLParam(r, "id")
+	slog.Debug("Retrieving agent detail", "agentID", agentID)
 	agent := h.store.GetAgent(agentID)
 
 	if agent == nil {
+		slog.Warn("Agent not found for detail view", "agentID", agentID)
 		http.NotFound(w, r)
 		return
 	}
 
 	component := views.AgentDetail(agent)
 	component.Render(context.Background(), w)
+	slog.Debug("Agent detail rendered successfully", "agentID", agentID)
 }
 
 // Login renders the login page.
 func (h *Handler) Login(w http.ResponseWriter, r *http.Request) {
+	slog.Debug("Incoming login request", "method", r.Method, "path", r.URL.Path, "remoteAddr", r.RemoteAddr)
+
 	if r.Method == http.MethodGet {
+		slog.Debug("Rendering login page")
 		component := views.LoginPage("")
 		component.Render(context.Background(), w)
 		return
@@ -59,13 +73,16 @@ func (h *Handler) Login(w http.ResponseWriter, r *http.Request) {
 		username := r.FormValue("username")
 		password := r.FormValue("password")
 
+		slog.Debug("Attempting login", "username", username, "remoteAddr", r.RemoteAddr)
 		token, err := h.auth.Login(username, password)
 		if err != nil {
+			slog.Warn("Login failed - invalid credentials", "username", username, "remoteAddr", r.RemoteAddr, "error", err)
 			component := views.LoginPage("Invalid credentials")
 			component.Render(context.Background(), w)
 			return
 		}
 
+		slog.Info("Login successful", "username", username, "remoteAddr", r.RemoteAddr)
 		http.SetCookie(w, &http.Cookie{
 			Name:     "session_token",
 			Value:    token,
@@ -79,19 +96,26 @@ func (h *Handler) Login(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	slog.Warn("Invalid method for login", "method", r.Method)
 	http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
 }
 
 // Logout handles logout.
 func (h *Handler) Logout(w http.ResponseWriter, r *http.Request) {
+	slog.Debug("Incoming logout request", "method", r.Method, "path", r.URL.Path, "remoteAddr", r.RemoteAddr)
+
 	if r.Method != http.MethodPost {
+		slog.Warn("Invalid method for logout", "method", r.Method)
 		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
 		return
 	}
 
 	cookie, err := r.Cookie("session_token")
 	if err == nil {
+		slog.Info("Logging out user", "remoteAddr", r.RemoteAddr)
 		h.auth.Logout(cookie.Value)
+	} else {
+		slog.Debug("Logout attempted without valid session", "remoteAddr", r.RemoteAddr)
 	}
 
 	http.SetCookie(w, &http.Cookie{
@@ -107,53 +131,70 @@ func (h *Handler) Logout(w http.ResponseWriter, r *http.Request) {
 
 // RemoveStaleAgents handles bulk removal of stale agents.
 func (h *Handler) RemoveStaleAgents(w http.ResponseWriter, r *http.Request) {
+	slog.Debug("Incoming remove stale agents request", "method", r.Method, "path", r.URL.Path, "remoteAddr", r.RemoteAddr)
+
 	if r.Method != http.MethodPost {
+		slog.Warn("Invalid method for remove stale agents", "method", r.Method)
 		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
 		return
 	}
 
 	agentIDs := r.Form["agent_ids"]
+	slog.Info("Removing stale agents", "count", len(agentIDs), "agentIDs", agentIDs)
 	for _, id := range agentIDs {
 		h.store.DeleteAgent(id)
 	}
 
+	slog.Info("Stale agents removed successfully", "count", len(agentIDs))
 	http.Redirect(w, r, "/", http.StatusSeeOther)
 }
 
 // DeleteAgent handles single agent deletion.
 func (h *Handler) DeleteAgent(w http.ResponseWriter, r *http.Request) {
+	slog.Debug("Incoming delete agent request", "method", r.Method, "path", r.URL.Path, "remoteAddr", r.RemoteAddr)
+
 	if r.Method != http.MethodPost {
+		slog.Warn("Invalid method for delete agent", "method", r.Method)
 		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
 		return
 	}
 
-	agentID := r.PathValue("id")
+	agentID := chi.URLParam(r, "id")
+	slog.Info("Deleting agent", "agentID", agentID)
 	h.store.DeleteAgent(agentID)
 
+	slog.Info("Agent deleted successfully", "agentID", agentID)
 	http.Redirect(w, r, "/", http.StatusSeeOther)
 }
 
 // UpdateAgentHostname handles hostname updates for agents.
 func (h *Handler) UpdateAgentHostname(w http.ResponseWriter, r *http.Request) {
+	slog.Debug("Incoming update agent hostname request", "method", r.Method, "path", r.URL.Path, "remoteAddr", r.RemoteAddr)
+
 	if r.Method != http.MethodPost {
+		slog.Warn("Invalid method for update agent hostname", "method", r.Method)
 		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
 		return
 	}
 
-	agentID := r.PathValue("id")
+	agentID := chi.URLParam(r, "id")
 	hostname := r.FormValue("hostname")
 
 	if hostname == "" {
+		slog.Warn("Empty hostname provided for update", "agentID", agentID)
 		http.Error(w, "Hostname cannot be empty", http.StatusBadRequest)
 		return
 	}
 
+	slog.Info("Updating agent hostname", "agentID", agentID, "newHostname", hostname)
 	err := h.store.UpdateHostname(agentID, hostname)
 	if err != nil {
+		slog.Warn("Failed to update hostname - agent not found", "agentID", agentID, "error", err)
 		http.NotFound(w, r)
 		return
 	}
 
+	slog.Info("Agent hostname updated successfully", "agentID", agentID, "hostname", hostname)
 	http.Redirect(w, r, "/agents/"+agentID, http.StatusSeeOther)
 }