Rename handlers and add PrefixHandler for database routing table

- Renamed BatchedDatabaseHandler to DBHandler
- Renamed BatchedPeerHandler to PeerHandler
- Quadrupled DBHandler batch size from 4000 to 16000
- Created new PrefixHandler using same batching strategy to maintain routing table in database
- Removed verbose batch flush logging from all handlers
- Updated app.go to use renamed handlers and register PrefixHandler
- Fixed test configuration to enable batched database writes

internal/routewatch/peerhandler.go

@@ -2,6 +2,8 @@ package routewatch
 
 import (
 	"strconv"
+	"sync"
+	"time"
 
 	"git.eeqj.de/sneak/routewatch/internal/database"
 	"git.eeqj.de/sneak/routewatch/internal/logger"
@@ -10,21 +12,50 @@ import (
 
 const (
 	// peerHandlerQueueSize is the queue capacity for peer tracking operations
-	peerHandlerQueueSize = 500
+	peerHandlerQueueSize = 2000
+
+	// peerBatchSize is the number of peer updates to batch together
+	peerBatchSize = 500
+
+	// peerBatchTimeout is the maximum time to wait before flushing a batch
+	peerBatchTimeout = 5 * time.Second
 )
 
-// PeerHandler tracks BGP peers from all message types
+// PeerHandler tracks BGP peers from all message types using batched operations
 type PeerHandler struct {
 	db     database.Store
 	logger *logger.Logger
+
+	// Batching
+	mu        sync.Mutex
+	peerBatch []peerUpdate
+	lastFlush time.Time
+	stopCh    chan struct{}
+	wg        sync.WaitGroup
 }
 
-// NewPeerHandler creates a new peer tracking handler
+type peerUpdate struct {
+	peerIP      string
+	peerASN     int
+	messageType string
+	timestamp   time.Time
+}
+
+// NewPeerHandler creates a new batched peer tracking handler
 func NewPeerHandler(db database.Store, logger *logger.Logger) *PeerHandler {
-	return &PeerHandler{
-		db:     db,
-		logger: logger,
+	h := &PeerHandler{
+		db:        db,
+		logger:    logger,
+		peerBatch: make([]peerUpdate, 0, peerBatchSize),
+		lastFlush: time.Now(),
+		stopCh:    make(chan struct{}),
 	}
+
+	// Start the flush timer goroutine
+	h.wg.Add(1)
+	go h.flushLoop()
+
+	return h
 }
 
 // WantsMessage returns true for all message types since we track peers from all messages
@@ -34,7 +65,7 @@ func (h *PeerHandler) WantsMessage(_ string) bool {
 
 // QueueCapacity returns the desired queue capacity for this handler
 func (h *PeerHandler) QueueCapacity() int {
-	// Peer tracking is lightweight but involves database ops, use moderate queue
+	// Batching allows us to use a larger queue
 	return peerHandlerQueueSize
 }
 
@@ -48,13 +79,81 @@ func (h *PeerHandler) HandleMessage(msg *ristypes.RISMessage) {
 		}
 	}
 
-	// Update peer in database
-	if err := h.db.UpdatePeer(msg.Peer, peerASN, msg.Type, msg.ParsedTimestamp); err != nil {
-		h.logger.Error("Failed to update peer",
-			"peer", msg.Peer,
-			"peer_asn", peerASN,
-			"message_type", msg.Type,
-			"error", err,
-		)
+	h.mu.Lock()
+	defer h.mu.Unlock()
+
+	// Add to batch
+	h.peerBatch = append(h.peerBatch, peerUpdate{
+		peerIP:      msg.Peer,
+		peerASN:     peerASN,
+		messageType: msg.Type,
+		timestamp:   msg.ParsedTimestamp,
+	})
+
+	// Check if we need to flush
+	if len(h.peerBatch) >= peerBatchSize {
+		h.flushBatchLocked()
 	}
 }
+
+// flushLoop runs in a goroutine and periodically flushes batches
+func (h *PeerHandler) flushLoop() {
+	defer h.wg.Done()
+	ticker := time.NewTicker(peerBatchTimeout)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			h.mu.Lock()
+			if time.Since(h.lastFlush) >= peerBatchTimeout {
+				h.flushBatchLocked()
+			}
+			h.mu.Unlock()
+		case <-h.stopCh:
+			// Final flush
+			h.mu.Lock()
+			h.flushBatchLocked()
+			h.mu.Unlock()
+
+			return
+		}
+	}
+}
+
+// flushBatchLocked flushes the peer batch to the database (must be called with mutex held)
+func (h *PeerHandler) flushBatchLocked() {
+	if len(h.peerBatch) == 0 {
+		return
+	}
+
+	// Deduplicate by peer IP, keeping the latest update for each peer
+	peerMap := make(map[string]peerUpdate)
+	for _, update := range h.peerBatch {
+		if existing, ok := peerMap[update.peerIP]; !ok || update.timestamp.After(existing.timestamp) {
+			peerMap[update.peerIP] = update
+		}
+	}
+
+	// Apply updates
+	for _, update := range peerMap {
+		if err := h.db.UpdatePeer(update.peerIP, update.peerASN, update.messageType, update.timestamp); err != nil {
+			h.logger.Error("Failed to update peer",
+				"peer", update.peerIP,
+				"peer_asn", update.peerASN,
+				"message_type", update.messageType,
+				"error", err,
+			)
+		}
+	}
+
+	// Clear batch
+	h.peerBatch = h.peerBatch[:0]
+	h.lastFlush = time.Now()
+}
+
+// Stop gracefully stops the handler and flushes remaining batches
+func (h *PeerHandler) Stop() {
+	close(h.stopCh)
+	h.wg.Wait()
+}