feat: implement grpc and http servers

Author: sirrobot01

internal/server/api/handlers.go

@@ -0,0 +1,375 @@
+package api
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/sirrobot01/mcpulse/internal/database"
+	"github.com/sirrobot01/mcpulse/internal/ingestion"
+	"github.com/sirrobot01/mcpulse/internal/models"
+	"go.uber.org/zap"
+)
+
+// Handlers holds all API handlers
+type Handlers struct {
+	repo   *database.Repository
+	ingest *ingestion.Service
+	logger *zap.Logger
+}
+
+// NewHandlers creates new API handlers
+func NewHandlers(repo *database.Repository, ingest *ingestion.Service, logger *zap.Logger) *Handlers {
+	return &Handlers{
+		repo:   repo,
+		ingest: ingest,
+		logger: logger,
+	}
+}
+
+// Health handles GET /health
+func (h *Handlers) Health(w http.ResponseWriter, r *http.Request) {
+	h.sendJSON(w, http.StatusOK, map[string]interface{}{
+		"status": "ok",
+		"time":   time.Now(),
+	})
+}
+
+// Version handles GET /version
+func (h *Handlers) Version(w http.ResponseWriter, r *http.Request) {
+	h.sendJSON(w, http.StatusOK, map[string]interface{}{
+		"version": "1.0.0",
+		"build":   "dev",
+	})
+}
+
+// ListServers handles GET /api/v1/servers
+func (h *Handlers) ListServers(w http.ResponseWriter, r *http.Request) {
+	servers, err := h.repo.ListServers(r.Context())
+	if err != nil {
+		h.logger.Error("failed to list servers", zap.Error(err))
+		h.sendError(w, http.StatusInternalServerError, "failed to list servers")
+		return
+	}
+
+	h.sendJSON(w, http.StatusOK, map[string]interface{}{
+		"servers": servers,
+	})
+}
+
+// GetServer handles GET /api/v1/servers/:id
+func (h *Handlers) GetServer(w http.ResponseWriter, r *http.Request) {
+	serverID := chi.URLParam(r, "id")
+	if serverID == "" {
+		h.sendError(w, http.StatusBadRequest, "server ID required")
+		return
+	}
+
+	server, err := h.repo.GetServer(r.Context(), serverID)
+	if err != nil {
+		h.logger.Error("failed to get server", zap.Error(err))
+		h.sendError(w, http.StatusInternalServerError, "failed to get server")
+		return
+	}
+
+	if server == nil {
+		h.sendError(w, http.StatusNotFound, "server not found")
+		return
+	}
+
+	h.sendJSON(w, http.StatusOK, server)
+}
+
+// Ingest handles POST /api/v1/ingest
+func (h *Handlers) Ingest(w http.ResponseWriter, r *http.Request) {
+	var req models.IngestRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		h.logger.Warn("invalid ingest payload", zap.Error(err))
+		h.sendError(w, http.StatusBadRequest, "invalid JSON payload")
+		return
+	}
+
+	resp, err := h.ingest.Ingest(r.Context(), req.Metrics)
+	if errors.Is(err, ingestion.ErrRateLimited) {
+		w.Header().Set("Retry-After", "1")
+		h.sendJSON(w, http.StatusTooManyRequests, map[string]interface{}{
+			"error":       "rate limit exceeded",
+			"retry_after": 1,
+		})
+		return
+	}
+	if errors.Is(err, ingestion.ErrBufferFull) {
+		h.sendError(w, http.StatusServiceUnavailable, "ingestion pipeline saturated")
+		return
+	}
+	if err != nil {
+		h.logger.Error("failed to ingest metrics", zap.Error(err))
+		h.sendError(w, http.StatusInternalServerError, "failed to ingest metrics")
+		return
+	}
+
+	h.sendJSON(w, http.StatusOK, resp)
+}
+
+// GetServerMetrics handles GET /api/v1/servers/:id/metrics
+func (h *Handlers) GetServerMetrics(w http.ResponseWriter, r *http.Request) {
+	serverID := chi.URLParam(r, "id")
+	if serverID == "" {
+		h.sendError(w, http.StatusBadRequest, "server ID required")
+		return
+	}
+
+	// Parse time range
+	from, to, interval := h.parseTimeRange(r)
+
+	metrics, err := h.repo.GetServerMetrics(r.Context(), serverID, from, to, interval)
+	if err != nil {
+		h.logger.Error("failed to get server metrics", zap.Error(err))
+		h.sendError(w, http.StatusInternalServerError, "failed to get server metrics")
+		return
+	}
+
+	h.sendJSON(w, http.StatusOK, metrics)
+}
+
+// GetTools handles GET /api/v1/servers/:id/tools
+func (h *Handlers) GetTools(w http.ResponseWriter, r *http.Request) {
+	serverID := chi.URLParam(r, "id")
+	if serverID == "" {
+		h.sendError(w, http.StatusBadRequest, "server ID required")
+		return
+	}
+
+	// Parse time range
+	from, to, _ := h.parseTimeRange(r)
+
+	// Parse pagination
+	limit, offset := h.parsePagination(r)
+
+	tools, total, err := h.repo.GetToolMetrics(r.Context(), serverID, from, to, limit, offset)
+	if err != nil {
+		h.logger.Error("failed to get tools", zap.Error(err))
+		h.sendError(w, http.StatusInternalServerError, "failed to get tools")
+		return
+	}
+
+	h.sendJSON(w, http.StatusOK, map[string]interface{}{
+		"server_id": serverID,
+		"tools":     tools,
+		"pagination": models.Pagination{
+			Total:  total,
+			Limit:  limit,
+			Offset: offset,
+		},
+	})
+}
+
+// GetToolTimeline handles GET /api/v1/servers/:id/tools/:name/timeline
+func (h *Handlers) GetToolTimeline(w http.ResponseWriter, r *http.Request) {
+	serverID := chi.URLParam(r, "id")
+	toolName := chi.URLParam(r, "name")
+
+	if serverID == "" || toolName == "" {
+		h.sendError(w, http.StatusBadRequest, "server ID and tool name required")
+		return
+	}
+
+	// Parse time range
+	from, to, interval := h.parseTimeRange(r)
+
+	timeline, err := h.repo.GetToolTimeline(r.Context(), serverID, toolName, from, to, interval)
+	if err != nil {
+		h.logger.Error("failed to get tool timeline", zap.Error(err))
+		h.sendError(w, http.StatusInternalServerError, "failed to get tool timeline")
+		return
+	}
+
+	h.sendJSON(w, http.StatusOK, map[string]interface{}{
+		"server_id": serverID,
+		"tool_name": toolName,
+		"timeline":  timeline,
+	})
+}
+
+// GetErrors handles GET /api/v1/servers/:id/errors
+func (h *Handlers) GetErrors(w http.ResponseWriter, r *http.Request) {
+	serverID := chi.URLParam(r, "id")
+	if serverID == "" {
+		h.sendError(w, http.StatusBadRequest, "server ID required")
+		return
+	}
+
+	// Parse time range
+	from, to, _ := h.parseTimeRange(r)
+
+	// Parse pagination
+	limit, offset := h.parsePagination(r)
+
+	// Parse optional tool filter
+	var toolName *string
+	if tool := r.URL.Query().Get("tool"); tool != "" {
+		toolName = &tool
+	}
+
+	errs, total, err := h.repo.GetErrors(r.Context(), serverID, from, to, toolName, limit, offset)
+	if err != nil {
+		h.logger.Error("failed to get errs", zap.Error(err))
+		h.sendError(w, http.StatusInternalServerError, "failed to get errs")
+		return
+	}
+
+	h.sendJSON(w, http.StatusOK, map[string]interface{}{
+		"server_id": serverID,
+		"errs":      errs,
+		"pagination": models.Pagination{
+			Total:  total,
+			Limit:  limit,
+			Offset: offset,
+		},
+	})
+}
+
+// GetSessions handles GET /api/v1/servers/:id/sessions
+func (h *Handlers) GetSessions(w http.ResponseWriter, r *http.Request) {
+	serverID := chi.URLParam(r, "id")
+	if serverID == "" {
+		h.sendError(w, http.StatusBadRequest, "server ID required")
+		return
+	}
+
+	// Parse time range
+	from, _, _ := h.parseTimeRange(r)
+
+	// Parse pagination
+	limit, offset := h.parsePagination(r)
+
+	// Parse status filter
+	activeOnly := r.URL.Query().Get("status") == "active"
+
+	sessions, total, err := h.repo.GetSessions(r.Context(), serverID, from, activeOnly, limit, offset)
+	if err != nil {
+		h.logger.Error("failed to get sessions", zap.Error(err))
+		h.sendError(w, http.StatusInternalServerError, "failed to get sessions")
+		return
+	}
+
+	h.sendJSON(w, http.StatusOK, map[string]interface{}{
+		"server_id": serverID,
+		"sessions":  sessions,
+		"pagination": models.Pagination{
+			Total:  total,
+			Limit:  limit,
+			Offset: offset,
+		},
+	})
+}
+
+// parseTimeRange parses time range from query parameters
+func (h *Handlers) parseTimeRange(r *http.Request) (from, to time.Time, interval string) {
+	// Default to last 24 hours
+	to = time.Now()
+	from = to.Add(-24 * time.Hour)
+
+	// Parse 'from' parameter
+	if fromStr := r.URL.Query().Get("from"); fromStr != "" {
+		if d, err := parseDuration(fromStr); err == nil {
+			from = time.Now().Add(-d)
+		} else if t, err := time.Parse(time.RFC3339, fromStr); err == nil {
+			from = t
+		}
+	}
+
+	// Parse 'to' parameter
+	if toStr := r.URL.Query().Get("to"); toStr != "" {
+		if toStr == "now" {
+			to = time.Now()
+		} else if t, err := time.Parse(time.RFC3339, toStr); err == nil {
+			to = t
+		}
+	}
+
+	// Parse 'interval' parameter
+	interval = r.URL.Query().Get("interval")
+	if interval == "" {
+		// Auto-select interval based on time range
+		duration := to.Sub(from)
+		if duration <= 6*time.Hour {
+			interval = "5m"
+		} else if duration <= 2*24*time.Hour {
+			interval = "1h"
+		} else if duration <= 30*24*time.Hour {
+			interval = "1d"
+		} else {
+			interval = "1w"
+		}
+	}
+
+	return from, to, interval
+}
+
+// parsePagination parses pagination parameters
+func (h *Handlers) parsePagination(r *http.Request) (limit, offset int) {
+	limit = 20 // default
+
+	if limitStr := r.URL.Query().Get("limit"); limitStr != "" {
+		if l, err := strconv.Atoi(limitStr); err == nil && l > 0 {
+			limit = l
+		}
+	}
+
+	if limit > 100 {
+		limit = 100 // max
+	}
+
+	if offsetStr := r.URL.Query().Get("offset"); offsetStr != "" {
+		if o, err := strconv.Atoi(offsetStr); err == nil && o >= 0 {
+			offset = o
+		}
+	}
+
+	return limit, offset
+}
+
+// parseDuration parses duration strings like "24h", "7d", "30d"
+func parseDuration(s string) (time.Duration, error) {
+	if len(s) < 2 {
+		return 0, nil
+	}
+
+	unit := s[len(s)-1]
+	valueStr := s[:len(s)-1]
+	value, err := strconv.Atoi(valueStr)
+	if err != nil {
+		return 0, err
+	}
+
+	switch unit {
+	case 'm':
+		return time.Duration(value) * time.Minute, nil
+	case 'h':
+		return time.Duration(value) * time.Hour, nil
+	case 'd':
+		return time.Duration(value) * 24 * time.Hour, nil
+	case 'w':
+		return time.Duration(value) * 7 * 24 * time.Hour, nil
+	default:
+		return 0, nil
+	}
+}
+
+// sendJSON sends a JSON response
+func (h *Handlers) sendJSON(w http.ResponseWriter, status int, data interface{}) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(data)
+}
+
+// sendError sends an error response
+func (h *Handlers) sendError(w http.ResponseWriter, status int, message string) {
+	h.sendJSON(w, status, map[string]interface{}{
+		"error": message,
+	})
+}