Add SQL query logging and performance improvements

- Implement comprehensive SQL query logging for queries over 10ms
- Add logging wrapper methods for all database operations
- Replace timing code in GetStats with simple info log messages
- Add missing database indexes for better query performance:
  - idx_live_routes_lookup for common prefix/origin/peer lookups
  - idx_live_routes_withdraw for withdrawal updates
  - idx_prefixes_prefix for prefix lookups
  - idx_asn_peerings_lookup for peering relationship queries
- Increase SQLite cache size to 512MB
- Add performance-oriented SQLite pragmas
- Extract HTML templates to separate files using go:embed
- Add JSON response middleware with @meta field (like bgpview.io API)
- Fix concurrent map write errors in HTTP handlers
- Add request timeout handling with proper JSON error responses

These changes significantly improve database query performance and
provide visibility into slow queries for debugging purposes.

internal/server/server.go

@@ -47,8 +47,9 @@ func (s *Server) setupRoutes() {
 	r.Use(middleware.RealIP)
 	r.Use(middleware.Logger)
 	r.Use(middleware.Recoverer)
-	const requestTimeout = 60 * time.Second
-	r.Use(middleware.Timeout(requestTimeout))
+	const requestTimeout = 2 * time.Second
+	r.Use(TimeoutMiddleware(requestTimeout))
+	r.Use(JSONResponseMiddleware)
 
 	// Routes
 	r.Get("/", s.handleRoot())
@@ -124,15 +125,60 @@ func (s *Server) handleStatusJSON() http.HandlerFunc {
 		LiveRoutes     int     `json:"live_routes"`
 	}
 
-	return func(w http.ResponseWriter, _ *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
+		// Create a 1 second timeout context for this request
+		ctx, cancel := context.WithTimeout(r.Context(), 1*time.Second)
+		defer cancel()
+
 		metrics := s.streamer.GetMetrics()
 
-		// Get database stats
-		dbStats, err := s.db.GetStats()
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
+		// Get database stats with timeout
+		statsChan := make(chan database.Stats)
+		errChan := make(chan error)
+
+		go func() {
+			s.logger.Debug("Starting database stats query")
+			dbStats, err := s.db.GetStats()
+			if err != nil {
+				s.logger.Debug("Database stats query failed", "error", err)
+				errChan <- err
+
+				return
+			}
+			s.logger.Debug("Database stats query completed")
+			statsChan <- dbStats
+		}()
+
+		var dbStats database.Stats
+		select {
+		case <-ctx.Done():
+			s.logger.Error("Database stats timeout in status.json")
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusRequestTimeout)
+			_ = json.NewEncoder(w).Encode(map[string]interface{}{
+				"status": "error",
+				"error": map[string]interface{}{
+					"msg":  "Database timeout",
+					"code": http.StatusRequestTimeout,
+				},
+			})
 
 			return
+		case err := <-errChan:
+			s.logger.Error("Failed to get database stats", "error", err)
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusInternalServerError)
+			_ = json.NewEncoder(w).Encode(map[string]interface{}{
+				"status": "error",
+				"error": map[string]interface{}{
+					"msg":  err.Error(),
+					"code": http.StatusInternalServerError,
+				},
+			})
+
+			return
+		case dbStats = <-statsChan:
+			// Success
 		}
 
 		uptime := time.Since(metrics.ConnectedSince).Truncate(time.Second).String()
@@ -158,7 +204,11 @@ func (s *Server) handleStatusJSON() http.HandlerFunc {
 		}
 
 		w.Header().Set("Content-Type", "application/json")
-		if err := json.NewEncoder(w).Encode(stats); err != nil {
+		response := map[string]interface{}{
+			"status": "ok",
+			"data":   stats,
+		}
+		if err := json.NewEncoder(w).Encode(response); err != nil {
 			s.logger.Error("Failed to encode stats", "error", err)
 		}
 	}
@@ -182,15 +232,53 @@ func (s *Server) handleStats() http.HandlerFunc {
 		LiveRoutes     int     `json:"live_routes"`
 	}
 
-	return func(w http.ResponseWriter, _ *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
+		// Create a 1 second timeout context for this request
+		ctx, cancel := context.WithTimeout(r.Context(), 1*time.Second)
+		defer cancel()
+
+		// Check if context is already cancelled
+		select {
+		case <-ctx.Done():
+			http.Error(w, "Request timeout", http.StatusRequestTimeout)
+
+			return
+		default:
+		}
+
 		metrics := s.streamer.GetMetrics()
 
-		// Get database stats
-		dbStats, err := s.db.GetStats()
-		if err != nil {
+		// Get database stats with timeout
+		statsChan := make(chan database.Stats)
+		errChan := make(chan error)
+
+		go func() {
+			s.logger.Debug("Starting database stats query")
+			dbStats, err := s.db.GetStats()
+			if err != nil {
+				s.logger.Debug("Database stats query failed", "error", err)
+				errChan <- err
+
+				return
+			}
+			s.logger.Debug("Database stats query completed")
+			statsChan <- dbStats
+		}()
+
+		var dbStats database.Stats
+		select {
+		case <-ctx.Done():
+			s.logger.Error("Database stats timeout")
+			http.Error(w, "Database timeout", http.StatusRequestTimeout)
+
+			return
+		case err := <-errChan:
+			s.logger.Error("Failed to get database stats", "error", err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 
 			return
+		case dbStats = <-statsChan:
+			// Success
 		}
 
 		uptime := time.Since(metrics.ConnectedSince).Truncate(time.Second).String()
@@ -216,7 +304,11 @@ func (s *Server) handleStats() http.HandlerFunc {
 		}
 
 		w.Header().Set("Content-Type", "application/json")
-		if err := json.NewEncoder(w).Encode(stats); err != nil {
+		response := map[string]interface{}{
+			"status": "ok",
+			"data":   stats,
+		}
+		if err := json.NewEncoder(w).Encode(response); err != nil {
 			s.logger.Error("Failed to encode stats", "error", err)
 		}
 	}