Use TRUNCATE mode for WAL checkpoints

PASSIVE checkpoints may not fully checkpoint when writers are active.
TRUNCATE mode blocks writers briefly but ensures complete checkpointing,
keeping the WAL small for consistent read performance under heavy load.

.gitignore

@@ -6,6 +6,9 @@
 *.dylib
 /bin/
 
+.DS_Store
+log.txt
+
 # Test binary, built with `go test -c`
 *.test
 
@@ -34,4 +37,5 @@ go.work.sum
 pkg/asinfo/asdata.json
 
 # Debug output files
-out
+out
+log.txt

Dockerfile

@@ -0,0 +1,65 @@
+# Build stage
+FROM golang:1.24-bookworm AS builder
+
+# Install build dependencies (zstd for archive, gcc for CGO/sqlite3)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    zstd \
+    gcc \
+    libc6-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /src
+
+# Copy everything
+COPY . .
+
+# Vendor dependencies (must be after copying source)
+RUN go mod download && go mod vendor
+
+# Build the binary with CGO enabled (required for sqlite3)
+RUN CGO_ENABLED=1 GOOS=linux go build -o /routewatch ./cmd/routewatch
+
+# Create source archive with vendored dependencies
+RUN tar --zstd -cf /routewatch-source.tar.zst \
+    --exclude='.git' \
+    --exclude='*.tar.zst' \
+    .
+
+# Runtime stage
+FROM debian:bookworm-slim
+
+# Install runtime dependencies
+# - ca-certificates: for HTTPS connections
+# - curl: for health checks
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ca-certificates \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create non-root user
+RUN useradd -r -u 1000 -m routewatch
+
+RUN mkdir -p /var/lib/berlin.sneak.app.routewatch && chown routewatch:routewatch /var/lib/berlin.sneak.app.routewatch
+
+RUN mkdir /app
+WORKDIR /app
+
+# Copy binary and source archive from builder
+COPY --from=builder /routewatch /app/routewatch
+COPY --from=builder /routewatch-source.tar.zst /app/source/routewatch-source.tar.zst
+
+# Set ownership
+RUN chown -R routewatch:routewatch /app
+
+ENV XDG_DATA_HOME=/var/lib
+
+# Expose HTTP port
+EXPOSE 8080
+
+COPY ./entrypoint.sh /entrypoint.sh
+
+# Health check using the health endpoint
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+    CMD curl -sf http://localhost:8080/.well-known/healthcheck.json || exit 1
+
+ENTRYPOINT ["/bin/bash", "/entrypoint.sh" ]

Makefile

@@ -1,5 +1,11 @@
 export DEBUG = routewatch
 
+# Git revision for version embedding
+GIT_REVISION := $(shell git rev-parse HEAD 2>/dev/null || echo "unknown")
+GIT_REVISION_SHORT := $(shell git rev-parse --short HEAD 2>/dev/null || echo "unknown")
+VERSION_PKG := git.eeqj.de/sneak/routewatch/internal/version
+LDFLAGS := -X $(VERSION_PKG).GitRevision=$(GIT_REVISION) -X $(VERSION_PKG).GitRevisionShort=$(GIT_REVISION_SHORT)
+
 .PHONY: test fmt lint build clean run asupdate
 
 all: test
@@ -15,13 +21,13 @@ lint:
 	golangci-lint run
 
 build:
-	CGO_ENABLED=1 go build -o bin/routewatch cmd/routewatch/main.go
+	CGO_ENABLED=1 go build -ldflags "$(LDFLAGS)" -o bin/routewatch cmd/routewatch/main.go
 
 clean:
 	rm -rf bin/
 
 run: build
-	./bin/routewatch
+	DEBUG=routewatch ./bin/routewatch 2>&1 | tee log.txt
 
 asupdate:
 	@echo "Updating AS info data..."

README.md

@@ -0,0 +1,194 @@
+# RouteWatch
+
+RouteWatch is a real-time BGP routing table monitor that streams BGP UPDATE messages from the RIPE RIS Live service, maintains a live routing table in SQLite, and provides HTTP APIs for querying routing information.
+
+
+## Features
+
+- Real-time streaming of BGP updates from RIPE RIS Live
+- Maintains live IPv4 and IPv6 routing tables
+- Tracks AS peering relationships
+- HTTP API for IP-to-AS lookups, prefix details, and AS information
+- Automatic reconnection with exponential backoff
+- Batched database writes for high performance
+- Backpressure handling to prevent memory exhaustion
+
+## Installation
+
+```bash
+go build -o routewatch ./cmd/routewatch
+```
+
+## Usage
+
+```bash
+# Run the daemon (listens on port 8080 by default)
+./routewatch
+
+# Set custom port
+PORT=3000 ./routewatch
+
+# Enable debug logging
+DEBUG=routewatch ./routewatch
+```
+
+## HTTP Endpoints
+
+### Web Interface
+- `GET /` - Redirects to /status
+- `GET /status` - HTML status dashboard
+- `GET /status.json` - JSON statistics
+- `GET /as/{asn}` - AS detail page (HTML)
+- `GET /prefix/{prefix}` - Prefix detail page (HTML)
+- `GET /prefixlength/{length}` - IPv4 prefixes by mask length
+- `GET /prefixlength6/{length}` - IPv6 prefixes by mask length
+- `GET /ip/{ip}` - Redirects to prefix containing the IP
+
+### API v1
+- `GET /api/v1/stats` - Detailed statistics with handler metrics
+- `GET /api/v1/ip/{ip}` - Look up AS information for an IP address
+- `GET /api/v1/as/{asn}` - Get prefixes announced by an AS
+- `GET /api/v1/prefix/{prefix}` - Get routes for a specific prefix
+
+## Code Structure
+
+```
+routewatch/
+├── cmd/
+│   ├── routewatch/         # Main daemon entry point
+│   ├── asinfo-gen/         # Utility to generate AS info data
+│   └── streamdumper/       # Debug utility for raw stream output
+├── internal/
+│   ├── routewatch/         # Core application logic
+│   ├── server/             # HTTP server and handlers
+│   ├── database/           # SQLite storage layer
+│   ├── streamer/           # RIPE RIS Live client
+│   ├── ristypes/           # BGP message data structures
+│   ├── logger/             # Structured logging wrapper
+│   ├── metrics/            # Performance metrics tracking
+│   ├── config/             # Configuration management
+│   └── templates/          # HTML templates
+└── pkg/
+    └── asinfo/             # AS information lookup (public API)
+```
+
+## Architecture Overview
+
+### Component Relationships
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                         RouteWatch                               │
+│  (internal/routewatch/app.go - main orchestrator)               │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐       │
+│  │   Streamer   │───▶│   Handlers   │───▶│   Database   │       │
+│  │              │    │              │    │              │       │
+│  │ RIS Live     │    │ - ASHandler  │    │ SQLite with  │       │
+│  │ WebSocket    │    │ - PeerHandler│    │ WAL mode     │       │
+│  │ client       │    │ - PrefixHdlr │    │              │       │
+│  │              │    │ - PeeringHdlr│    │ Tables:      │       │
+│  └──────────────┘    └──────────────┘    │ - asns       │       │
+│                                          │ - prefixes   │       │
+│  ┌──────────────┐    ┌──────────────┐    │ - live_routes│       │
+│  │    Server    │───▶│   Handlers   │───▶│ - peerings   │       │
+│  │              │    │              │    │ - bgp_peers  │       │
+│  │ Chi router   │    │ Status, API  │    └──────────────┘       │
+│  │ port 8080    │    │ AS, Prefix   │                           │
+│  └──────────────┘    └──────────────┘                           │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### Execution Flow
+
+1. **Startup** (`cmd/routewatch/main.go` → `internal/routewatch/cli.go`)
+   - Uber fx dependency injection initializes all components
+   - Signal handlers registered for graceful shutdown
+
+2. **Initialization** (`internal/routewatch/app.go`)
+   - Database created with SQLite schema (WAL mode, 3GB cache)
+   - Message handlers registered with the streamer
+   - HTTP server started on configured port
+
+3. **Message Processing Pipeline**
+   ```
+   RIS Live Stream → JSON Parser → Message Dispatcher → Handler Queues → Batch Writers → SQLite
+   ```
+   - Streamer connects to `ris-live.ripe.net` via HTTP
+   - Parses BGP UPDATE messages from JSON stream
+   - Dispatches to registered handlers based on message type
+   - Each handler has its own queue with backpressure handling
+   - Handlers batch writes for efficiency (25K-30K ops, 1-2s timeout)
+
+4. **Handler Details**
+   - **ASHandler**: Tracks all ASNs seen in AS paths
+   - **PeerHandler**: Records BGP peer information
+   - **PrefixHandler**: Maintains live routing table (upserts on announcement, deletes on withdrawal)
+   - **PeeringHandler**: Extracts AS peering relationships from AS paths
+
+5. **HTTP Request Flow**
+   ```
+   Request → Chi Router → Middleware (timeout, logging) → Handler → Database Query → Response
+   ```
+
+### Key Design Patterns
+
+- **Batched Writes**: All database operations are batched for performance
+- **Backpressure**: Probabilistic message dropping when queues exceed 50% capacity
+- **Graceful Shutdown**: 60-second timeout, flushes all pending batches
+- **Reconnection**: Exponential backoff (5s-320s) with reset after 30s of stable connection
+- **IPv4 Optimization**: IP ranges stored as uint32 for O(1) lookups
+
+### Database Schema
+
+```sql
+-- Core tables
+asns(id, number, handle, description, first_seen, last_seen)
+prefixes_v4(id, prefix, mask_length, first_seen, last_seen)
+prefixes_v6(id, prefix, mask_length, first_seen, last_seen)
+
+-- Live routing tables (one per IP version)
+live_routes_v4(id, prefix, mask_length, origin_asn, peer_ip, as_path,
+               next_hop, last_updated, v4_ip_start, v4_ip_end)
+live_routes_v6(id, prefix, mask_length, origin_asn, peer_ip, as_path,
+               next_hop, last_updated)
+
+-- Relationship tracking
+peerings(id, as_a, as_b, first_seen, last_seen)
+bgp_peers(id, peer_ip, peer_asn, last_message_type, last_seen)
+```
+
+## Configuration
+
+Configuration is handled via environment variables and OS-specific paths:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `PORT` | `8080` | HTTP server port |
+| `DEBUG` | (empty) | Set to `routewatch` for debug logging |
+
+State directory (database location):
+- macOS: `~/Library/Application Support/routewatch/`
+- Linux: `/var/lib/routewatch/` or `~/.local/share/routewatch/`
+
+## Development
+
+```bash
+# Run tests
+make test
+
+# Format code
+make fmt
+
+# Run linter
+make lint
+
+# Build
+make
+```
+
+## License
+
+See LICENSE file.

cmd/streamdumper/main.go

@@ -9,16 +9,14 @@ import (
 	"os/signal"
 	"syscall"
 
+	"git.eeqj.de/sneak/routewatch/internal/logger"
 	"git.eeqj.de/sneak/routewatch/internal/metrics"
 	"git.eeqj.de/sneak/routewatch/internal/streamer"
-	"log/slog"
 )
 
 func main() {
-	// Set up logger to only show errors
+	// Set up logger
-	logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{
+	logger := logger.New()
-		Level: slog.LevelError,
-	}))
 
 	// Create metrics tracker
 	metricsTracker := metrics.New()

entrypoint.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+cd /var/lib/berlin.sneak.app.routewatch
+chown -R routewatch:routewatch .
+chmod 700 .
+
+exec runuser -u routewatch -- /app/routewatch

go.mod

@@ -3,11 +3,13 @@ module git.eeqj.de/sneak/routewatch
 go 1.24.4
 
 require (
+	github.com/dustin/go-humanize v1.0.1
 	github.com/go-chi/chi/v5 v5.2.2
 	github.com/google/uuid v1.6.0
 	github.com/mattn/go-sqlite3 v1.14.29
 	github.com/rcrowley/go-metrics v0.0.0-20250401214520-65e299d6c5c9
 	go.uber.org/fx v1.24.0
+	golang.org/x/term v0.33.0
 )
 
 require (

go.sum

@@ -1,5 +1,7 @@
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
 github.com/go-chi/chi/v5 v5.2.2 h1:CMwsvRVTbXVytCk1Wd72Zy1LAsAh9GxMmSNWLHCG618=
 github.com/go-chi/chi/v5 v5.2.2/go.mod h1:L2yAIGWB3H+phAw1NxKwWM+7eUH/lU8pOMm5hHcoops=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
@@ -24,5 +26,7 @@ go.uber.org/zap v1.26.0 h1:sI7k6L95XOKS281NhVKOFCUNIvv9e0w4BF8N3u+tCRo=
 go.uber.org/zap v1.26.0/go.mod h1:dtElttAiwGvoJ/vj4IwHBS/gXsEu/pZ50mUIRWuG0so=
 golang.org/x/sys v0.34.0 h1:H5Y5sJ2L2JRdyv7ROF1he/lPdvFsd0mJHFw2ThKHxLA=
 golang.org/x/sys v0.34.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/term v0.33.0 h1:NuFncQrRcaRvVmgRkvM3j/F00gWIAlcmlB8ACEKmGIg=
+golang.org/x/term v0.33.0/go.mod h1:s18+ql9tYWp1IfpV9DmCtQDDSRBUjKaw9M1eAv5UeF0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/config/config.go

@@ -0,0 +1,103 @@
+// Package config provides centralized configuration management for RouteWatch
+package config
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"time"
+)
+
+const (
+	// AppIdentifier is the reverse domain name identifier for the app
+	AppIdentifier = "berlin.sneak.app.routewatch"
+
+	// dirPermissions for creating directories
+	dirPermissions = 0750 // rwxr-x---
+
+	// defaultRouteExpirationMinutes is the default route expiration timeout in minutes
+	defaultRouteExpirationMinutes = 5
+)
+
+// Config holds configuration for the entire application
+type Config struct {
+	// StateDir is the directory for all application state (database, snapshots)
+	StateDir string
+
+	// MaxRuntime is the maximum runtime (0 = run forever)
+	MaxRuntime time.Duration
+
+	// EnableBatchedDatabaseWrites enables batched database operations for better performance
+	EnableBatchedDatabaseWrites bool
+
+	// RouteExpirationTimeout is how long a route can go without being refreshed before expiring
+	// Default is 2 hours which is conservative for BGP (typical BGP hold time is 90-180 seconds)
+	RouteExpirationTimeout time.Duration
+}
+
+// New creates a new Config with default paths based on the OS
+func New() (*Config, error) {
+	stateDir, err := getStateDirectory()
+	if err != nil {
+		return nil, fmt.Errorf("failed to determine state directory: %w", err)
+	}
+
+	return &Config{
+		StateDir:                    stateDir,
+		MaxRuntime:                  0,                                           // Run forever by default
+		EnableBatchedDatabaseWrites: true,                                        // Enable batching by default
+		RouteExpirationTimeout:      defaultRouteExpirationMinutes * time.Minute, // For active route monitoring
+	}, nil
+}
+
+// GetStateDir returns the state directory path
+func (c *Config) GetStateDir() string {
+	return c.StateDir
+}
+
+// getStateDirectory returns the appropriate state directory based on the OS
+func getStateDirectory() (string, error) {
+	switch runtime.GOOS {
+	case "darwin":
+		// macOS: ~/Library/Application Support/berlin.sneak.app.routewatch
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return "", err
+		}
+
+		return filepath.Join(home, "Library", "Application Support", AppIdentifier), nil
+
+	case "linux", "freebsd", "openbsd", "netbsd":
+		// Unix-like: /var/lib/berlin.sneak.app.routewatch if root, else XDG_DATA_HOME
+		if os.Geteuid() == 0 {
+			return filepath.Join("/var/lib", AppIdentifier), nil
+		}
+
+		// Check XDG_DATA_HOME first
+		if xdgData := os.Getenv("XDG_DATA_HOME"); xdgData != "" {
+			return filepath.Join(xdgData, AppIdentifier), nil
+		}
+
+		// Fall back to ~/.local/share/berlin.sneak.app.routewatch
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return "", err
+		}
+
+		return filepath.Join(home, ".local", "share", AppIdentifier), nil
+
+	default:
+		return "", fmt.Errorf("unsupported operating system: %s", runtime.GOOS)
+	}
+}
+
+// EnsureDirectories creates all necessary directories if they don't exist
+func (c *Config) EnsureDirectories() error {
+	// Ensure state directory exists
+	if err := os.MkdirAll(c.StateDir, dirPermissions); err != nil {
+		return fmt.Errorf("failed to create state directory: %w", err)
+	}
+
+	return nil
+}

internal/database/database_test.go

@@ -0,0 +1,301 @@
+package database
+
+import (
+	"net"
+	"testing"
+)
+
+func TestIPToUint32(t *testing.T) {
+	tests := []struct {
+		name     string
+		ip       string
+		expected uint32
+	}{
+		{
+			name:     "Simple IP",
+			ip:       "192.168.1.1",
+			expected: 3232235777, // 192<<24 + 168<<16 + 1<<8 + 1
+		},
+		{
+			name:     "Minimum IP",
+			ip:       "0.0.0.0",
+			expected: 0,
+		},
+		{
+			name:     "Maximum IP",
+			ip:       "255.255.255.255",
+			expected: 4294967295,
+		},
+		{
+			name:     "10.0.0.0",
+			ip:       "10.0.0.0",
+			expected: 167772160,
+		},
+		{
+			name:     "172.16.0.0",
+			ip:       "172.16.0.0",
+			expected: 2886729728,
+		},
+		{
+			name:     "8.8.8.8",
+			ip:       "8.8.8.8",
+			expected: 134744072,
+		},
+		{
+			name:     "1.2.3.4",
+			ip:       "1.2.3.4",
+			expected: 16909060,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ip := net.ParseIP(tt.ip)
+			if ip == nil {
+				t.Fatalf("Failed to parse IP: %s", tt.ip)
+			}
+
+			result := ipToUint32(ip)
+			if result != tt.expected {
+				t.Errorf("ipToUint32(%s) = %d, want %d", tt.ip, result, tt.expected)
+			}
+
+			// Test with IPv4-mapped IPv6 address
+			ip6 := net.ParseIP(tt.ip).To16()
+			if ip6 != nil {
+				result6 := ipToUint32(ip6)
+				if result6 != tt.expected {
+					t.Errorf("ipToUint32(%s as IPv6) = %d, want %d", tt.ip, result6, tt.expected)
+				}
+			}
+		})
+	}
+}
+
+func TestCalculateIPv4Range(t *testing.T) {
+	tests := []struct {
+		name      string
+		cidr      string
+		wantStart uint32
+		wantEnd   uint32
+		wantErr   bool
+	}{
+		{
+			name:      "Single IP /32",
+			cidr:      "192.168.1.1/32",
+			wantStart: 3232235777,
+			wantEnd:   3232235777,
+		},
+		{
+			name:      "Class C /24",
+			cidr:      "192.168.1.0/24",
+			wantStart: 3232235776, // 192.168.1.0
+			wantEnd:   3232236031, // 192.168.1.255
+		},
+		{
+			name:      "Class B /16",
+			cidr:      "192.168.0.0/16",
+			wantStart: 3232235520, // 192.168.0.0
+			wantEnd:   3232301055, // 192.168.255.255
+		},
+		{
+			name:      "Class A /8",
+			cidr:      "10.0.0.0/8",
+			wantStart: 167772160, // 10.0.0.0
+			wantEnd:   184549375, // 10.255.255.255
+		},
+		{
+			name:      "Entire IPv4 space /0",
+			cidr:      "0.0.0.0/0",
+			wantStart: 0,
+			wantEnd:   4294967295,
+		},
+		{
+			name:      "Small subnet /30",
+			cidr:      "192.168.1.0/30",
+			wantStart: 3232235776, // 192.168.1.0
+			wantEnd:   3232235779, // 192.168.1.3
+		},
+		{
+			name:      "Medium subnet /20",
+			cidr:      "172.16.0.0/20",
+			wantStart: 2886729728, // 172.16.0.0
+			wantEnd:   2886733823, // 172.16.15.255
+		},
+		{
+			name:      "Private range 172.16/12",
+			cidr:      "172.16.0.0/12",
+			wantStart: 2886729728, // 172.16.0.0
+			wantEnd:   2887778303, // 172.31.255.255
+		},
+		{
+			name:      "Google DNS /29",
+			cidr:      "8.8.8.8/29",
+			wantStart: 134744072, // 8.8.8.8 (network is actually 8.8.8.8 with /29)
+			wantEnd:   134744079, // 8.8.8.15
+		},
+		{
+			name:      "Non-zero host bits",
+			cidr:      "192.168.1.5/24",
+			wantStart: 3232235776, // 192.168.1.0 (network address)
+			wantEnd:   3232236031, // 192.168.1.255
+		},
+		{
+			name:    "Invalid CIDR",
+			cidr:    "192.168.1.1/33",
+			wantErr: true,
+		},
+		{
+			name:    "Invalid IP",
+			cidr:    "256.256.256.256/24",
+			wantErr: true,
+		},
+		{
+			name:    "IPv6 CIDR",
+			cidr:    "2001:db8::/32",
+			wantErr: true,
+		},
+		{
+			name:    "Empty CIDR",
+			cidr:    "",
+			wantErr: true,
+		},
+		{
+			name:    "Missing mask",
+			cidr:    "192.168.1.1",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			start, end, err := CalculateIPv4Range(tt.cidr)
+
+			if tt.wantErr {
+				if err == nil {
+					t.Errorf("CalculateIPv4Range(%s) expected error, got nil", tt.cidr)
+				}
+				return
+			}
+
+			if err != nil {
+				t.Errorf("CalculateIPv4Range(%s) unexpected error: %v", tt.cidr, err)
+				return
+			}
+
+			if start != tt.wantStart {
+				t.Errorf("CalculateIPv4Range(%s) start = %d, want %d", tt.cidr, start, tt.wantStart)
+			}
+
+			if end != tt.wantEnd {
+				t.Errorf("CalculateIPv4Range(%s) end = %d, want %d", tt.cidr, end, tt.wantEnd)
+			}
+
+			// Verify that start <= end
+			if start > end {
+				t.Errorf("CalculateIPv4Range(%s) start (%d) > end (%d)", tt.cidr, start, end)
+			}
+
+			// Verify the range size matches the CIDR mask
+			if !tt.wantErr && tt.cidr != "" {
+				_, ipNet, _ := net.ParseCIDR(tt.cidr)
+				if ipNet != nil {
+					ones, bits := ipNet.Mask.Size()
+					expectedSize := uint32(1) << uint(bits-ones)
+					actualSize := end - start + 1
+					if actualSize != expectedSize {
+						t.Errorf("CalculateIPv4Range(%s) range size = %d, want %d", tt.cidr, actualSize, expectedSize)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestIPv4RangeIntegration(t *testing.T) {
+	// Test that our functions work correctly together
+	tests := []struct {
+		name          string
+		cidr          string
+		testIPs       []string
+		shouldContain []bool
+	}{
+		{
+			name: "192.168.1.0/24",
+			cidr: "192.168.1.0/24",
+			testIPs: []string{
+				"192.168.1.0",
+				"192.168.1.1",
+				"192.168.1.255",
+				"192.168.0.255",
+				"192.168.2.0",
+			},
+			shouldContain: []bool{true, true, true, false, false},
+		},
+		{
+			name: "10.0.0.0/8",
+			cidr: "10.0.0.0/8",
+			testIPs: []string{
+				"10.0.0.0",
+				"10.255.255.255",
+				"10.1.2.3",
+				"9.255.255.255",
+				"11.0.0.0",
+			},
+			shouldContain: []bool{true, true, true, false, false},
+		},
+		{
+			name: "172.16.0.0/12",
+			cidr: "172.16.0.0/12",
+			testIPs: []string{
+				"172.16.0.0",
+				"172.31.255.255",
+				"172.20.1.1",
+				"172.15.255.255",
+				"172.32.0.0",
+			},
+			shouldContain: []bool{true, true, true, false, false},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			start, end, err := CalculateIPv4Range(tt.cidr)
+			if err != nil {
+				t.Fatalf("Failed to calculate range for %s: %v", tt.cidr, err)
+			}
+
+			for i, testIP := range tt.testIPs {
+				ip := net.ParseIP(testIP)
+				if ip == nil {
+					t.Fatalf("Failed to parse test IP: %s", testIP)
+				}
+
+				ipUint := ipToUint32(ip)
+				contained := ipUint >= start && ipUint <= end
+
+				if contained != tt.shouldContain[i] {
+					t.Errorf("IP %s in range %s: got %v, want %v", testIP, tt.cidr, contained, tt.shouldContain[i])
+				}
+			}
+		})
+	}
+}
+
+func BenchmarkIPToUint32(b *testing.B) {
+	ip := net.ParseIP("192.168.1.1")
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		_ = ipToUint32(ip)
+	}
+}
+
+func BenchmarkCalculateIPv4Range(b *testing.B) {
+	cidr := "192.168.0.0/16"
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		_, _, _ = CalculateIPv4Range(cidr)
+	}
+}

internal/database/interface.go

@@ -1,41 +1,94 @@
+// Package database provides SQLite storage for BGP routing data including ASNs,
+// prefixes, announcements, peerings, and live route tables.
 package database
 
 import (
+	"context"
 	"time"
 )
 
-// Stats contains database statistics
+// Stats contains database statistics including counts for ASNs, prefixes,
+// peerings, peers, and live routes, as well as file size and prefix distribution data.
 type Stats struct {
-	ASNs          int
+	ASNs                   int
-	Prefixes      int
+	Prefixes               int
-	IPv4Prefixes  int
+	IPv4Prefixes           int
-	IPv6Prefixes  int
+	IPv6Prefixes           int
-	Peerings      int
+	Peerings               int
-	FileSizeBytes int64
+	Peers                  int
+	FileSizeBytes          int64
+	LiveRoutes             int
+	OldestRoute            *time.Time
+	NewestRoute            *time.Time
+	IPv4PrefixDistribution []PrefixDistribution
+	IPv6PrefixDistribution []PrefixDistribution
 }
 
-// Store defines the interface for database operations
+// Store defines the interface for database operations. It provides methods for
+// managing ASNs, prefixes, announcements, peerings, BGP peers, and live routes.
+// Implementations must be safe for concurrent use.
 type Store interface {
 	// ASN operations
 	GetOrCreateASN(number int, timestamp time.Time) (*ASN, error)
+	GetOrCreateASNBatch(asns map[int]time.Time) error
 
 	// Prefix operations
 	GetOrCreatePrefix(prefix string, timestamp time.Time) (*Prefix, error)
+	UpdatePrefixesBatch(prefixes map[string]time.Time) error
 
 	// Announcement operations
 	RecordAnnouncement(announcement *Announcement) error
 
 	// Peering operations
-	RecordPeering(fromASNID, toASNID string, timestamp time.Time) error
+	RecordPeering(asA, asB int, timestamp time.Time) error
 
 	// Statistics
 	GetStats() (Stats, error)
+	GetStatsContext(ctx context.Context) (Stats, error)
 
 	// Peer operations
 	UpdatePeer(peerIP string, peerASN int, messageType string, timestamp time.Time) error
+	UpdatePeerBatch(peers map[string]PeerUpdate) error
+
+	// Live route operations
+	UpsertLiveRoute(route *LiveRoute) error
+	UpsertLiveRouteBatch(routes []*LiveRoute) error
+	DeleteLiveRoute(prefix string, originASN int, peerIP string) error
+	DeleteLiveRouteBatch(deletions []LiveRouteDeletion) error
+	GetPrefixDistribution() (ipv4 []PrefixDistribution, ipv6 []PrefixDistribution, err error)
+	GetPrefixDistributionContext(ctx context.Context) (ipv4 []PrefixDistribution, ipv6 []PrefixDistribution, err error)
+	GetLiveRouteCounts() (ipv4Count, ipv6Count int, err error)
+	GetLiveRouteCountsContext(ctx context.Context) (ipv4Count, ipv6Count int, err error)
+
+	// IP lookup operations
+	GetASInfoForIP(ip string) (*ASInfo, error)
+	GetASInfoForIPContext(ctx context.Context, ip string) (*ASInfo, error)
+	GetIPInfo(ip string) (*IPInfo, error)
+	GetIPInfoContext(ctx context.Context, ip string) (*IPInfo, error)
+
+	// ASN WHOIS operations
+	GetNextStaleASN(ctx context.Context, staleThreshold time.Duration) (int, error)
+	UpdateASNWHOIS(ctx context.Context, update *ASNWHOISUpdate) error
+	GetWHOISStats(ctx context.Context, staleThreshold time.Duration) (*WHOISStats, error)
+
+	// AS and prefix detail operations
+	GetASDetails(asn int) (*ASN, []LiveRoute, error)
+	GetASDetailsContext(ctx context.Context, asn int) (*ASN, []LiveRoute, error)
+	GetASPeers(asn int) ([]ASPeer, error)
+	GetASPeersContext(ctx context.Context, asn int) ([]ASPeer, error)
+	GetPrefixDetails(prefix string) ([]LiveRoute, error)
+	GetPrefixDetailsContext(ctx context.Context, prefix string) ([]LiveRoute, error)
+	GetRandomPrefixesByLength(maskLength, ipVersion, limit int) ([]LiveRoute, error)
+	GetRandomPrefixesByLengthContext(ctx context.Context, maskLength, ipVersion, limit int) ([]LiveRoute, error)
 
 	// Lifecycle
 	Close() error
+
+	// Maintenance operations
+	Vacuum(ctx context.Context) error
+	Analyze(ctx context.Context) error
+	Checkpoint(ctx context.Context) error
+	Ping(ctx context.Context) error
 }
 
 // Ensure Database implements Store

internal/database/models.go

@@ -1,3 +1,4 @@
+// Package database provides SQLite storage for BGP routing data.
 package database
 
 import (
@@ -6,17 +7,34 @@ import (
 	"github.com/google/uuid"
 )
 
-// ASN represents an Autonomous System Number
+// ASN represents an Autonomous System Number with its metadata including
+// handle, description, WHOIS data, and first/last seen timestamps.
 type ASN struct {
-	ID          uuid.UUID `json:"id"`
+	ASN         int    `json:"asn"`
-	Number      int       `json:"number"`
+	Handle      string `json:"handle"`
-	Handle      string    `json:"handle"`
+	Description string `json:"description"`
-	Description string    `json:"description"`
+	// WHOIS parsed fields
-	FirstSeen   time.Time `json:"first_seen"`
+	ASName      string     `json:"as_name,omitempty"`
-	LastSeen    time.Time `json:"last_seen"`
+	OrgName     string     `json:"org_name,omitempty"`
+	OrgID       string     `json:"org_id,omitempty"`
+	Address     string     `json:"address,omitempty"`
+	CountryCode string     `json:"country_code,omitempty"`
+	AbuseEmail  string     `json:"abuse_email,omitempty"`
+	AbusePhone  string     `json:"abuse_phone,omitempty"`
+	TechEmail   string     `json:"tech_email,omitempty"`
+	TechPhone   string     `json:"tech_phone,omitempty"`
+	RIR         string     `json:"rir,omitempty"` // ARIN, RIPE, APNIC, LACNIC, AFRINIC
+	RIRRegDate  *time.Time `json:"rir_registration_date,omitempty"`
+	RIRLastMod  *time.Time `json:"rir_last_modified,omitempty"`
+	WHOISRaw    string     `json:"whois_raw,omitempty"`
+	// Timestamps
+	FirstSeen      time.Time  `json:"first_seen"`
+	LastSeen       time.Time  `json:"last_seen"`
+	WHOISUpdatedAt *time.Time `json:"whois_updated_at,omitempty"`
 }
 
-// Prefix represents an IP prefix (CIDR block)
+// Prefix represents an IP prefix (CIDR block) with its IP version (4 or 6)
+// and first/last seen timestamps.
 type Prefix struct {
 	ID        uuid.UUID `json:"id"`
 	Prefix    string    `json:"prefix"`
@@ -25,23 +43,117 @@ type Prefix struct {
 	LastSeen  time.Time `json:"last_seen"`
 }
 
-// Announcement represents a BGP announcement
+// Announcement represents a BGP announcement or withdrawal event,
+// containing the prefix, AS path, origin ASN, peer ASN, next hop, and timestamp.
 type Announcement struct {
 	ID           uuid.UUID `json:"id"`
 	PrefixID     uuid.UUID `json:"prefix_id"`
-	ASNID        uuid.UUID `json:"asn_id"`
+	PeerASN      int       `json:"peer_asn"`
-	OriginASNID  uuid.UUID `json:"origin_asn_id"`
+	OriginASN    int       `json:"origin_asn"`
 	Path         string    `json:"path"` // JSON-encoded AS path
 	NextHop      string    `json:"next_hop"`
 	Timestamp    time.Time `json:"timestamp"`
 	IsWithdrawal bool      `json:"is_withdrawal"`
 }
 
-// ASNPeering represents a peering relationship between two ASNs
+// ASNPeering represents a peering relationship between two ASNs,
+// stored with the lower ASN as ASA and the higher as ASB.
 type ASNPeering struct {
 	ID        uuid.UUID `json:"id"`
-	FromASNID uuid.UUID `json:"from_asn_id"`
+	ASA       int       `json:"as_a"`
-	ToASNID   uuid.UUID `json:"to_asn_id"`
+	ASB       int       `json:"as_b"`
 	FirstSeen time.Time `json:"first_seen"`
 	LastSeen  time.Time `json:"last_seen"`
 }
+
+// LiveRoute represents a route in the live routing table
+type LiveRoute struct {
+	ID          uuid.UUID `json:"id"`
+	Prefix      string    `json:"prefix"`
+	MaskLength  int       `json:"mask_length"`
+	IPVersion   int       `json:"ip_version"`
+	OriginASN   int       `json:"origin_asn"`
+	PeerIP      string    `json:"peer_ip"`
+	ASPath      []int     `json:"as_path"`
+	NextHop     string    `json:"next_hop"`
+	LastUpdated time.Time `json:"last_updated"`
+	// IPv4 range fields for fast lookups (nil for IPv6)
+	V4IPStart *uint32 `json:"v4_ip_start,omitempty"`
+	V4IPEnd   *uint32 `json:"v4_ip_end,omitempty"`
+}
+
+// PrefixDistribution represents the distribution of prefixes by mask length
+type PrefixDistribution struct {
+	MaskLength int `json:"mask_length"`
+	Count      int `json:"count"`
+}
+
+// ASInfo represents AS information for an IP lookup (legacy format)
+type ASInfo struct {
+	ASN         int       `json:"asn"`
+	Handle      string    `json:"handle"`
+	Description string    `json:"description"`
+	Prefix      string    `json:"prefix"`
+	LastUpdated time.Time `json:"last_updated"`
+	Age         string    `json:"age"`
+}
+
+// IPInfo represents comprehensive IP information for the /ip endpoint
+type IPInfo struct {
+	IP         string   `json:"ip"`
+	PTR        []string `json:"ptr,omitempty"`
+	Netblock   string   `json:"netblock"`
+	MaskLength int      `json:"mask_length"`
+	IPVersion  int      `json:"ip_version"`
+	NumPeers   int      `json:"num_peers"`
+	// AS information
+	ASN         int    `json:"asn"`
+	ASName      string `json:"as_name,omitempty"`
+	Handle      string `json:"handle,omitempty"`
+	Description string `json:"description,omitempty"`
+	OrgName     string `json:"org_name,omitempty"`
+	OrgID       string `json:"org_id,omitempty"`
+	Address     string `json:"address,omitempty"`
+	CountryCode string `json:"country_code,omitempty"`
+	AbuseEmail  string `json:"abuse_email,omitempty"`
+	RIR         string `json:"rir,omitempty"`
+	// Timestamps
+	FirstSeen time.Time `json:"first_seen"`
+	LastSeen  time.Time `json:"last_seen"`
+	// Indicates if WHOIS data needs refresh (not serialized)
+	NeedsWHOISRefresh bool `json:"-"`
+}
+
+// LiveRouteDeletion represents parameters for deleting a live route
+type LiveRouteDeletion struct {
+	Prefix    string
+	OriginASN int
+	PeerIP    string
+	IPVersion int
+}
+
+// PeerUpdate represents parameters for updating a peer
+type PeerUpdate struct {
+	PeerIP      string
+	PeerASN     int
+	MessageType string
+	Timestamp   time.Time
+}
+
+// ASNWHOISUpdate contains WHOIS data for updating an ASN record.
+type ASNWHOISUpdate struct {
+	ASN         int
+	ASName      string
+	OrgName     string
+	OrgID       string
+	Address     string
+	CountryCode string
+	AbuseEmail  string
+	AbusePhone  string
+	TechEmail   string
+	TechPhone   string
+	RIR         string
+	RIRRegDate  *time.Time
+	RIRLastMod  *time.Time
+	WHOISRaw    string
+}

internal/database/schema.sql

@@ -1,16 +1,44 @@
+-- IMPORTANT: This is the ONLY place where schema changes should be made.
+-- We do NOT support migrations. All schema changes MUST be in this file.
+-- DO NOT make schema changes anywhere else in the codebase.
+
 CREATE TABLE IF NOT EXISTS asns (
-	id TEXT PRIMARY KEY,
+	asn INTEGER PRIMARY KEY,
-	number INTEGER UNIQUE NOT NULL,
 	handle TEXT,
 	description TEXT,
+	-- WHOIS parsed fields
+	as_name TEXT,
+	org_name TEXT,
+	org_id TEXT,
+	address TEXT,                -- full address (may be multi-line)
+	country_code TEXT,
+	abuse_email TEXT,
+	abuse_phone TEXT,
+	tech_email TEXT,
+	tech_phone TEXT,
+	rir TEXT,                    -- ARIN, RIPE, APNIC, LACNIC, AFRINIC
+	rir_registration_date DATETIME,
+	rir_last_modified DATETIME,
+	-- Raw WHOIS response
+	whois_raw TEXT,              -- complete WHOIS response text
+	-- Timestamps
+	first_seen DATETIME NOT NULL,
+	last_seen DATETIME NOT NULL,
+	whois_updated_at DATETIME    -- when we last fetched WHOIS data
+);
+
+-- IPv4 prefixes table
+CREATE TABLE IF NOT EXISTS prefixes_v4 (
+	id TEXT PRIMARY KEY,
+	prefix TEXT UNIQUE NOT NULL,
 	first_seen DATETIME NOT NULL,
 	last_seen DATETIME NOT NULL
 );
 
-CREATE TABLE IF NOT EXISTS prefixes (
+-- IPv6 prefixes table
+CREATE TABLE IF NOT EXISTS prefixes_v6 (
 	id TEXT PRIMARY KEY,
 	prefix TEXT UNIQUE NOT NULL,
-	ip_version INTEGER NOT NULL, -- 4 for IPv4, 6 for IPv6
 	first_seen DATETIME NOT NULL,
 	last_seen DATETIME NOT NULL
 );
@@ -18,26 +46,23 @@ CREATE TABLE IF NOT EXISTS prefixes (
 CREATE TABLE IF NOT EXISTS announcements (
 	id TEXT PRIMARY KEY,
 	prefix_id TEXT NOT NULL,
-	asn_id TEXT NOT NULL,
+	peer_asn INTEGER NOT NULL,
-	origin_asn_id TEXT NOT NULL,
+	origin_asn INTEGER NOT NULL,
 	path TEXT NOT NULL,
 	next_hop TEXT,
 	timestamp DATETIME NOT NULL,
 	is_withdrawal BOOLEAN NOT NULL DEFAULT 0,
-	FOREIGN KEY (prefix_id) REFERENCES prefixes(id),
+	FOREIGN KEY (peer_asn) REFERENCES asns(asn),
-	FOREIGN KEY (asn_id) REFERENCES asns(id),
+	FOREIGN KEY (origin_asn) REFERENCES asns(asn)
-	FOREIGN KEY (origin_asn_id) REFERENCES asns(id)
 );
 
-CREATE TABLE IF NOT EXISTS asn_peerings (
+CREATE TABLE IF NOT EXISTS peerings (
 	id TEXT PRIMARY KEY,
-	from_asn_id TEXT NOT NULL,
+	as_a INTEGER NOT NULL,
-	to_asn_id TEXT NOT NULL,
+	as_b INTEGER NOT NULL,
 	first_seen DATETIME NOT NULL,
 	last_seen DATETIME NOT NULL,
-	FOREIGN KEY (from_asn_id) REFERENCES asns(id),
+	UNIQUE(as_a, as_b)
-	FOREIGN KEY (to_asn_id) REFERENCES asns(id),
-	UNIQUE(from_asn_id, to_asn_id)
 );
 
 -- BGP peers that send us messages
@@ -50,22 +75,72 @@ CREATE TABLE IF NOT EXISTS bgp_peers (
 	last_message_type TEXT
 );
 
-CREATE INDEX IF NOT EXISTS idx_prefixes_ip_version ON prefixes(ip_version);
+-- Indexes for prefixes_v4 table
-CREATE INDEX IF NOT EXISTS idx_prefixes_version_prefix ON prefixes(ip_version, prefix);
+CREATE INDEX IF NOT EXISTS idx_prefixes_v4_prefix ON prefixes_v4(prefix);
+
+-- Indexes for prefixes_v6 table
+CREATE INDEX IF NOT EXISTS idx_prefixes_v6_prefix ON prefixes_v6(prefix);
 CREATE INDEX IF NOT EXISTS idx_announcements_timestamp ON announcements(timestamp);
 CREATE INDEX IF NOT EXISTS idx_announcements_prefix_id ON announcements(prefix_id);
-CREATE INDEX IF NOT EXISTS idx_announcements_asn_id ON announcements(asn_id);
+CREATE INDEX IF NOT EXISTS idx_announcements_peer_asn ON announcements(peer_asn);
-CREATE INDEX IF NOT EXISTS idx_asn_peerings_from_asn ON asn_peerings(from_asn_id);
+CREATE INDEX IF NOT EXISTS idx_announcements_origin_asn ON announcements(origin_asn);
-CREATE INDEX IF NOT EXISTS idx_asn_peerings_to_asn ON asn_peerings(to_asn_id);
+CREATE INDEX IF NOT EXISTS idx_peerings_as_a ON peerings(as_a);
-CREATE INDEX IF NOT EXISTS idx_asn_peerings_lookup ON asn_peerings(from_asn_id, to_asn_id);
+CREATE INDEX IF NOT EXISTS idx_peerings_as_b ON peerings(as_b);
-
+CREATE INDEX IF NOT EXISTS idx_peerings_lookup ON peerings(as_a, as_b);
--- Additional indexes for prefixes table
-CREATE INDEX IF NOT EXISTS idx_prefixes_prefix ON prefixes(prefix);
 
 -- Indexes for asns table
-CREATE INDEX IF NOT EXISTS idx_asns_number ON asns(number);
+CREATE INDEX IF NOT EXISTS idx_asns_asn ON asns(asn);
+CREATE INDEX IF NOT EXISTS idx_asns_whois_updated_at ON asns(whois_updated_at);
 
 -- Indexes for bgp_peers table
 CREATE INDEX IF NOT EXISTS idx_bgp_peers_asn ON bgp_peers(peer_asn);
 CREATE INDEX IF NOT EXISTS idx_bgp_peers_last_seen ON bgp_peers(last_seen);
-CREATE INDEX IF NOT EXISTS idx_bgp_peers_ip ON bgp_peers(peer_ip);
+CREATE INDEX IF NOT EXISTS idx_bgp_peers_ip ON bgp_peers(peer_ip);
+
+-- IPv4 routing table maintained by PrefixHandler
+CREATE TABLE IF NOT EXISTS live_routes_v4 (
+	id TEXT PRIMARY KEY,
+	prefix TEXT NOT NULL,
+	mask_length INTEGER NOT NULL, -- CIDR mask length (0-32)
+	origin_asn INTEGER NOT NULL,
+	peer_ip TEXT NOT NULL,
+	as_path TEXT NOT NULL, -- JSON array
+	next_hop TEXT NOT NULL,
+	last_updated DATETIME NOT NULL,
+	-- IPv4 range columns for fast lookups
+	ip_start INTEGER NOT NULL, -- Start of IPv4 range as 32-bit unsigned int
+	ip_end INTEGER NOT NULL,    -- End of IPv4 range as 32-bit unsigned int
+	UNIQUE(prefix, origin_asn, peer_ip)
+);
+
+-- IPv6 routing table maintained by PrefixHandler
+CREATE TABLE IF NOT EXISTS live_routes_v6 (
+	id TEXT PRIMARY KEY,
+	prefix TEXT NOT NULL,
+	mask_length INTEGER NOT NULL, -- CIDR mask length (0-128)
+	origin_asn INTEGER NOT NULL,
+	peer_ip TEXT NOT NULL,
+	as_path TEXT NOT NULL, -- JSON array
+	next_hop TEXT NOT NULL,
+	last_updated DATETIME NOT NULL,
+	-- Note: IPv6 doesn't use integer range columns
+	UNIQUE(prefix, origin_asn, peer_ip)
+);
+
+-- Indexes for live_routes_v4 table
+CREATE INDEX IF NOT EXISTS idx_live_routes_v4_prefix ON live_routes_v4(prefix);
+CREATE INDEX IF NOT EXISTS idx_live_routes_v4_mask_length ON live_routes_v4(mask_length);
+CREATE INDEX IF NOT EXISTS idx_live_routes_v4_origin_asn ON live_routes_v4(origin_asn);
+CREATE INDEX IF NOT EXISTS idx_live_routes_v4_last_updated ON live_routes_v4(last_updated);
+-- Indexes for IPv4 range queries
+CREATE INDEX IF NOT EXISTS idx_live_routes_v4_ip_range ON live_routes_v4(ip_start, ip_end);
+-- Index to optimize prefix distribution queries
+CREATE INDEX IF NOT EXISTS idx_live_routes_v4_mask_prefix ON live_routes_v4(mask_length, prefix);
+
+-- Indexes for live_routes_v6 table
+CREATE INDEX IF NOT EXISTS idx_live_routes_v6_prefix ON live_routes_v6(prefix);
+CREATE INDEX IF NOT EXISTS idx_live_routes_v6_mask_length ON live_routes_v6(mask_length);
+CREATE INDEX IF NOT EXISTS idx_live_routes_v6_origin_asn ON live_routes_v6(origin_asn);
+CREATE INDEX IF NOT EXISTS idx_live_routes_v6_last_updated ON live_routes_v6(last_updated);
+-- Index to optimize prefix distribution queries
+CREATE INDEX IF NOT EXISTS idx_live_routes_v6_mask_prefix ON live_routes_v6(mask_length, prefix);

internal/database/slowquery.go

@@ -3,14 +3,15 @@ package database
 import (
 	"context"
 	"database/sql"
-	"log/slog"
 	"time"
+
+	"git.eeqj.de/sneak/routewatch/internal/logger"
 )
 
-const slowQueryThreshold = 50 * time.Millisecond
+const slowQueryThreshold = 25 * time.Millisecond
 
 // logSlowQuery logs queries that take longer than slowQueryThreshold
-func logSlowQuery(logger *slog.Logger, query string, start time.Time) {
+func logSlowQuery(logger *logger.Logger, query string, start time.Time) {
 	elapsed := time.Since(start)
 	if elapsed > slowQueryThreshold {
 		logger.Debug("Slow query", "query", query, "duration", elapsed)
@@ -18,6 +19,7 @@ func logSlowQuery(logger *slog.Logger, query string, start time.Time) {
 }
 
 // queryRow wraps QueryRow with slow query logging
+// nolint:unused // kept for consistency with other query wrappers
 func (d *Database) queryRow(query string, args ...interface{}) *sql.Row {
 	start := time.Now()
 	defer logSlowQuery(d.logger, query, start)
@@ -47,7 +49,7 @@ func (d *Database) exec(query string, args ...interface{}) error {
 // loggingTx wraps sql.Tx to log slow queries
 type loggingTx struct {
 	*sql.Tx
-	logger *slog.Logger
+	logger *logger.Logger
 }
 
 // QueryRow wraps sql.Tx.QueryRow to log slow queries

internal/database/utils.go

@@ -10,11 +10,6 @@ func generateUUID() uuid.UUID {
 	return uuid.New()
 }
 
-const (
-	ipVersionV4 = 4
-	ipVersionV6 = 6
-)
-
 // detectIPVersion determines if a prefix is IPv4 (returns 4) or IPv6 (returns 6)
 func detectIPVersion(prefix string) int {
 	if strings.Contains(prefix, ":") {

internal/logger/logger.go

@@ -0,0 +1,175 @@
+// Package logger provides a structured logger with source location tracking.
+// It wraps the standard library's log/slog package and automatically enriches
+// log messages with the file name, line number, and function name of the caller.
+// The output format is automatically selected based on the runtime environment:
+// human-readable text for terminals, JSON for non-terminal output.
+package logger
+
+import (
+	"fmt"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"golang.org/x/term"
+)
+
+// Logger wraps slog.Logger to add automatic source location information
+// to all log messages. It embeds slog.Logger and provides the same logging
+// methods (Debug, Info, Warn, Error) but enriches each message with the
+// file name, line number, and function name of the caller.
+type Logger struct {
+	*slog.Logger
+}
+
+// AsSlog returns the underlying slog.Logger for use with APIs that require
+// a standard slog.Logger instance rather than the custom Logger type.
+func (l *Logger) AsSlog() *slog.Logger {
+	return l.Logger
+}
+
+// New creates a new Logger with an appropriate handler based on the runtime
+// environment. If stdout is a terminal, it uses a human-readable text format;
+// otherwise, it outputs JSON for structured log aggregation. The log level
+// defaults to Info, but can be set to Debug by including "routewatch" in the
+// DEBUG environment variable.
+func New() *Logger {
+	level := slog.LevelInfo
+	if debug := os.Getenv("DEBUG"); strings.Contains(debug, "routewatch") {
+		level = slog.LevelDebug
+	}
+
+	opts := &slog.HandlerOptions{
+		Level: level,
+	}
+
+	var handler slog.Handler
+	if term.IsTerminal(int(os.Stdout.Fd())) {
+		// Terminal, use text
+		handler = slog.NewTextHandler(os.Stdout, opts)
+	} else {
+		// Not a terminal, use JSON
+		handler = slog.NewJSONHandler(os.Stdout, opts)
+	}
+
+	return &Logger{Logger: slog.New(handler)}
+}
+
+// sourceSkipLevel defines the number of call stack frames to skip when
+// determining the caller's source location. This accounts for the logger
+// method itself and the getSourceAttrs helper function.
+const sourceSkipLevel = 2
+
+// getSourceAttrs returns attributes for the calling source location
+func getSourceAttrs() []slog.Attr {
+	pc, file, line, ok := runtime.Caller(sourceSkipLevel)
+	if !ok {
+		return nil
+	}
+
+	// Get just the filename without the full path
+	file = filepath.Base(file)
+
+	// Get the function name
+	fn := runtime.FuncForPC(pc)
+	var funcName string
+	if fn != nil {
+		funcName = filepath.Base(fn.Name())
+	}
+
+	attrs := []slog.Attr{
+		slog.String("source", fmt.Sprintf("%s:%d", file, line)),
+	}
+
+	if funcName != "" {
+		attrs = append(attrs, slog.String("func", funcName))
+	}
+
+	return attrs
+}
+
+// Debug logs a message at debug level with automatic source location tracking.
+// Additional structured attributes can be passed as key-value pairs in args.
+// Debug messages are only output when the DEBUG environment variable contains
+// "routewatch".
+func (l *Logger) Debug(msg string, args ...any) {
+	sourceAttrs := getSourceAttrs()
+	allArgs := make([]any, 0, len(args)+len(sourceAttrs)*2)
+
+	// Add source attributes first
+	for _, attr := range sourceAttrs {
+		allArgs = append(allArgs, attr)
+	}
+
+	// Add user args
+	allArgs = append(allArgs, args...)
+
+	l.Logger.Debug(msg, allArgs...)
+}
+
+// Info logs a message at info level with automatic source location tracking.
+// Additional structured attributes can be passed as key-value pairs in args.
+func (l *Logger) Info(msg string, args ...any) {
+	sourceAttrs := getSourceAttrs()
+	allArgs := make([]any, 0, len(args)+len(sourceAttrs)*2)
+
+	// Add source attributes first
+	for _, attr := range sourceAttrs {
+		allArgs = append(allArgs, attr)
+	}
+
+	// Add user args
+	allArgs = append(allArgs, args...)
+
+	l.Logger.Info(msg, allArgs...)
+}
+
+// Warn logs a message at warn level with automatic source location tracking.
+// Additional structured attributes can be passed as key-value pairs in args.
+func (l *Logger) Warn(msg string, args ...any) {
+	sourceAttrs := getSourceAttrs()
+	allArgs := make([]any, 0, len(args)+len(sourceAttrs)*2)
+
+	// Add source attributes first
+	for _, attr := range sourceAttrs {
+		allArgs = append(allArgs, attr)
+	}
+
+	// Add user args
+	allArgs = append(allArgs, args...)
+
+	l.Logger.Warn(msg, allArgs...)
+}
+
+// Error logs a message at error level with automatic source location tracking.
+// Additional structured attributes can be passed as key-value pairs in args.
+func (l *Logger) Error(msg string, args ...any) {
+	sourceAttrs := getSourceAttrs()
+	allArgs := make([]any, 0, len(args)+len(sourceAttrs)*2)
+
+	// Add source attributes first
+	for _, attr := range sourceAttrs {
+		allArgs = append(allArgs, attr)
+	}
+
+	// Add user args
+	allArgs = append(allArgs, args...)
+
+	l.Logger.Error(msg, allArgs...)
+}
+
+// With returns a new Logger with additional structured attributes that will
+// be included in all subsequent log messages. The args parameter accepts
+// key-value pairs in the same format as the logging methods.
+func (l *Logger) With(args ...any) *Logger {
+	return &Logger{Logger: l.Logger.With(args...)}
+}
+
+// WithGroup returns a new Logger that adds the specified group name as a
+// prefix to all attribute keys in subsequent log messages. This is useful
+// for organizing related attributes under a common namespace.
+func (l *Logger) WithGroup(name string) *Logger {
+	return &Logger{Logger: l.Logger.WithGroup(name)}
+}

internal/metrics/metrics.go

@@ -15,12 +15,29 @@ type Tracker struct {
 	registry       metrics.Registry
 	connectedSince time.Time
 	isConnected    atomic.Bool
+	reconnectCount atomic.Uint64
 
-	// Stream metrics
+	// Stream metrics (decompressed data)
 	messageCounter metrics.Counter
 	byteCounter    metrics.Counter
 	messageRate    metrics.Meter
 	byteRate       metrics.Meter
+
+	// Wire bytes metrics (actual bytes on the wire, before decompression)
+	wireByteCounter metrics.Counter
+	wireByteRate    metrics.Meter
+
+	// Route update metrics
+	ipv4UpdateRate metrics.Meter
+	ipv6UpdateRate metrics.Meter
+
+	// Announcement/withdrawal metrics
+	announcementCounter metrics.Counter
+	withdrawalCounter   metrics.Counter
+	churnRate           metrics.Meter // combined announcements + withdrawals per second
+
+	// BGP peer tracking
+	bgpPeerCount atomic.Int32
 }
 
 // New creates a new metrics tracker
@@ -28,30 +45,46 @@ func New() *Tracker {
 	registry := metrics.NewRegistry()
 
 	return &Tracker{
-		registry:       registry,
+		registry:            registry,
-		messageCounter: metrics.NewCounter(),
+		messageCounter:      metrics.NewCounter(),
-		byteCounter:    metrics.NewCounter(),
+		byteCounter:         metrics.NewCounter(),
-		messageRate:    metrics.NewMeter(),
+		messageRate:         metrics.NewMeter(),
-		byteRate:       metrics.NewMeter(),
+		byteRate:            metrics.NewMeter(),
+		wireByteCounter:     metrics.NewCounter(),
+		wireByteRate:        metrics.NewMeter(),
+		ipv4UpdateRate:      metrics.NewMeter(),
+		ipv6UpdateRate:      metrics.NewMeter(),
+		announcementCounter: metrics.NewCounter(),
+		withdrawalCounter:   metrics.NewCounter(),
+		churnRate:           metrics.NewMeter(),
 	}
 }
 
 // SetConnected updates the connection status
 func (t *Tracker) SetConnected(connected bool) {
-	t.isConnected.Store(connected)
+	wasConnected := t.isConnected.Swap(connected)
 	if connected {
 		t.mu.Lock()
 		t.connectedSince = time.Now()
 		t.mu.Unlock()
+		// Increment reconnect count (but not for the initial connection)
+		if wasConnected || t.reconnectCount.Load() > 0 {
+			t.reconnectCount.Add(1)
+		}
 	}
 }
 
+// GetReconnectCount returns the number of reconnections since startup
+func (t *Tracker) GetReconnectCount() uint64 {
+	return t.reconnectCount.Load()
+}
+
 // IsConnected returns the current connection status
 func (t *Tracker) IsConnected() bool {
 	return t.isConnected.Load()
 }
 
-// RecordMessage records a received message and its size
+// RecordMessage records a received message and its decompressed size
 func (t *Tracker) RecordMessage(bytes int64) {
 	t.messageCounter.Inc(1)
 	t.byteCounter.Inc(bytes)
@@ -59,6 +92,12 @@ func (t *Tracker) RecordMessage(bytes int64) {
 	t.byteRate.Mark(bytes)
 }
 
+// RecordWireBytes records actual bytes received on the wire (before decompression)
+func (t *Tracker) RecordWireBytes(bytes int64) {
+	t.wireByteCounter.Inc(bytes)
+	t.wireByteRate.Mark(bytes)
+}
+
 // GetStreamMetrics returns current streaming metrics
 func (t *Tracker) GetStreamMetrics() StreamMetrics {
 	t.mu.RLock()
@@ -70,31 +109,126 @@ func (t *Tracker) GetStreamMetrics() StreamMetrics {
 	// Safely convert counters to uint64
 	msgCount := t.messageCounter.Count()
 	byteCount := t.byteCounter.Count()
+	wireByteCount := t.wireByteCounter.Count()
 
-	var totalMessages, totalBytes uint64
+	var totalMessages, totalBytes, totalWireBytes uint64
 	if msgCount >= 0 {
 		totalMessages = uint64(msgCount)
 	}
 	if byteCount >= 0 {
 		totalBytes = uint64(byteCount)
 	}
+	if wireByteCount >= 0 {
+		totalWireBytes = uint64(wireByteCount)
+	}
 
 	return StreamMetrics{
 		TotalMessages:  totalMessages,
 		TotalBytes:     totalBytes,
+		TotalWireBytes: totalWireBytes,
 		ConnectedSince: connectedSince,
 		Connected:      t.isConnected.Load(),
 		MessagesPerSec: t.messageRate.Rate1(),
 		BitsPerSec:     t.byteRate.Rate1() * bitsPerByte,
+		WireBitsPerSec: t.wireByteRate.Rate1() * bitsPerByte,
+		ReconnectCount: t.reconnectCount.Load(),
+	}
+}
+
+// RecordIPv4Update records an IPv4 route update
+func (t *Tracker) RecordIPv4Update() {
+	t.ipv4UpdateRate.Mark(1)
+}
+
+// RecordIPv6Update records an IPv6 route update
+func (t *Tracker) RecordIPv6Update() {
+	t.ipv6UpdateRate.Mark(1)
+}
+
+// RecordAnnouncement records a route announcement
+func (t *Tracker) RecordAnnouncement() {
+	t.announcementCounter.Inc(1)
+	t.churnRate.Mark(1)
+}
+
+// RecordWithdrawal records a route withdrawal
+func (t *Tracker) RecordWithdrawal() {
+	t.withdrawalCounter.Inc(1)
+	t.churnRate.Mark(1)
+}
+
+// SetBGPPeerCount updates the current BGP peer count
+func (t *Tracker) SetBGPPeerCount(count int) {
+	// BGP peer count is always small (< 1000), so int32 is safe
+	if count > 0 && count < 1<<31 {
+		t.bgpPeerCount.Store(int32(count)) //nolint:gosec // count is validated
+	}
+}
+
+// GetBGPPeerCount returns the current BGP peer count
+func (t *Tracker) GetBGPPeerCount() int {
+	return int(t.bgpPeerCount.Load())
+}
+
+// GetAnnouncementCount returns the total announcement count
+func (t *Tracker) GetAnnouncementCount() uint64 {
+	count := t.announcementCounter.Count()
+	if count < 0 {
+		return 0
+	}
+
+	return uint64(count)
+}
+
+// GetWithdrawalCount returns the total withdrawal count
+func (t *Tracker) GetWithdrawalCount() uint64 {
+	count := t.withdrawalCounter.Count()
+	if count < 0 {
+		return 0
+	}
+
+	return uint64(count)
+}
+
+// GetChurnRate returns the route churn rate per second
+func (t *Tracker) GetChurnRate() float64 {
+	return t.churnRate.Rate1()
+}
+
+// GetRouteMetrics returns current route update metrics
+func (t *Tracker) GetRouteMetrics() RouteMetrics {
+	return RouteMetrics{
+		IPv4UpdatesPerSec: t.ipv4UpdateRate.Rate1(),
+		IPv6UpdatesPerSec: t.ipv6UpdateRate.Rate1(),
 	}
 }
 
 // StreamMetrics contains streaming statistics
 type StreamMetrics struct {
-	TotalMessages  uint64
+	// TotalMessages is the total number of messages received since startup
-	TotalBytes     uint64
+	TotalMessages uint64
+	// TotalBytes is the total number of decompressed bytes received since startup
+	TotalBytes uint64
+	// TotalWireBytes is the total number of bytes received on the wire (before decompression)
+	TotalWireBytes uint64
+	// ConnectedSince is the time when the current connection was established
 	ConnectedSince time.Time
-	Connected      bool
+	// Connected indicates whether the stream is currently connected
+	Connected bool
+	// MessagesPerSec is the rate of messages received per second (1-minute average)
 	MessagesPerSec float64
-	BitsPerSec     float64
+	// BitsPerSec is the rate of decompressed bits received per second (1-minute average)
+	BitsPerSec float64
+	// WireBitsPerSec is the rate of bits received on the wire per second (1-minute average)
+	WireBitsPerSec float64
+	// ReconnectCount is the number of reconnections since startup
+	ReconnectCount uint64
+}
+
+// RouteMetrics contains route update statistics
+type RouteMetrics struct {
+	// IPv4UpdatesPerSec is the rate of IPv4 route updates per second (1-minute average)
+	IPv4UpdatesPerSec float64
+	// IPv6UpdatesPerSec is the rate of IPv6 route updates per second (1-minute average)
+	IPv6UpdatesPerSec float64
 }

internal/ristypes/ris.go

@@ -6,10 +6,14 @@ import (
 	"time"
 )
 
-// ASPath represents an AS path that may contain nested AS sets
+// ASPath represents a BGP AS path as a slice of AS numbers.
+// It handles JSON unmarshaling of both simple arrays and nested AS sets,
+// flattening any nested structures into a single sequence of AS numbers.
 type ASPath []int
 
-// UnmarshalJSON implements custom JSON unmarshaling to flatten nested arrays
+// UnmarshalJSON implements the json.Unmarshaler interface for ASPath.
+// It handles both simple integer arrays [1, 2, 3] and nested AS sets
+// like [1, [2, 3], 4], flattening them into a single slice of integers.
 func (p *ASPath) UnmarshalJSON(data []byte) error {
 	// First try to unmarshal as a simple array of integers
 	var simple []int
@@ -46,13 +50,18 @@ func (p *ASPath) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
-// RISLiveMessage represents the outer wrapper from the RIS Live stream
+// RISLiveMessage represents the outer wrapper message from the RIPE RIS Live stream.
+// Each message contains a Type field indicating the message type and a Data field
+// containing the actual BGP message payload.
 type RISLiveMessage struct {
 	Type string     `json:"type"`
 	Data RISMessage `json:"data"`
 }
 
-// RISMessage represents a message from the RIS Live stream
+// RISMessage represents a BGP update message from the RIPE RIS Live stream.
+// It contains metadata about the BGP session (peer, ASN, host) along with
+// the actual BGP update data including AS path, communities, announcements,
+// and withdrawals.
 type RISMessage struct {
 	Type            string            `json:"type"`
 	Timestamp       float64           `json:"timestamp"`
@@ -74,7 +83,9 @@ type RISMessage struct {
 	Raw             string            `json:"raw,omitempty"`
 }
 
-// RISAnnouncement represents announcement data within a RIS message
+// RISAnnouncement represents a BGP route announcement within a RIS message.
+// It contains the next hop IP address and the list of prefixes being announced
+// via that next hop.
 type RISAnnouncement struct {
 	NextHop  string   `json:"next_hop"`
 	Prefixes []string `json:"prefixes"`

internal/routewatch/app.go

@@ -5,84 +5,57 @@ package routewatch
 import (
 	"context"
 	"fmt"
-	"log/slog"
-	"os"
-	"strings"
 	"sync"
 	"time"
 
+	"git.eeqj.de/sneak/routewatch/internal/config"
 	"git.eeqj.de/sneak/routewatch/internal/database"
+	"git.eeqj.de/sneak/routewatch/internal/logger"
 	"git.eeqj.de/sneak/routewatch/internal/metrics"
-	"git.eeqj.de/sneak/routewatch/internal/routingtable"
 	"git.eeqj.de/sneak/routewatch/internal/server"
-	"git.eeqj.de/sneak/routewatch/internal/snapshotter"
 	"git.eeqj.de/sneak/routewatch/internal/streamer"
 
 	"go.uber.org/fx"
 )
 
-// Config contains runtime configuration for RouteWatch
-type Config struct {
-	MaxRuntime time.Duration // Maximum runtime (0 = run forever)
-}
-
-const (
-	// routingTableStatsInterval is how often we log routing table statistics
-	routingTableStatsInterval = 15 * time.Second
-)
-
-// NewConfig provides default configuration
-func NewConfig() Config {
-	return Config{
-		MaxRuntime: 0, // Run forever by default
-	}
-}
-
 // Dependencies contains all dependencies for RouteWatch
 type Dependencies struct {
 	fx.In
 
-	DB           database.Store
+	DB       database.Store
-	RoutingTable *routingtable.RoutingTable
+	Streamer *streamer.Streamer
-	Streamer     *streamer.Streamer
+	Server   *server.Server
-	Server       *server.Server
+	Logger   *logger.Logger
-	Logger       *slog.Logger
+	Config   *config.Config
-	Config       Config `optional:"true"`
 }
 
 // RouteWatch represents the main application instance
 type RouteWatch struct {
-	db           database.Store
+	db             database.Store
-	routingTable *routingtable.RoutingTable
+	streamer       *streamer.Streamer
-	streamer     *streamer.Streamer
+	server         *server.Server
-	server       *server.Server
+	logger         *logger.Logger
-	snapshotter  *snapshotter.Snapshotter
+	maxRuntime     time.Duration
-	logger       *slog.Logger
+	shutdown       bool
-	maxRuntime   time.Duration
+	mu             sync.Mutex
-	shutdown     bool
+	config         *config.Config
-	mu           sync.Mutex
+	dbHandler      *ASHandler
+	peerHandler    *PeerHandler
+	prefixHandler  *PrefixHandler
+	peeringHandler *PeeringHandler
+	asnFetcher     *ASNFetcher
+	dbMaintainer   *DBMaintainer
 }
 
 // New creates a new RouteWatch instance
 func New(deps Dependencies) *RouteWatch {
 	rw := &RouteWatch{
-		db:           deps.DB,
+		db:         deps.DB,
-		routingTable: deps.RoutingTable,
+		streamer:   deps.Streamer,
-		streamer:     deps.Streamer,
+		server:     deps.Server,
-		server:       deps.Server,
+		logger:     deps.Logger,
-		logger:       deps.Logger,
+		maxRuntime: deps.Config.MaxRuntime,
-		maxRuntime:   deps.Config.MaxRuntime,
+		config:     deps.Config,
-	}
-
-	// Create snapshotter unless disabled (for tests)
-	if os.Getenv("ROUTEWATCH_DISABLE_SNAPSHOTTER") != "1" {
-		snap, err := snapshotter.New(deps.RoutingTable, deps.Logger)
-		if err != nil {
-			deps.Logger.Error("Failed to create snapshotter", "error", err)
-			// Continue without snapshotter
-		} else {
-			rw.snapshotter = snap
-		}
 	}
 
 	return rw
@@ -101,25 +74,33 @@ func (rw *RouteWatch) Run(ctx context.Context) error {
 	}
 
 	// Register database handler to process BGP UPDATE messages
-	dbHandler := NewDatabaseHandler(rw.db, rw.logger)
+	if rw.config.EnableBatchedDatabaseWrites {
-	rw.streamer.RegisterHandler(dbHandler)
+		rw.logger.Info("Using batched database handlers for improved performance")
+		// ASHandler maintains the asns table
+		rw.dbHandler = NewASHandler(rw.db, rw.logger)
+		rw.streamer.RegisterHandler(rw.dbHandler)
 
-	// Register routing table handler to maintain in-memory routing table
+		// PeerHandler maintains the bgp_peers table
-	rtHandler := NewRoutingTableHandler(rw.routingTable, rw.logger)
+		rw.peerHandler = NewPeerHandler(rw.db, rw.logger)
-	rw.streamer.RegisterHandler(rtHandler)
+		rw.streamer.RegisterHandler(rw.peerHandler)
 
-	// Register peer tracking handler to track all peers
+		// PrefixHandler maintains the prefixes and live_routes tables
-	peerHandler := NewPeerHandler(rw.db, rw.logger)
+		rw.prefixHandler = NewPrefixHandler(rw.db, rw.logger)
-	rw.streamer.RegisterHandler(peerHandler)
+		rw.prefixHandler.SetMetricsTracker(rw.streamer.GetMetricsTracker())
+		rw.streamer.RegisterHandler(rw.prefixHandler)
 
-	// Start periodic routing table stats logging
+		// PeeringHandler maintains the asn_peerings table
-	go rw.logRoutingTableStats(ctx)
+		rw.peeringHandler = NewPeeringHandler(rw.db, rw.logger)
+		rw.streamer.RegisterHandler(rw.peeringHandler)
+	} else {
+		// Non-batched handlers not implemented yet
+		rw.logger.Error("Non-batched handlers not implemented")
 
-	// Start snapshotter if available
+		return fmt.Errorf("non-batched handlers not implemented")
-	if rw.snapshotter != nil {
-		rw.snapshotter.Start(ctx)
 	}
 
+	// No longer need routing table handler - PrefixHandler maintains live_routes table
+
 	// Start streaming
 	if err := rw.streamer.Start(); err != nil {
 		return err
@@ -130,6 +111,15 @@ func (rw *RouteWatch) Run(ctx context.Context) error {
 		return err
 	}
 
+	// Start ASN WHOIS fetcher for background updates
+	rw.asnFetcher = NewASNFetcher(rw.db, rw.logger.Logger)
+	rw.asnFetcher.Start()
+	rw.server.SetASNFetcher(rw.asnFetcher)
+
+	// Start database maintenance goroutine
+	rw.dbMaintainer = NewDBMaintainer(rw.db, rw.logger.Logger)
+	rw.dbMaintainer.Start()
+
 	// Wait for context cancellation
 	<-ctx.Done()
 
@@ -147,6 +137,34 @@ func (rw *RouteWatch) Shutdown() {
 	rw.shutdown = true
 	rw.mu.Unlock()
 
+	// Stop batched handlers first to flush remaining batches
+	if rw.dbHandler != nil {
+		rw.logger.Info("Flushing database handler")
+		rw.dbHandler.Stop()
+	}
+	if rw.peerHandler != nil {
+		rw.logger.Info("Flushing peer handler")
+		rw.peerHandler.Stop()
+	}
+	if rw.prefixHandler != nil {
+		rw.logger.Info("Flushing prefix handler")
+		rw.prefixHandler.Stop()
+	}
+	if rw.peeringHandler != nil {
+		rw.logger.Info("Flushing peering handler")
+		rw.peeringHandler.Stop()
+	}
+
+	// Stop ASN WHOIS fetcher
+	if rw.asnFetcher != nil {
+		rw.asnFetcher.Stop()
+	}
+
+	// Stop database maintainer
+	if rw.dbMaintainer != nil {
+		rw.dbMaintainer.Stop()
+	}
+
 	// Stop services
 	rw.streamer.Stop()
 
@@ -168,83 +186,19 @@ func (rw *RouteWatch) Shutdown() {
 		"duration", time.Since(metrics.ConnectedSince),
 	)
 
-	// Take final snapshot before shutdown if snapshotter is available
-	if rw.snapshotter != nil {
-		rw.logger.Info("Taking final snapshot before shutdown")
-		if err := rw.snapshotter.Shutdown(); err != nil {
-			rw.logger.Error("Failed to shutdown snapshotter", "error", err)
-		} else {
-			rw.logger.Info("Final snapshot completed")
-		}
-	} else {
-		rw.logger.Info("No snapshotter available")
-	}
-}
-
-// logRoutingTableStats periodically logs routing table statistics
-func (rw *RouteWatch) logRoutingTableStats(ctx context.Context) {
-	// Log stats periodically
-	ticker := time.NewTicker(routingTableStatsInterval)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case <-ticker.C:
-			stats := rw.routingTable.GetDetailedStats()
-			rw.logger.Info("Routing table statistics",
-				"ipv4_routes", stats.IPv4Routes,
-				"ipv6_routes", stats.IPv6Routes,
-				"ipv4_updates_per_sec", fmt.Sprintf("%.2f", stats.IPv4UpdatesRate),
-				"ipv6_updates_per_sec", fmt.Sprintf("%.2f", stats.IPv6UpdatesRate),
-				"total_routes", stats.TotalRoutes,
-				"unique_prefixes", stats.UniquePrefixes,
-				"unique_origins", stats.UniqueOrigins,
-				"unique_peers", stats.UniquePeers,
-			)
-		}
-	}
-}
-
-// NewLogger creates a structured logger
-func NewLogger() *slog.Logger {
-	level := slog.LevelInfo
-	if debug := os.Getenv("DEBUG"); strings.Contains(debug, "routewatch") {
-		level = slog.LevelDebug
-	}
-
-	opts := &slog.HandlerOptions{
-		Level: level,
-	}
-
-	var handler slog.Handler
-	if os.Stdout.Name() != "/dev/stdout" || os.Getenv("TERM") == "" {
-		// Not a terminal, use JSON
-		handler = slog.NewJSONHandler(os.Stdout, opts)
-	} else {
-		// Terminal, use text
-		handler = slog.NewTextHandler(os.Stdout, opts)
-	}
-
-	return slog.New(handler)
 }
 
 // getModule provides all fx dependencies
 func getModule() fx.Option {
 	return fx.Options(
 		fx.Provide(
-			NewLogger,
+			logger.New,
-			NewConfig,
+			config.New,
 			metrics.New,
-			database.New,
 			fx.Annotate(
-				func(db *database.Database) database.Store {
+				database.New,
-					return db
-				},
 				fx.As(new(database.Store)),
 			),
-			routingtable.New,
 			streamer.New,
 			server.New,
 			New,

internal/routewatch/app_integration_test.go

@@ -2,14 +2,16 @@ package routewatch
 
 import (
 	"context"
+	"fmt"
 	"strings"
 	"sync"
 	"testing"
 	"time"
 
+	"git.eeqj.de/sneak/routewatch/internal/config"
 	"git.eeqj.de/sneak/routewatch/internal/database"
+	"git.eeqj.de/sneak/routewatch/internal/logger"
 	"git.eeqj.de/sneak/routewatch/internal/metrics"
-	"git.eeqj.de/sneak/routewatch/internal/routingtable"
 	"git.eeqj.de/sneak/routewatch/internal/server"
 	"git.eeqj.de/sneak/routewatch/internal/streamer"
 	"github.com/google/uuid"
@@ -59,8 +61,7 @@ func (m *mockStore) GetOrCreateASN(number int, timestamp time.Time) (*database.A
 	}
 
 	asn := &database.ASN{
-		ID:        uuid.New(),
+		ASN:       number,
-		Number:    number,
 		FirstSeen: timestamp,
 		LastSeen:  timestamp,
 	}
@@ -70,6 +71,37 @@ func (m *mockStore) GetOrCreateASN(number int, timestamp time.Time) (*database.A
 	return asn, nil
 }
 
+// UpdatePrefixesBatch mock implementation
+func (m *mockStore) UpdatePrefixesBatch(prefixes map[string]time.Time) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	for prefix, timestamp := range prefixes {
+		if p, exists := m.Prefixes[prefix]; exists {
+			p.LastSeen = timestamp
+		} else {
+			const (
+				ipVersionV4 = 4
+				ipVersionV6 = 6
+			)
+
+			ipVersion := ipVersionV4
+			if strings.Contains(prefix, ":") {
+				ipVersion = ipVersionV6
+			}
+
+			m.Prefixes[prefix] = &database.Prefix{
+				ID:        uuid.New(),
+				Prefix:    prefix,
+				IPVersion: ipVersion,
+				FirstSeen: timestamp,
+				LastSeen:  timestamp,
+			}
+		}
+	}
+	return nil
+}
+
 // GetOrCreatePrefix mock implementation
 func (m *mockStore) GetOrCreatePrefix(prefix string, timestamp time.Time) (*database.Prefix, error) {
 	m.mu.Lock()
@@ -117,11 +149,16 @@ func (m *mockStore) RecordAnnouncement(_ *database.Announcement) error {
 }
 
 // RecordPeering mock implementation
-func (m *mockStore) RecordPeering(fromASNID, toASNID string, _ time.Time) error {
+func (m *mockStore) RecordPeering(asA, asB int, _ time.Time) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
-	key := fromASNID + "_" + toASNID
+	// Normalize
+	if asA > asB {
+		asA, asB = asB, asA
+	}
+
+	key := fmt.Sprintf("%d_%d", asA, asB)
 	if !m.Peerings[key] {
 		m.Peerings[key] = true
 		m.PeeringCount++
@@ -152,18 +189,249 @@ func (m *mockStore) GetStats() (database.Stats, error) {
 		IPv4Prefixes: m.IPv4Prefixes,
 		IPv6Prefixes: m.IPv6Prefixes,
 		Peerings:     m.PeeringCount,
+		Peers:        10, // Mock peer count
 	}, nil
 }
 
+// GetStatsContext returns statistics about the mock store with context support
+func (m *mockStore) GetStatsContext(ctx context.Context) (database.Stats, error) {
+	return m.GetStats()
+}
+
+// UpsertLiveRoute mock implementation
+func (m *mockStore) UpsertLiveRoute(route *database.LiveRoute) error {
+	// Simple mock - just return nil
+	return nil
+}
+
+// DeleteLiveRoute mock implementation
+func (m *mockStore) DeleteLiveRoute(prefix string, originASN int, peerIP string) error {
+	// Simple mock - just return nil
+	return nil
+}
+
+// GetPrefixDistribution mock implementation
+func (m *mockStore) GetPrefixDistribution() (ipv4 []database.PrefixDistribution, ipv6 []database.PrefixDistribution, err error) {
+	// Return empty distributions for now
+	return nil, nil, nil
+}
+
+// GetPrefixDistributionContext mock implementation with context support
+func (m *mockStore) GetPrefixDistributionContext(ctx context.Context) (ipv4 []database.PrefixDistribution, ipv6 []database.PrefixDistribution, err error) {
+	return m.GetPrefixDistribution()
+}
+
+// GetLiveRouteCounts mock implementation
+func (m *mockStore) GetLiveRouteCounts() (ipv4Count, ipv6Count int, err error) {
+	// Return mock counts
+	return m.RouteCount / 2, m.RouteCount / 2, nil
+}
+
+// GetLiveRouteCountsContext mock implementation with context support
+func (m *mockStore) GetLiveRouteCountsContext(ctx context.Context) (ipv4Count, ipv6Count int, err error) {
+	return m.GetLiveRouteCounts()
+}
+
+// GetASInfoForIP mock implementation
+func (m *mockStore) GetASInfoForIP(ip string) (*database.ASInfo, error) {
+	// Simple mock - return a test AS
+	now := time.Now()
+	return &database.ASInfo{
+		ASN:         15169,
+		Handle:      "GOOGLE",
+		Description: "Google LLC",
+		Prefix:      "8.8.8.0/24",
+		LastUpdated: now.Add(-5 * time.Minute),
+		Age:         "5m0s",
+	}, nil
+}
+
+// GetASInfoForIPContext mock implementation with context support
+func (m *mockStore) GetASInfoForIPContext(ctx context.Context, ip string) (*database.ASInfo, error) {
+	return m.GetASInfoForIP(ip)
+}
+
+// GetASDetails mock implementation
+func (m *mockStore) GetASDetails(asn int) (*database.ASN, []database.LiveRoute, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	// Check if ASN exists
+	if asnInfo, exists := m.ASNs[asn]; exists {
+		// Return empty prefixes for now
+		return asnInfo, []database.LiveRoute{}, nil
+	}
+
+	return nil, nil, database.ErrNoRoute
+}
+
+// GetASDetailsContext mock implementation with context support
+func (m *mockStore) GetASDetailsContext(ctx context.Context, asn int) (*database.ASN, []database.LiveRoute, error) {
+	return m.GetASDetails(asn)
+}
+
+// GetPrefixDetails mock implementation
+func (m *mockStore) GetPrefixDetails(prefix string) ([]database.LiveRoute, error) {
+	// Return empty routes for now
+	return []database.LiveRoute{}, nil
+}
+
+// GetPrefixDetailsContext mock implementation with context support
+func (m *mockStore) GetPrefixDetailsContext(ctx context.Context, prefix string) ([]database.LiveRoute, error) {
+	return m.GetPrefixDetails(prefix)
+}
+
+func (m *mockStore) GetRandomPrefixesByLength(maskLength, ipVersion, limit int) ([]database.LiveRoute, error) {
+	// Return empty routes for now
+	return []database.LiveRoute{}, nil
+}
+
+// GetRandomPrefixesByLengthContext mock implementation with context support
+func (m *mockStore) GetRandomPrefixesByLengthContext(ctx context.Context, maskLength, ipVersion, limit int) ([]database.LiveRoute, error) {
+	return m.GetRandomPrefixesByLength(maskLength, ipVersion, limit)
+}
+
+// GetASPeers mock implementation
+func (m *mockStore) GetASPeers(asn int) ([]database.ASPeer, error) {
+	// Return empty peers for now
+	return []database.ASPeer{}, nil
+}
+
+// GetASPeersContext mock implementation with context support
+func (m *mockStore) GetASPeersContext(ctx context.Context, asn int) ([]database.ASPeer, error) {
+	return m.GetASPeers(asn)
+}
+
+// GetIPInfo mock implementation
+func (m *mockStore) GetIPInfo(ip string) (*database.IPInfo, error) {
+	return m.GetIPInfoContext(context.Background(), ip)
+}
+
+// GetIPInfoContext mock implementation with context support
+func (m *mockStore) GetIPInfoContext(ctx context.Context, ip string) (*database.IPInfo, error) {
+	now := time.Now()
+	return &database.IPInfo{
+		IP:          ip,
+		Netblock:    "8.8.8.0/24",
+		MaskLength:  24,
+		IPVersion:   4,
+		NumPeers:    3,
+		ASN:         15169,
+		Handle:      "GOOGLE",
+		Description: "Google LLC",
+		CountryCode: "US",
+		FirstSeen:   now.Add(-24 * time.Hour),
+		LastSeen:    now,
+	}, nil
+}
+
+// GetNextStaleASN mock implementation
+func (m *mockStore) GetNextStaleASN(ctx context.Context, staleThreshold time.Duration) (int, error) {
+	return 0, database.ErrNoStaleASN
+}
+
+// UpdateASNWHOIS mock implementation
+func (m *mockStore) UpdateASNWHOIS(ctx context.Context, update *database.ASNWHOISUpdate) error {
+	return nil
+}
+
+// GetWHOISStats mock implementation
+func (m *mockStore) GetWHOISStats(ctx context.Context, staleThreshold time.Duration) (*database.WHOISStats, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	return &database.WHOISStats{
+		TotalASNs:    len(m.ASNs),
+		FreshASNs:    0,
+		StaleASNs:    0,
+		NeverFetched: len(m.ASNs),
+	}, nil
+}
+
+// UpsertLiveRouteBatch mock implementation
+func (m *mockStore) UpsertLiveRouteBatch(routes []*database.LiveRoute) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	for _, route := range routes {
+		// Track prefix
+		if _, exists := m.Prefixes[route.Prefix]; !exists {
+			m.Prefixes[route.Prefix] = &database.Prefix{
+				ID:        uuid.New(),
+				Prefix:    route.Prefix,
+				IPVersion: route.IPVersion,
+				FirstSeen: route.LastUpdated,
+				LastSeen:  route.LastUpdated,
+			}
+			m.PrefixCount++
+			if route.IPVersion == 4 {
+				m.IPv4Prefixes++
+			} else {
+				m.IPv6Prefixes++
+			}
+		}
+		m.RouteCount++
+	}
+	return nil
+}
+
+// DeleteLiveRouteBatch mock implementation
+func (m *mockStore) DeleteLiveRouteBatch(deletions []database.LiveRouteDeletion) error {
+	// Simple mock - just return nil
+	return nil
+}
+
+// GetOrCreateASNBatch mock implementation
+func (m *mockStore) GetOrCreateASNBatch(asns map[int]time.Time) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	for number, timestamp := range asns {
+		if _, exists := m.ASNs[number]; !exists {
+			m.ASNs[number] = &database.ASN{
+				ASN:       number,
+				FirstSeen: timestamp,
+				LastSeen:  timestamp,
+			}
+			m.ASNCount++
+		}
+	}
+	return nil
+}
+
+// UpdatePeerBatch mock implementation
+func (m *mockStore) UpdatePeerBatch(peers map[string]database.PeerUpdate) error {
+	// Simple mock - just return nil
+	return nil
+}
+
+// Vacuum mock implementation
+func (m *mockStore) Vacuum(ctx context.Context) error {
+	return nil
+}
+
+// Analyze mock implementation
+func (m *mockStore) Analyze(ctx context.Context) error {
+	return nil
+}
+
+// Checkpoint mock implementation
+func (m *mockStore) Checkpoint(ctx context.Context) error {
+	return nil
+}
+
+// Ping mock implementation
+func (m *mockStore) Ping(ctx context.Context) error {
+	return nil
+}
+
 func TestRouteWatchLiveFeed(t *testing.T) {
-	// Disable snapshotter for tests
-	t.Setenv("ROUTEWATCH_DISABLE_SNAPSHOTTER", "1")
 
 	// Create mock database
 	mockDB := newMockStore()
 	defer mockDB.Close()
 
-	logger := NewLogger()
+	logger := logger.New()
 
 	// Create metrics tracker
 	metricsTracker := metrics.New()
@@ -171,22 +439,23 @@ func TestRouteWatchLiveFeed(t *testing.T) {
 	// Create streamer
 	s := streamer.New(logger, metricsTracker)
 
-	// Create routing table
+	// Create test config with empty state dir (no snapshot loading)
-	rt := routingtable.New(logger)
+	cfg := &config.Config{
+		StateDir:                    "",
+		MaxRuntime:                  5 * time.Second,
+		EnableBatchedDatabaseWrites: true,
+	}
 
 	// Create server
-	srv := server.New(mockDB, rt, s, logger)
+	srv := server.New(mockDB, s, logger)
 
 	// Create RouteWatch with 5 second limit
 	deps := Dependencies{
-		DB:           mockDB,
+		DB:       mockDB,
-		RoutingTable: rt,
+		Streamer: s,
-		Streamer:     s,
+		Server:   srv,
-		Server:       srv,
+		Logger:   logger,
-		Logger:       logger,
+		Config:   cfg,
-		Config: Config{
-			MaxRuntime: 5 * time.Second,
-		},
 	}
 	rw := New(deps)
 
@@ -199,6 +468,11 @@ func TestRouteWatchLiveFeed(t *testing.T) {
 	// Wait for the configured duration
 	time.Sleep(5 * time.Second)
 
+	// Force peering processing for test
+	if rw.peeringHandler != nil {
+		rw.peeringHandler.ProcessPeeringsNow()
+	}
+
 	// Get statistics
 	stats, err := mockDB.GetStats()
 	if err != nil {

internal/routewatch/app_test.go

@@ -1,12 +1,3 @@
 package routewatch
 
-import (
+// Tests for routewatch package are in app_integration_test.go
-	"testing"
-)
-
-func TestNewLogger(t *testing.T) {
-	logger := NewLogger()
-	if logger == nil {
-		t.Fatal("NewLogger returned nil")
-	}
-}

internal/routewatch/ashandler.go

@@ -0,0 +1,182 @@
+package routewatch
+
+import (
+	"sync"
+	"time"
+
+	"git.eeqj.de/sneak/routewatch/internal/database"
+	"git.eeqj.de/sneak/routewatch/internal/logger"
+	"git.eeqj.de/sneak/routewatch/internal/ristypes"
+)
+
+const (
+	// asHandlerQueueSize is the queue capacity for ASN operations
+	// DO NOT set this higher than 100000 without explicit instructions
+	asHandlerQueueSize = 100000
+
+	// asnBatchSize is the number of ASN operations to batch together
+	asnBatchSize = 30000
+
+	// asnBatchTimeout is the maximum time to wait before flushing a batch
+	// DO NOT reduce this timeout - larger batches are more efficient
+	asnBatchTimeout = 2 * time.Second
+)
+
+// ASHandler processes Autonomous System Number (ASN) information extracted from
+// BGP UPDATE messages. It uses batched database operations to efficiently store
+// ASN data, collecting operations into batches that are flushed either when the
+// batch reaches a size threshold or after a timeout period.
+type ASHandler struct {
+	db     database.Store
+	logger *logger.Logger
+
+	// Batching
+	mu        sync.Mutex
+	batch     []asnOp
+	lastFlush time.Time
+	stopCh    chan struct{}
+	wg        sync.WaitGroup
+}
+
+type asnOp struct {
+	number    int
+	timestamp time.Time
+}
+
+// NewASHandler creates and returns a new ASHandler instance. It initializes
+// the batching system and starts a background goroutine that periodically
+// flushes accumulated ASN operations to the database. The caller must call
+// Stop when finished to ensure all pending operations are flushed and the
+// background goroutine is terminated.
+func NewASHandler(db database.Store, logger *logger.Logger) *ASHandler {
+	h := &ASHandler{
+		db:        db,
+		logger:    logger,
+		batch:     make([]asnOp, 0, asnBatchSize),
+		lastFlush: time.Now(),
+		stopCh:    make(chan struct{}),
+	}
+
+	// Start the flush timer goroutine
+	h.wg.Add(1)
+	go h.flushLoop()
+
+	return h
+}
+
+// WantsMessage reports whether this handler should process messages of the
+// given type. ASHandler only processes "UPDATE" messages, as these contain
+// the AS path information needed to track autonomous systems.
+func (h *ASHandler) WantsMessage(messageType string) bool {
+	// We only care about UPDATE messages for the database
+	return messageType == "UPDATE"
+}
+
+// QueueCapacity returns the recommended message queue size for this handler.
+// ASHandler uses a large queue capacity to accommodate high-volume BGP streams,
+// as the batching mechanism allows efficient processing of accumulated messages.
+func (h *ASHandler) QueueCapacity() int {
+	// Batching allows us to use a larger queue
+	return asHandlerQueueSize
+}
+
+// HandleMessage processes a RIS Live BGP message by extracting all ASNs from
+// the AS path and queuing them for batch insertion into the database. The
+// origin ASN (last element in the path) and all transit ASNs are recorded
+// with their associated timestamps. The batch is automatically flushed when
+// it reaches the configured size threshold.
+func (h *ASHandler) HandleMessage(msg *ristypes.RISMessage) {
+	// Use the pre-parsed timestamp
+	timestamp := msg.ParsedTimestamp
+
+	// Get origin ASN from path (last element)
+	var originASN int
+	if len(msg.Path) > 0 {
+		originASN = msg.Path[len(msg.Path)-1]
+	}
+
+	h.mu.Lock()
+	defer h.mu.Unlock()
+
+	// Queue origin ASN operation
+	if originASN > 0 {
+		h.batch = append(h.batch, asnOp{
+			number:    originASN,
+			timestamp: timestamp,
+		})
+	}
+
+	// Also track all ASNs in the path
+	for _, asn := range msg.Path {
+		if asn > 0 {
+			h.batch = append(h.batch, asnOp{
+				number:    asn,
+				timestamp: timestamp,
+			})
+		}
+	}
+
+	// Check if we need to flush
+	if len(h.batch) >= asnBatchSize {
+		h.flushBatchLocked()
+	}
+}
+
+// flushLoop runs in a goroutine and periodically flushes batches
+func (h *ASHandler) flushLoop() {
+	defer h.wg.Done()
+	ticker := time.NewTicker(asnBatchTimeout)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			h.mu.Lock()
+			if time.Since(h.lastFlush) >= asnBatchTimeout {
+				h.flushBatchLocked()
+			}
+			h.mu.Unlock()
+		case <-h.stopCh:
+			// Final flush
+			h.mu.Lock()
+			h.flushBatchLocked()
+			h.mu.Unlock()
+
+			return
+		}
+	}
+}
+
+// flushBatchLocked flushes the ASN batch to the database (must be called with mutex held)
+func (h *ASHandler) flushBatchLocked() {
+	if len(h.batch) == 0 {
+		return
+	}
+
+	// Process ASNs first (deduped)
+	asnMap := make(map[int]time.Time)
+	for _, op := range h.batch {
+		if existing, ok := asnMap[op.number]; !ok || op.timestamp.After(existing) {
+			asnMap[op.number] = op.timestamp
+		}
+	}
+
+	// Process all ASNs in a single batch transaction
+	if err := h.db.GetOrCreateASNBatch(asnMap); err != nil {
+		h.logger.Error("Failed to process ASN batch", "error", err, "count", len(asnMap))
+	}
+
+	// Clear batch
+	h.batch = h.batch[:0]
+	h.lastFlush = time.Now()
+}
+
+// Stop gracefully shuts down the ASHandler by signaling the background flush
+// goroutine to terminate and waiting for it to complete. Any pending ASN
+// operations in the current batch are flushed to the database before Stop
+// returns. This method should be called during application shutdown to ensure
+// no data is lost.
+func (h *ASHandler) Stop() {
+	close(h.stopCh)
+	h.wg.Wait()
+}

internal/routewatch/asnfetcher.go

@@ -0,0 +1,325 @@
+// Package routewatch contains the ASN WHOIS fetcher for background updates.
+package routewatch
+
+import (
+	"context"
+	"log/slog"
+	"sync"
+	"time"
+
+	"git.eeqj.de/sneak/routewatch/internal/database"
+	"git.eeqj.de/sneak/routewatch/internal/server"
+	"git.eeqj.de/sneak/routewatch/internal/whois"
+)
+
+// ASN fetcher configuration constants.
+const (
+	// baseInterval is the starting interval between fetch attempts.
+	baseInterval = 15 * time.Second
+
+	// minInterval is the minimum interval after successes (rate limit).
+	minInterval = 1 * time.Second
+
+	// maxInterval is the maximum interval after failures (backoff cap).
+	maxInterval = 5 * time.Minute
+
+	// backoffMultiplier is how much to multiply interval on failure.
+	backoffMultiplier = 2
+
+	// whoisStaleThreshold is how old WHOIS data can be before refresh.
+	whoisStaleThreshold = 30 * 24 * time.Hour // 30 days
+
+	// immediateQueueSize is the buffer size for immediate fetch requests.
+	immediateQueueSize = 100
+
+	// statsWindow is how long to keep stats for.
+	statsWindow = time.Hour
+)
+
+
+// ASNFetcher handles background WHOIS lookups for ASNs.
+type ASNFetcher struct {
+	db             database.Store
+	whoisClient    *whois.Client
+	logger         *slog.Logger
+	immediateQueue chan int
+	stopCh         chan struct{}
+	wg             sync.WaitGroup
+
+	// fetchMu ensures only one fetch runs at a time
+	fetchMu sync.Mutex
+
+	// interval tracking with mutex protection
+	intervalMu       sync.Mutex
+	currentInterval  time.Duration
+	consecutiveFails int
+
+	// hourly stats tracking
+	statsMu        sync.Mutex
+	successTimes   []time.Time
+	errorTimes     []time.Time
+}
+
+// NewASNFetcher creates a new ASN fetcher.
+func NewASNFetcher(db database.Store, logger *slog.Logger) *ASNFetcher {
+	return &ASNFetcher{
+		db:              db,
+		whoisClient:     whois.NewClient(),
+		logger:          logger.With("component", "asn_fetcher"),
+		immediateQueue:  make(chan int, immediateQueueSize),
+		stopCh:          make(chan struct{}),
+		currentInterval: baseInterval,
+		successTimes:    make([]time.Time, 0),
+		errorTimes:      make([]time.Time, 0),
+	}
+}
+
+// Start begins the background ASN fetcher goroutine.
+func (f *ASNFetcher) Start() {
+	f.wg.Add(1)
+	go f.run()
+	f.logger.Info("ASN fetcher started",
+		"base_interval", baseInterval,
+		"min_interval", minInterval,
+		"max_interval", maxInterval,
+	)
+}
+
+// Stop gracefully shuts down the fetcher.
+func (f *ASNFetcher) Stop() {
+	close(f.stopCh)
+	f.wg.Wait()
+	f.logger.Info("ASN fetcher stopped")
+}
+
+// QueueImmediate queues an ASN for immediate WHOIS lookup.
+// Non-blocking - if queue is full, the request is dropped.
+func (f *ASNFetcher) QueueImmediate(asn int) {
+	select {
+	case f.immediateQueue <- asn:
+		f.logger.Debug("Queued immediate WHOIS lookup", "asn", asn)
+	default:
+		f.logger.Debug("Immediate queue full, dropping request", "asn", asn)
+	}
+}
+
+// GetStats returns statistics about fetcher activity.
+func (f *ASNFetcher) GetStats() server.ASNFetcherStats {
+	f.statsMu.Lock()
+	defer f.statsMu.Unlock()
+
+	f.intervalMu.Lock()
+	interval := f.currentInterval
+	fails := f.consecutiveFails
+	f.intervalMu.Unlock()
+
+	// Prune old entries and count
+	cutoff := time.Now().Add(-statsWindow)
+	f.successTimes = pruneOldTimes(f.successTimes, cutoff)
+	f.errorTimes = pruneOldTimes(f.errorTimes, cutoff)
+
+	return server.ASNFetcherStats{
+		SuccessesLastHour: len(f.successTimes),
+		ErrorsLastHour:    len(f.errorTimes),
+		CurrentInterval:   interval,
+		ConsecutiveFails:  fails,
+	}
+}
+
+// pruneOldTimes removes times older than cutoff and returns the pruned slice.
+func pruneOldTimes(times []time.Time, cutoff time.Time) []time.Time {
+	result := make([]time.Time, 0, len(times))
+	for _, t := range times {
+		if t.After(cutoff) {
+			result = append(result, t)
+		}
+	}
+
+	return result
+}
+
+// getInterval returns the current fetch interval.
+func (f *ASNFetcher) getInterval() time.Duration {
+	f.intervalMu.Lock()
+	defer f.intervalMu.Unlock()
+
+	return f.currentInterval
+}
+
+// recordSuccess decreases the interval on successful fetch.
+func (f *ASNFetcher) recordSuccess() {
+	f.intervalMu.Lock()
+	f.consecutiveFails = 0
+
+	// Decrease interval by half, but not below minimum
+	newInterval := f.currentInterval / backoffMultiplier
+	if newInterval < minInterval {
+		newInterval = minInterval
+	}
+
+	if newInterval != f.currentInterval {
+		f.logger.Debug("Decreased fetch interval",
+			"old_interval", f.currentInterval,
+			"new_interval", newInterval,
+		)
+		f.currentInterval = newInterval
+	}
+	f.intervalMu.Unlock()
+
+	// Record success time for stats
+	f.statsMu.Lock()
+	f.successTimes = append(f.successTimes, time.Now())
+	f.statsMu.Unlock()
+}
+
+// recordFailure increases the interval on failed fetch using exponential backoff.
+func (f *ASNFetcher) recordFailure() {
+	f.intervalMu.Lock()
+	f.consecutiveFails++
+
+	// Exponential backoff: multiply by 2, capped at max
+	newInterval := f.currentInterval * backoffMultiplier
+	if newInterval > maxInterval {
+		newInterval = maxInterval
+	}
+
+	if newInterval != f.currentInterval {
+		f.logger.Debug("Increased fetch interval due to failure",
+			"old_interval", f.currentInterval,
+			"new_interval", newInterval,
+			"consecutive_failures", f.consecutiveFails,
+		)
+		f.currentInterval = newInterval
+	}
+	f.intervalMu.Unlock()
+
+	// Record error time for stats
+	f.statsMu.Lock()
+	f.errorTimes = append(f.errorTimes, time.Now())
+	f.statsMu.Unlock()
+}
+
+// run is the main background loop.
+func (f *ASNFetcher) run() {
+	defer f.wg.Done()
+
+	timer := time.NewTimer(f.getInterval())
+	defer timer.Stop()
+
+	for {
+		select {
+		case <-f.stopCh:
+			return
+
+		case asn := <-f.immediateQueue:
+			// Process immediate request (respects lock)
+			f.tryFetch(asn)
+			// Reset timer after immediate fetch
+			timer.Reset(f.getInterval())
+
+		case <-timer.C:
+			// Background fetch of stale/missing ASN
+			f.fetchNextStale()
+			// Reset timer with potentially updated interval
+			timer.Reset(f.getInterval())
+		}
+	}
+}
+
+// tryFetch attempts to fetch and update an ASN, respecting the fetch lock.
+// Returns true if fetch was successful.
+func (f *ASNFetcher) tryFetch(asn int) bool {
+	// Try to acquire lock, skip if another fetch is running
+	if !f.fetchMu.TryLock() {
+		f.logger.Debug("Skipping fetch, another fetch in progress", "asn", asn)
+
+		return false
+	}
+	defer f.fetchMu.Unlock()
+
+	return f.fetchAndUpdate(asn)
+}
+
+// fetchNextStale finds and fetches the next ASN needing WHOIS data.
+func (f *ASNFetcher) fetchNextStale() {
+	// Try to acquire lock, skip if another fetch is running
+	if !f.fetchMu.TryLock() {
+		f.logger.Debug("Skipping stale fetch, another fetch in progress")
+
+		return
+	}
+	defer f.fetchMu.Unlock()
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+
+	asn, err := f.db.GetNextStaleASN(ctx, whoisStaleThreshold)
+	if err != nil {
+		if err != database.ErrNoStaleASN {
+			f.logger.Error("Failed to get stale ASN", "error", err)
+			f.recordFailure()
+		}
+		// No stale ASN is not a failure, just nothing to do
+
+		return
+	}
+
+	f.fetchAndUpdate(asn)
+}
+
+// fetchAndUpdate performs a WHOIS lookup and updates the database.
+// Returns true if successful.
+func (f *ASNFetcher) fetchAndUpdate(asn int) bool {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+
+	f.logger.Info("Fetching WHOIS data", "asn", asn)
+
+	info, err := f.whoisClient.LookupASN(ctx, asn)
+	if err != nil {
+		f.logger.Error("WHOIS lookup failed", "asn", asn, "error", err)
+		f.recordFailure()
+
+		return false
+	}
+
+	// Update database with WHOIS data
+	err = f.db.UpdateASNWHOIS(ctx, &database.ASNWHOISUpdate{
+		ASN:         asn,
+		ASName:      info.ASName,
+		OrgName:     info.OrgName,
+		OrgID:       info.OrgID,
+		Address:     info.Address,
+		CountryCode: info.CountryCode,
+		AbuseEmail:  info.AbuseEmail,
+		AbusePhone:  info.AbusePhone,
+		TechEmail:   info.TechEmail,
+		TechPhone:   info.TechPhone,
+		RIR:         info.RIR,
+		RIRRegDate:  info.RegDate,
+		RIRLastMod:  info.LastMod,
+		WHOISRaw:    info.RawResponse,
+	})
+	if err != nil {
+		f.logger.Error("Failed to update ASN WHOIS data", "asn", asn, "error", err)
+		f.recordFailure()
+
+		return false
+	}
+
+	f.recordSuccess()
+	f.logger.Info("Updated ASN WHOIS data",
+		"asn", asn,
+		"org_name", info.OrgName,
+		"country", info.CountryCode,
+		"rir", info.RIR,
+		"next_interval", f.getInterval(),
+	)
+
+	return true
+}
+
+// GetStaleThreshold returns the WHOIS stale threshold duration.
+func GetStaleThreshold() time.Duration {
+	return whoisStaleThreshold
+}

internal/routewatch/cli.go

@@ -2,42 +2,85 @@ package routewatch
 
 import (
 	"context"
-	"log/slog"
 	"os"
 	"os/signal"
+	"runtime"
+	"strings"
 	"syscall"
 	"time"
 
+	"git.eeqj.de/sneak/routewatch/internal/logger"
 	"go.uber.org/fx"
 )
 
 const (
 	// shutdownTimeout is the maximum time allowed for graceful shutdown
 	shutdownTimeout = 60 * time.Second
+	// debugInterval is how often to log debug stats
+	debugInterval = 60 * time.Second
+	// bytesPerMB is bytes per megabyte
+	bytesPerMB = 1024 * 1024
 )
 
-// CLIEntry is the main entry point for the CLI
+// logDebugStats logs goroutine count and memory usage
+func logDebugStats(logger *logger.Logger) {
+	// Only run if DEBUG env var contains "routewatch"
+	debugEnv := os.Getenv("DEBUG")
+	if !strings.Contains(debugEnv, "routewatch") {
+		return
+	}
+
+	ticker := time.NewTicker(debugInterval)
+	defer ticker.Stop()
+
+	for range ticker.C {
+		var m runtime.MemStats
+		runtime.ReadMemStats(&m)
+
+		logger.Debug("System stats",
+			"goroutines", runtime.NumGoroutine(),
+			"alloc_mb", m.Alloc/bytesPerMB,
+			"total_alloc_mb", m.TotalAlloc/bytesPerMB,
+			"sys_mb", m.Sys/bytesPerMB,
+			"num_gc", m.NumGC,
+			"heap_alloc_mb", m.HeapAlloc/bytesPerMB,
+			"heap_sys_mb", m.HeapSys/bytesPerMB,
+			"heap_idle_mb", m.HeapIdle/bytesPerMB,
+			"heap_inuse_mb", m.HeapInuse/bytesPerMB,
+			"heap_released_mb", m.HeapReleased/bytesPerMB,
+			"stack_inuse_mb", m.StackInuse/bytesPerMB,
+		)
+	}
+}
+
+// CLIEntry is the main entry point for the routewatch command-line interface.
+// It initializes the application using the fx dependency injection framework,
+// sets up signal handling for graceful shutdown, and starts the RouteWatch service.
+// This function blocks until the application receives a shutdown signal or encounters
+// a fatal error.
 func CLIEntry() {
 	app := fx.New(
 		getModule(),
 		fx.StopTimeout(shutdownTimeout), // Allow 60 seconds for graceful shutdown
-		fx.Invoke(func(lc fx.Lifecycle, rw *RouteWatch, logger *slog.Logger) {
+		fx.Invoke(func(lc fx.Lifecycle, rw *RouteWatch, logger *logger.Logger, shutdowner fx.Shutdowner) {
 			lc.Append(fx.Hook{
-				OnStart: func(_ context.Context) error {
+				OnStart: func(ctx context.Context) error {
+					// Start debug stats logging
+					go logDebugStats(logger)
+
+					// Handle shutdown signals
+					sigCh := make(chan os.Signal, 1)
+					signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
+
 					go func() {
-						ctx, cancel := context.WithCancel(context.Background())
+						<-sigCh
-						defer cancel()
+						logger.Info("Received shutdown signal")
-
+						if err := shutdowner.Shutdown(); err != nil {
-						// Handle shutdown signals
+							logger.Error("Failed to shutdown gracefully", "error", err)
-						sigCh := make(chan os.Signal, 1)
+						}
-						signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
+					}()
-
-						go func() {
-							<-sigCh
-							logger.Info("Received shutdown signal")
-							cancel()
-						}()
 
+					go func() {
 						if err := rw.Run(ctx); err != nil {
 							logger.Error("RouteWatch error", "error", err)
 						}

internal/routewatch/dbhandler.go

@@ -1,156 +0,0 @@
-package routewatch
-
-import (
-	"log/slog"
-
-	"git.eeqj.de/sneak/routewatch/internal/database"
-	"git.eeqj.de/sneak/routewatch/internal/ristypes"
-)
-
-const (
-	// databaseHandlerQueueSize is the queue capacity for database operations
-	databaseHandlerQueueSize = 200
-)
-
-// DatabaseHandler handles BGP messages and stores them in the database
-type DatabaseHandler struct {
-	db     database.Store
-	logger *slog.Logger
-}
-
-// NewDatabaseHandler creates a new database handler
-func NewDatabaseHandler(
-	db database.Store,
-	logger *slog.Logger,
-) *DatabaseHandler {
-	return &DatabaseHandler{
-		db:     db,
-		logger: logger,
-	}
-}
-
-// WantsMessage returns true if this handler wants to process messages of the given type
-func (h *DatabaseHandler) WantsMessage(messageType string) bool {
-	// We only care about UPDATE messages for the database
-	return messageType == "UPDATE"
-}
-
-// QueueCapacity returns the desired queue capacity for this handler
-func (h *DatabaseHandler) QueueCapacity() int {
-	// Database operations are slow, so use a smaller queue
-	return databaseHandlerQueueSize
-}
-
-// HandleMessage processes a RIS message and updates the database
-func (h *DatabaseHandler) HandleMessage(msg *ristypes.RISMessage) {
-	// Use the pre-parsed timestamp
-	timestamp := msg.ParsedTimestamp
-
-	// Get origin ASN from path (last element)
-	var originASN int
-	if len(msg.Path) > 0 {
-		originASN = msg.Path[len(msg.Path)-1]
-	}
-
-	// Process announcements
-	for _, announcement := range msg.Announcements {
-		for _, prefix := range announcement.Prefixes {
-			// Get or create prefix
-			_, err := h.db.GetOrCreatePrefix(prefix, timestamp)
-			if err != nil {
-				h.logger.Error(
-					"Failed to get/create prefix",
-					"prefix",
-					prefix,
-					"error",
-					err,
-				)
-
-				continue
-			}
-
-			// Get or create origin ASN
-			_, err = h.db.GetOrCreateASN(originASN, timestamp)
-			if err != nil {
-				h.logger.Error(
-					"Failed to get/create ASN",
-					"asn",
-					originASN,
-					"error",
-					err,
-				)
-
-				continue
-			}
-
-			// TODO: Record the announcement in the announcements table
-			// Process AS path to update peerings
-			if len(msg.Path) > 1 {
-				for i := range len(msg.Path) - 1 {
-					fromASN := msg.Path[i]
-					toASN := msg.Path[i+1]
-
-					// Get or create both ASNs
-					fromAS, err := h.db.GetOrCreateASN(fromASN, timestamp)
-					if err != nil {
-						h.logger.Error(
-							"Failed to get/create from ASN",
-							"asn",
-							fromASN,
-							"error",
-							err,
-						)
-
-						continue
-					}
-
-					toAS, err := h.db.GetOrCreateASN(toASN, timestamp)
-					if err != nil {
-						h.logger.Error(
-							"Failed to get/create to ASN",
-							"asn",
-							toASN,
-							"error",
-							err,
-						)
-
-						continue
-					}
-
-					// Record the peering
-					err = h.db.RecordPeering(
-						fromAS.ID.String(),
-						toAS.ID.String(),
-						timestamp,
-					)
-					if err != nil {
-						h.logger.Error("Failed to record peering",
-							"from_asn", fromASN,
-							"to_asn", toASN,
-							"error", err,
-						)
-					}
-				}
-			}
-		}
-	}
-
-	// Process withdrawals
-	for _, prefix := range msg.Withdrawals {
-		// Get prefix
-		_, err := h.db.GetOrCreatePrefix(prefix, timestamp)
-		if err != nil {
-			h.logger.Error(
-				"Failed to get prefix for withdrawal",
-				"prefix",
-				prefix,
-				"error",
-				err,
-			)
-
-			continue
-		}
-
-		// TODO: Record the withdrawal in the announcements table as a withdrawal
-	}
-}

internal/routewatch/dbmaintainer.go

@@ -0,0 +1,189 @@
+// Package routewatch contains the database maintainer for background maintenance tasks.
+package routewatch
+
+import (
+	"context"
+	"log/slog"
+	"sync"
+	"time"
+
+	"git.eeqj.de/sneak/routewatch/internal/database"
+)
+
+// Database maintenance configuration constants.
+const (
+	// checkpointInterval is how often to run WAL checkpoint.
+	// Frequent checkpoints keep the WAL small, improving read performance.
+	// Under heavy write load, we need aggressive checkpointing.
+	checkpointInterval = 5 * time.Second
+
+	// vacuumInterval is how often to run incremental vacuum.
+	// Since incremental vacuum only frees ~1000 pages (~4MB) per run,
+	// we run it frequently to keep up with deletions.
+	vacuumInterval = 10 * time.Minute
+
+	// analyzeInterval is how often to run ANALYZE.
+	analyzeInterval = 1 * time.Hour
+
+	// checkpointTimeout is the max time for WAL checkpoint.
+	checkpointTimeout = 10 * time.Second
+
+	// vacuumTimeout is the max time for incremental vacuum (should be quick).
+	vacuumTimeout = 30 * time.Second
+
+	// analyzeTimeout is the max time for ANALYZE.
+	analyzeTimeout = 5 * time.Minute
+)
+
+// DBMaintainer handles background database maintenance tasks.
+type DBMaintainer struct {
+	db     database.Store
+	logger *slog.Logger
+	stopCh chan struct{}
+	wg     sync.WaitGroup
+
+	// Stats tracking
+	statsMu             sync.Mutex
+	lastCheckpoint      time.Time
+	lastVacuum          time.Time
+	lastAnalyze         time.Time
+	checkpointCount     int
+	vacuumCount         int
+	analyzeCount        int
+	lastCheckpointError error
+	lastVacuumError     error
+	lastAnalyzeError    error
+}
+
+// NewDBMaintainer creates a new database maintainer.
+func NewDBMaintainer(db database.Store, logger *slog.Logger) *DBMaintainer {
+	return &DBMaintainer{
+		db:     db,
+		logger: logger.With("component", "db_maintainer"),
+		stopCh: make(chan struct{}),
+	}
+}
+
+// Start begins the background maintenance goroutine.
+func (m *DBMaintainer) Start() {
+	m.wg.Add(1)
+	go m.run()
+	m.logger.Info("Database maintainer started",
+		"checkpoint_interval", checkpointInterval,
+		"vacuum_interval", vacuumInterval,
+		"analyze_interval", analyzeInterval,
+	)
+}
+
+// Stop gracefully shuts down the maintainer.
+func (m *DBMaintainer) Stop() {
+	close(m.stopCh)
+	m.wg.Wait()
+	m.logger.Info("Database maintainer stopped")
+}
+
+// run is the main background loop.
+func (m *DBMaintainer) run() {
+	defer m.wg.Done()
+
+	// Use different timers for each task
+	checkpointTimer := time.NewTimer(checkpointInterval)
+	vacuumTimer := time.NewTimer(vacuumInterval)
+	analyzeTimer := time.NewTimer(analyzeInterval)
+	defer checkpointTimer.Stop()
+	defer vacuumTimer.Stop()
+	defer analyzeTimer.Stop()
+
+	for {
+		select {
+		case <-m.stopCh:
+			return
+
+		case <-checkpointTimer.C:
+			m.runCheckpoint()
+			checkpointTimer.Reset(checkpointInterval)
+
+		case <-vacuumTimer.C:
+			m.runVacuum()
+			vacuumTimer.Reset(vacuumInterval)
+
+		case <-analyzeTimer.C:
+			m.runAnalyze()
+			analyzeTimer.Reset(analyzeInterval)
+		}
+	}
+}
+
+// runCheckpoint performs a WAL checkpoint to keep the WAL file small.
+func (m *DBMaintainer) runCheckpoint() {
+	ctx, cancel := context.WithTimeout(context.Background(), checkpointTimeout)
+	defer cancel()
+
+	startTime := time.Now()
+
+	err := m.db.Checkpoint(ctx)
+
+	m.statsMu.Lock()
+	m.lastCheckpoint = time.Now()
+	m.lastCheckpointError = err
+	if err == nil {
+		m.checkpointCount++
+	}
+	m.statsMu.Unlock()
+
+	if err != nil {
+		m.logger.Error("WAL checkpoint failed", "error", err, "duration", time.Since(startTime))
+	} else {
+		m.logger.Debug("WAL checkpoint completed", "duration", time.Since(startTime))
+	}
+}
+
+// runVacuum performs an incremental vacuum operation on the database.
+func (m *DBMaintainer) runVacuum() {
+	ctx, cancel := context.WithTimeout(context.Background(), vacuumTimeout)
+	defer cancel()
+
+	m.logger.Debug("Running incremental vacuum")
+	startTime := time.Now()
+
+	err := m.db.Vacuum(ctx)
+
+	m.statsMu.Lock()
+	m.lastVacuum = time.Now()
+	m.lastVacuumError = err
+	if err == nil {
+		m.vacuumCount++
+	}
+	m.statsMu.Unlock()
+
+	if err != nil {
+		m.logger.Error("Incremental vacuum failed", "error", err, "duration", time.Since(startTime))
+	} else {
+		m.logger.Debug("Incremental vacuum completed", "duration", time.Since(startTime))
+	}
+}
+
+// runAnalyze performs an ANALYZE operation on the database.
+func (m *DBMaintainer) runAnalyze() {
+	ctx, cancel := context.WithTimeout(context.Background(), analyzeTimeout)
+	defer cancel()
+
+	m.logger.Info("Starting database ANALYZE")
+	startTime := time.Now()
+
+	err := m.db.Analyze(ctx)
+
+	m.statsMu.Lock()
+	m.lastAnalyze = time.Now()
+	m.lastAnalyzeError = err
+	if err == nil {
+		m.analyzeCount++
+	}
+	m.statsMu.Unlock()
+
+	if err != nil {
+		m.logger.Error("ANALYZE failed", "error", err, "duration", time.Since(startTime))
+	} else {
+		m.logger.Info("ANALYZE completed", "duration", time.Since(startTime))
+	}
+}

internal/routewatch/handler.go

@@ -1,19 +1,29 @@
 package routewatch
 
 import (
+	"git.eeqj.de/sneak/routewatch/internal/logger"
 	"git.eeqj.de/sneak/routewatch/internal/ristypes"
-	"log/slog"
 )
 
-// SimpleHandler is a basic implementation of streamer.MessageHandler
+// SimpleHandler is a basic implementation of streamer.MessageHandler that
+// filters messages by type and delegates processing to a callback function.
+// It provides a simple way to handle specific RIS message types without
+// implementing the full MessageHandler interface from scratch.
 type SimpleHandler struct {
-	logger       *slog.Logger
+	logger       *logger.Logger
 	messageTypes []string
 	callback     func(*ristypes.RISMessage)
 }
 
-// NewSimpleHandler creates a handler that accepts specific message types
+// NewSimpleHandler creates a new SimpleHandler that accepts specific message types.
-func NewSimpleHandler(logger *slog.Logger, messageTypes []string, callback func(*ristypes.RISMessage)) *SimpleHandler {
+// The messageTypes parameter specifies which RIS message types this handler will process.
+// If messageTypes is empty, the handler will accept all message types.
+// The callback function is invoked for each message that passes the type filter.
+func NewSimpleHandler(
+	logger *logger.Logger,
+	messageTypes []string,
+	callback func(*ristypes.RISMessage),
+) *SimpleHandler {
 	return &SimpleHandler{
 		logger:       logger,
 		messageTypes: messageTypes,
@@ -21,7 +31,9 @@ func NewSimpleHandler(logger *slog.Logger, messageTypes []string, callback func(
 	}
 }
 
-// WantsMessage returns true if this handler wants to process messages of the given type
+// WantsMessage returns true if this handler wants to process messages of the given type.
+// It checks whether messageType is in the handler's configured list of accepted types.
+// If no specific types were configured (empty messageTypes slice), it returns true for all types.
 func (h *SimpleHandler) WantsMessage(messageType string) bool {
 	// If no specific types are set, accept all messages
 	if len(h.messageTypes) == 0 {
@@ -37,7 +49,8 @@ func (h *SimpleHandler) WantsMessage(messageType string) bool {
 	return false
 }
 
-// HandleMessage processes a RIS message
+// HandleMessage processes a RIS message by invoking the configured callback function.
+// If no callback was provided during construction, the message is silently ignored.
 func (h *SimpleHandler) HandleMessage(msg *ristypes.RISMessage) {
 	if h.callback != nil {
 		h.callback(msg)

internal/routewatch/peerhandler.go

@@ -1,44 +1,91 @@
 package routewatch
 
+// peerhandler.go provides batched peer tracking functionality for BGP route monitoring.
+// It tracks BGP peers from all incoming RIS messages and maintains peer state in the database.
+
 import (
-	"log/slog"
 	"strconv"
+	"sync"
+	"time"
 
 	"git.eeqj.de/sneak/routewatch/internal/database"
+	"git.eeqj.de/sneak/routewatch/internal/logger"
 	"git.eeqj.de/sneak/routewatch/internal/ristypes"
 )
 
 const (
 	// peerHandlerQueueSize is the queue capacity for peer tracking operations
-	peerHandlerQueueSize = 500
+	peerHandlerQueueSize = 100000
+
+	// peerBatchSize is the number of peer updates to batch together
+	peerBatchSize = 10000
+
+	// peerBatchTimeout is the maximum time to wait before flushing a batch
+	peerBatchTimeout = 2 * time.Second
 )
 
-// PeerHandler tracks BGP peers from all message types
+// PeerHandler tracks BGP peers from all message types using batched operations.
+// It maintains a queue of peer updates and periodically flushes them to the database
+// in batches to improve performance. The handler deduplicates peer updates within
+// each batch, keeping only the most recent update for each peer IP address.
 type PeerHandler struct {
 	db     database.Store
-	logger *slog.Logger
+	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 {
-func NewPeerHandler(db database.Store, logger *slog.Logger) *PeerHandler {
+	peerIP      string
-	return &PeerHandler{
+	peerASN     int
-		db:     db,
+	messageType string
-		logger: logger,
+	timestamp   time.Time
+}
+
+// NewPeerHandler creates a new PeerHandler with the given database store and logger.
+// It initializes the peer batch buffer and starts a background goroutine that
+// periodically flushes accumulated peer updates to the database. The handler
+// should be stopped by calling Stop when it is no longer needed.
+func NewPeerHandler(db database.Store, logger *logger.Logger) *PeerHandler {
+	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
+// WantsMessage returns true for all message types since peer information
+// is extracted from every RIS message regardless of type. This satisfies
+// the MessageHandler interface.
 func (h *PeerHandler) WantsMessage(_ string) bool {
 	return true
 }
 
-// QueueCapacity returns the desired queue capacity for this handler
+// QueueCapacity returns the desired queue capacity for this handler.
+// The PeerHandler uses a large queue capacity because batching allows
+// for efficient processing of many updates at once.
 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
 }
 
-// HandleMessage processes a message to track peer information
+// HandleMessage processes a RIS message to track peer information.
+// It extracts the peer IP address and ASN from the message and adds
+// the update to an internal batch. When the batch reaches peerBatchSize
+// or the batch timeout expires, the batch is flushed to the database.
 func (h *PeerHandler) HandleMessage(msg *ristypes.RISMessage) {
 	// Parse peer ASN from string
 	peerASN := 0
@@ -48,13 +95,85 @@ func (h *PeerHandler) HandleMessage(msg *ristypes.RISMessage) {
 		}
 	}
 
-	// Update peer in database
+	h.mu.Lock()
-	if err := h.db.UpdatePeer(msg.Peer, peerASN, msg.Type, msg.ParsedTimestamp); err != nil {
+	defer h.mu.Unlock()
-		h.logger.Error("Failed to update peer",
+
-			"peer", msg.Peer,
+	// Add to batch
-			"peer_asn", peerASN,
+	h.peerBatch = append(h.peerBatch, peerUpdate{
-			"message_type", msg.Type,
+		peerIP:      msg.Peer,
-			"error", err,
+		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
+		}
+	}
+
+	// Convert to database format
+	dbPeerMap := make(map[string]database.PeerUpdate)
+	for peerIP, update := range peerMap {
+		dbPeerMap[peerIP] = database.PeerUpdate{
+			PeerIP:      update.peerIP,
+			PeerASN:     update.peerASN,
+			MessageType: update.messageType,
+			Timestamp:   update.timestamp,
+		}
+	}
+
+	// Process all peers in a single batch transaction
+	if err := h.db.UpdatePeerBatch(dbPeerMap); err != nil {
+		h.logger.Error("Failed to process peer batch", "error", err, "count", len(dbPeerMap))
+	}
+
+	// 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()
+}

internal/routewatch/peeringhandler.go

@@ -0,0 +1,259 @@
+package routewatch
+
+import (
+	"encoding/json"
+	"sync"
+	"time"
+
+	"git.eeqj.de/sneak/routewatch/internal/database"
+	"git.eeqj.de/sneak/routewatch/internal/logger"
+	"git.eeqj.de/sneak/routewatch/internal/ristypes"
+)
+
+const (
+	// peeringHandlerQueueSize defines the buffer capacity for the peering
+	// handler's message queue. This should be large enough to handle bursts
+	// of BGP UPDATE messages without blocking.
+	peeringHandlerQueueSize = 100000
+
+	// minPathLengthForPeering specifies the minimum number of ASNs required
+	// in a BGP AS path to extract peering relationships. A path with fewer
+	// than 2 ASNs cannot contain any peering information.
+	minPathLengthForPeering = 2
+
+	// pathExpirationTime determines how long AS paths are kept in memory
+	// before being eligible for pruning. Paths older than this are removed
+	// to prevent unbounded memory growth.
+	pathExpirationTime = 30 * time.Minute
+
+	// peeringProcessInterval controls how frequently the handler processes
+	// accumulated AS paths and extracts peering relationships to store
+	// in the database.
+	peeringProcessInterval = 30 * time.Second
+
+	// pathPruneInterval determines how often the handler checks for and
+	// removes expired AS paths from memory.
+	pathPruneInterval = 5 * time.Minute
+)
+
+// PeeringHandler processes BGP UPDATE messages to extract and track
+// AS peering relationships. It accumulates AS paths in memory and
+// periodically processes them to extract unique peering pairs, which
+// are then stored in the database. The handler implements the Handler
+// interface for integration with the message processing pipeline.
+type PeeringHandler struct {
+	db     database.Store
+	logger *logger.Logger
+
+	// In-memory AS path tracking
+	mu      sync.RWMutex
+	asPaths map[string]time.Time // key is JSON-encoded AS path
+
+	stopCh chan struct{}
+}
+
+// NewPeeringHandler creates and initializes a new PeeringHandler with the
+// provided database store and logger. It starts two background goroutines:
+// one for periodic processing of accumulated AS paths into peering records,
+// and one for pruning expired paths from memory. The handler begins
+// processing immediately upon creation.
+func NewPeeringHandler(db database.Store, logger *logger.Logger) *PeeringHandler {
+	h := &PeeringHandler{
+		db:      db,
+		logger:  logger,
+		asPaths: make(map[string]time.Time),
+		stopCh:  make(chan struct{}),
+	}
+
+	// Start the periodic processing goroutines
+	go h.processLoop()
+	go h.pruneLoop()
+
+	return h
+}
+
+// WantsMessage reports whether the handler should receive messages of the
+// given type. PeeringHandler only processes UPDATE messages, as these contain
+// the AS path information needed to extract peering relationships.
+func (h *PeeringHandler) WantsMessage(messageType string) bool {
+	// We only care about UPDATE messages that have AS paths
+	return messageType == "UPDATE"
+}
+
+// QueueCapacity returns the buffer size for the handler's message queue.
+// This value is used by the message dispatcher to allocate the channel
+// buffer when registering the handler.
+func (h *PeeringHandler) QueueCapacity() int {
+	return peeringHandlerQueueSize
+}
+
+// HandleMessage processes a BGP UPDATE message by storing its AS path
+// in memory for later batch processing. Messages with AS paths shorter
+// than minPathLengthForPeering are ignored as they cannot contain valid
+// peering information.
+func (h *PeeringHandler) HandleMessage(msg *ristypes.RISMessage) {
+	// Skip if no AS path or only one AS
+	if len(msg.Path) < minPathLengthForPeering {
+		return
+	}
+
+	timestamp := msg.ParsedTimestamp
+
+	// Encode AS path as JSON for use as map key
+	pathJSON, err := json.Marshal(msg.Path)
+	if err != nil {
+		h.logger.Error("Failed to encode AS path", "error", err)
+
+		return
+	}
+
+	h.mu.Lock()
+	h.asPaths[string(pathJSON)] = timestamp
+	h.mu.Unlock()
+}
+
+// processLoop runs periodically to process AS paths into peerings
+func (h *PeeringHandler) processLoop() {
+	ticker := time.NewTicker(peeringProcessInterval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			h.processPeerings()
+		case <-h.stopCh:
+			// Final processing
+			h.processPeerings()
+
+			return
+		}
+	}
+}
+
+// pruneLoop runs periodically to remove old AS paths
+func (h *PeeringHandler) pruneLoop() {
+	ticker := time.NewTicker(pathPruneInterval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			h.prunePaths()
+		case <-h.stopCh:
+			return
+		}
+	}
+}
+
+// prunePaths removes AS paths older than pathExpirationTime
+func (h *PeeringHandler) prunePaths() {
+	cutoff := time.Now().Add(-pathExpirationTime)
+	var removed int
+
+	h.mu.Lock()
+	for pathKey, timestamp := range h.asPaths {
+		if timestamp.Before(cutoff) {
+			delete(h.asPaths, pathKey)
+			removed++
+		}
+	}
+	pathCount := len(h.asPaths)
+	h.mu.Unlock()
+
+	if removed > 0 {
+		h.logger.Debug("Pruned old AS paths", "removed", removed, "remaining", pathCount)
+	}
+}
+
+// ProcessPeeringsNow triggers immediate processing of all accumulated AS
+// paths into peering records. This bypasses the normal periodic processing
+// schedule and is primarily intended for testing purposes.
+func (h *PeeringHandler) ProcessPeeringsNow() {
+	h.processPeerings()
+}
+
+// processPeerings extracts peerings from AS paths and writes to database
+func (h *PeeringHandler) processPeerings() {
+	// Take a snapshot of current AS paths
+	h.mu.RLock()
+	pathsCopy := make(map[string]time.Time, len(h.asPaths))
+	for k, v := range h.asPaths {
+		pathsCopy[k] = v
+	}
+	h.mu.RUnlock()
+
+	if len(pathsCopy) == 0 {
+		return
+	}
+
+	// Extract unique peerings from AS paths
+	type peeringKey struct {
+		low, high int
+	}
+	peerings := make(map[peeringKey]time.Time)
+
+	for pathJSON, timestamp := range pathsCopy {
+		var path []int
+		if err := json.Unmarshal([]byte(pathJSON), &path); err != nil {
+			h.logger.Error("Failed to decode AS path", "error", err)
+
+			continue
+		}
+
+		// Extract peerings from path
+		for i := range len(path) - 1 {
+			asn1 := path[i]
+			asn2 := path[i+1]
+
+			// Skip invalid ASNs
+			if asn1 <= 0 || asn2 <= 0 || asn1 == asn2 {
+				continue
+			}
+
+			// Normalize: lower AS number first
+			low, high := asn1, asn2
+			if low > high {
+				low, high = high, low
+			}
+
+			key := peeringKey{low: low, high: high}
+			// Update timestamp if this is newer
+			if existing, ok := peerings[key]; !ok || timestamp.After(existing) {
+				peerings[key] = timestamp
+			}
+		}
+	}
+
+	// Record peerings in database
+	start := time.Now()
+	successCount := 0
+	for key, ts := range peerings {
+		err := h.db.RecordPeering(key.low, key.high, ts)
+		if err != nil {
+			h.logger.Error("Failed to record peering",
+				"as_a", key.low,
+				"as_b", key.high,
+				"error", err,
+			)
+		} else {
+			successCount++
+		}
+	}
+
+	h.logger.Info("Processed AS peerings",
+		"paths", len(pathsCopy),
+		"unique_peerings", len(peerings),
+		"success", successCount,
+		"duration", time.Since(start),
+	)
+}
+
+// Stop gracefully shuts down the handler by signaling the background
+// goroutines to stop and performing a final synchronous processing of
+// any remaining AS paths. This ensures no peering data is lost during
+// shutdown.
+func (h *PeeringHandler) Stop() {
+	close(h.stopCh)
+	// Process any remaining peerings synchronously
+	h.processPeerings()
+}

internal/routewatch/prefixhandler.go

@@ -0,0 +1,503 @@
+package routewatch
+
+import (
+	"net"
+	"strings"
+	"sync"
+	"time"
+
+	"git.eeqj.de/sneak/routewatch/internal/database"
+	"git.eeqj.de/sneak/routewatch/internal/logger"
+	"git.eeqj.de/sneak/routewatch/internal/metrics"
+	"git.eeqj.de/sneak/routewatch/internal/ristypes"
+	"github.com/google/uuid"
+)
+
+const (
+	// prefixHandlerQueueSize is the queue capacity for prefix tracking operations
+	// DO NOT set this higher than 100000 without explicit instructions
+	prefixHandlerQueueSize = 100000
+
+	// prefixBatchSize is the number of prefix updates to batch together
+	prefixBatchSize = 25000
+
+	// prefixBatchTimeout is the maximum time to wait before flushing a batch
+	// DO NOT reduce this timeout - larger batches are more efficient
+	prefixBatchTimeout = 1 * time.Second
+
+	// IP version constants
+	ipv4Version = 4
+	ipv6Version = 6
+)
+
+// PrefixHandler tracks BGP prefixes and maintains a live routing table in the database.
+// Routes are added on announcement and deleted on withdrawal.
+type PrefixHandler struct {
+	db      database.Store
+	logger  *logger.Logger
+	metrics *metrics.Tracker
+
+	// Batching
+	mu        sync.Mutex
+	batch     []prefixUpdate
+	lastFlush time.Time
+	stopCh    chan struct{}
+	wg        sync.WaitGroup
+}
+
+type prefixUpdate struct {
+	prefix      string
+	originASN   int
+	peer        string
+	messageType string
+	timestamp   time.Time
+	path        []int
+}
+
+// NewPrefixHandler creates a new batched prefix tracking handler
+func NewPrefixHandler(db database.Store, logger *logger.Logger) *PrefixHandler {
+	h := &PrefixHandler{
+		db:        db,
+		logger:    logger,
+		batch:     make([]prefixUpdate, 0, prefixBatchSize),
+		lastFlush: time.Now(),
+		stopCh:    make(chan struct{}),
+	}
+
+	// Start the flush timer goroutine
+	h.wg.Add(1)
+	go h.flushLoop()
+
+	return h
+}
+
+// SetMetricsTracker sets the metrics tracker for recording route updates
+func (h *PrefixHandler) SetMetricsTracker(metrics *metrics.Tracker) {
+	h.metrics = metrics
+}
+
+// WantsMessage returns true if this handler wants to process messages of the given type
+func (h *PrefixHandler) WantsMessage(messageType string) bool {
+	// We only care about UPDATE messages for the routing table
+	return messageType == "UPDATE"
+}
+
+// QueueCapacity returns the desired queue capacity for this handler
+func (h *PrefixHandler) QueueCapacity() int {
+	// Batching allows us to use a larger queue
+	return prefixHandlerQueueSize
+}
+
+// HandleMessage processes a message to track prefix information
+func (h *PrefixHandler) HandleMessage(msg *ristypes.RISMessage) {
+	// Use the pre-parsed timestamp
+	timestamp := msg.ParsedTimestamp
+
+	// Get origin ASN from path (last element)
+	var originASN int
+	if len(msg.Path) > 0 {
+		originASN = msg.Path[len(msg.Path)-1]
+	}
+
+	h.mu.Lock()
+	defer h.mu.Unlock()
+
+	// Process announcements
+	for _, announcement := range msg.Announcements {
+		for _, prefix := range announcement.Prefixes {
+			h.batch = append(h.batch, prefixUpdate{
+				prefix:      prefix,
+				originASN:   originASN,
+				peer:        msg.Peer,
+				messageType: "announcement",
+				timestamp:   timestamp,
+				path:        msg.Path,
+			})
+			// Record announcement in metrics
+			if h.metrics != nil {
+				h.metrics.RecordAnnouncement()
+			}
+		}
+	}
+
+	// Process withdrawals
+	for _, prefix := range msg.Withdrawals {
+		h.batch = append(h.batch, prefixUpdate{
+			prefix:      prefix,
+			originASN:   originASN, // Use the originASN from path if available
+			peer:        msg.Peer,
+			messageType: "withdrawal",
+			timestamp:   timestamp,
+			path:        msg.Path,
+		})
+		// Record withdrawal in metrics
+		if h.metrics != nil {
+			h.metrics.RecordWithdrawal()
+		}
+	}
+
+	// Check if we need to flush
+	if len(h.batch) >= prefixBatchSize {
+		h.flushBatchLocked()
+	}
+}
+
+// flushLoop runs in a goroutine and periodically flushes batches
+func (h *PrefixHandler) flushLoop() {
+	defer h.wg.Done()
+	ticker := time.NewTicker(prefixBatchTimeout)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			h.mu.Lock()
+			if time.Since(h.lastFlush) >= prefixBatchTimeout {
+				h.flushBatchLocked()
+			}
+			h.mu.Unlock()
+		case <-h.stopCh:
+			// Final flush
+			h.mu.Lock()
+			h.flushBatchLocked()
+			h.mu.Unlock()
+
+			return
+		}
+	}
+}
+
+// flushBatchLocked flushes the prefix batch to the database (must be called with mutex held)
+func (h *PrefixHandler) flushBatchLocked() {
+	if len(h.batch) == 0 {
+		return
+	}
+
+	startTime := time.Now()
+	batchSize := len(h.batch)
+
+	// Group updates by prefix to deduplicate
+	// For each prefix, keep the latest update
+	prefixMap := make(map[string]prefixUpdate)
+	for _, update := range h.batch {
+		key := update.prefix
+		if existing, ok := prefixMap[key]; !ok || update.timestamp.After(existing.timestamp) {
+			prefixMap[key] = update
+		}
+	}
+
+	// Collect routes to upsert and delete
+	var routesToUpsert []*database.LiveRoute
+	var routesToDelete []database.LiveRouteDeletion
+
+	// Collect unique prefixes to update
+	prefixesToUpdate := make(map[string]time.Time)
+
+	for _, update := range prefixMap {
+		// Track prefix for both announcements and withdrawals
+		if _, exists := prefixesToUpdate[update.prefix]; !exists || update.timestamp.After(prefixesToUpdate[update.prefix]) {
+			prefixesToUpdate[update.prefix] = update.timestamp
+		}
+
+		if update.messageType == "announcement" && update.originASN > 0 {
+			// Create live route for batch upsert
+			route := h.createLiveRoute(update)
+			if route != nil {
+				routesToUpsert = append(routesToUpsert, route)
+			}
+		} else if update.messageType == "withdrawal" {
+			// Parse CIDR to get IP version
+			_, ipVersion, err := parseCIDR(update.prefix)
+			if err != nil {
+				h.logger.Error("Failed to parse CIDR for withdrawal", "prefix", update.prefix, "error", err)
+
+				continue
+			}
+
+			// Create deletion record for batch delete
+			routesToDelete = append(routesToDelete, database.LiveRouteDeletion{
+				Prefix:    update.prefix,
+				OriginASN: update.originASN,
+				PeerIP:    update.peer,
+				IPVersion: ipVersion,
+			})
+		}
+	}
+
+	// Process batch operations
+	successCount := 0
+	if len(routesToUpsert) > 0 {
+		if err := h.db.UpsertLiveRouteBatch(routesToUpsert); err != nil {
+			h.logger.Error("Failed to upsert route batch", "error", err, "count", len(routesToUpsert))
+		} else {
+			successCount += len(routesToUpsert)
+		}
+	}
+
+	if len(routesToDelete) > 0 {
+		if err := h.db.DeleteLiveRouteBatch(routesToDelete); err != nil {
+			h.logger.Error("Failed to delete route batch", "error", err, "count", len(routesToDelete))
+		} else {
+			successCount += len(routesToDelete)
+		}
+	}
+
+	// Update prefix tables
+	if len(prefixesToUpdate) > 0 {
+		if err := h.db.UpdatePrefixesBatch(prefixesToUpdate); err != nil {
+			h.logger.Error("Failed to update prefix batch", "error", err, "count", len(prefixesToUpdate))
+		}
+	}
+
+	elapsed := time.Since(startTime)
+	h.logger.Debug("Flushed prefix batch",
+		"batch_size", batchSize,
+		"unique_prefixes", len(prefixMap),
+		"success", successCount,
+		"duration_ms", elapsed.Milliseconds(),
+	)
+
+	// Clear batch
+	h.batch = h.batch[:0]
+	h.lastFlush = time.Now()
+}
+
+// parseCIDR extracts the mask length and IP version from a prefix string
+func parseCIDR(prefix string) (maskLength int, ipVersion int, err error) {
+	_, ipNet, err := net.ParseCIDR(prefix)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	ones, _ := ipNet.Mask.Size()
+	if strings.Contains(prefix, ":") {
+		return ones, ipv6Version, nil
+	}
+
+	return ones, ipv4Version, nil
+}
+
+// processAnnouncement handles storing an announcement in the database
+// nolint:unused // kept for potential future use
+func (h *PrefixHandler) processAnnouncement(_ *database.Prefix, update prefixUpdate) {
+	// Parse CIDR to get mask length
+	maskLength, ipVersion, err := parseCIDR(update.prefix)
+	if err != nil {
+		h.logger.Error("Failed to parse CIDR",
+			"prefix", update.prefix,
+			"error", err,
+		)
+
+		return
+	}
+
+	// Track route update metrics
+	if h.metrics != nil {
+		if ipVersion == ipv4Version {
+			h.metrics.RecordIPv4Update()
+		} else {
+			h.metrics.RecordIPv6Update()
+		}
+	}
+
+	// Create live route record
+	liveRoute := &database.LiveRoute{
+		ID:          uuid.New(),
+		Prefix:      update.prefix,
+		MaskLength:  maskLength,
+		IPVersion:   ipVersion,
+		OriginASN:   update.originASN,
+		PeerIP:      update.peer,
+		ASPath:      update.path,
+		NextHop:     update.peer, // Using peer as next hop
+		LastUpdated: update.timestamp,
+	}
+
+	// For IPv4, calculate the IP range
+	if ipVersion == ipv4Version {
+		start, end, err := database.CalculateIPv4Range(update.prefix)
+		if err == nil {
+			liveRoute.V4IPStart = &start
+			liveRoute.V4IPEnd = &end
+		} else {
+			h.logger.Error("Failed to calculate IPv4 range",
+				"prefix", update.prefix,
+				"error", err,
+			)
+		}
+	}
+
+	if err := h.db.UpsertLiveRoute(liveRoute); err != nil {
+		h.logger.Error("Failed to upsert live route",
+			"prefix", update.prefix,
+			"error", err,
+		)
+	}
+}
+
+// createLiveRoute creates a LiveRoute from a prefix update
+func (h *PrefixHandler) createLiveRoute(update prefixUpdate) *database.LiveRoute {
+	// Parse CIDR to get mask length
+	maskLength, ipVersion, err := parseCIDR(update.prefix)
+	if err != nil {
+		h.logger.Error("Failed to parse CIDR",
+			"prefix", update.prefix,
+			"error", err,
+		)
+
+		return nil
+	}
+
+	// Track route update metrics
+	if h.metrics != nil {
+		if ipVersion == ipv4Version {
+			h.metrics.RecordIPv4Update()
+		} else {
+			h.metrics.RecordIPv6Update()
+		}
+	}
+
+	// Create live route record
+	liveRoute := &database.LiveRoute{
+		ID:          uuid.New(),
+		Prefix:      update.prefix,
+		MaskLength:  maskLength,
+		IPVersion:   ipVersion,
+		OriginASN:   update.originASN,
+		PeerIP:      update.peer,
+		ASPath:      update.path,
+		NextHop:     update.peer, // Using peer as next hop
+		LastUpdated: update.timestamp,
+	}
+
+	// For IPv4, calculate the IP range
+	if ipVersion == ipv4Version {
+		start, end, err := database.CalculateIPv4Range(update.prefix)
+		if err == nil {
+			liveRoute.V4IPStart = &start
+			liveRoute.V4IPEnd = &end
+		} else {
+			h.logger.Error("Failed to calculate IPv4 range",
+				"prefix", update.prefix,
+				"error", err,
+			)
+		}
+	}
+
+	return liveRoute
+}
+
+// processAnnouncementDirect handles storing an announcement directly without prefix table
+// nolint:unused // kept for potential future use
+func (h *PrefixHandler) processAnnouncementDirect(update prefixUpdate) {
+	// Parse CIDR to get mask length
+	maskLength, ipVersion, err := parseCIDR(update.prefix)
+	if err != nil {
+		h.logger.Error("Failed to parse CIDR",
+			"prefix", update.prefix,
+			"error", err,
+		)
+
+		return
+	}
+
+	// Track route update metrics
+	if h.metrics != nil {
+		if ipVersion == ipv4Version {
+			h.metrics.RecordIPv4Update()
+		} else {
+			h.metrics.RecordIPv6Update()
+		}
+	}
+
+	// Create live route record
+	liveRoute := &database.LiveRoute{
+		ID:          uuid.New(),
+		Prefix:      update.prefix,
+		MaskLength:  maskLength,
+		IPVersion:   ipVersion,
+		OriginASN:   update.originASN,
+		PeerIP:      update.peer,
+		ASPath:      update.path,
+		NextHop:     update.peer, // Using peer as next hop
+		LastUpdated: update.timestamp,
+	}
+
+	// For IPv4, calculate the IP range
+	if ipVersion == ipv4Version {
+		start, end, err := database.CalculateIPv4Range(update.prefix)
+		if err == nil {
+			liveRoute.V4IPStart = &start
+			liveRoute.V4IPEnd = &end
+		} else {
+			h.logger.Error("Failed to calculate IPv4 range",
+				"prefix", update.prefix,
+				"error", err,
+			)
+		}
+	}
+
+	if err := h.db.UpsertLiveRoute(liveRoute); err != nil {
+		h.logger.Error("Failed to upsert live route",
+			"prefix", update.prefix,
+			"error", err,
+		)
+	}
+}
+
+// processWithdrawalDirect handles removing a route directly without prefix table
+// nolint:unused // kept for potential future use
+func (h *PrefixHandler) processWithdrawalDirect(update prefixUpdate) {
+	// For withdrawals, we need to delete the route from live_routes
+	if update.originASN > 0 {
+		if err := h.db.DeleteLiveRoute(update.prefix, update.originASN, update.peer); err != nil {
+			h.logger.Error("Failed to delete live route",
+				"prefix", update.prefix,
+				"origin_asn", update.originASN,
+				"peer", update.peer,
+				"error", err,
+			)
+		}
+	} else {
+		// If no origin ASN, just delete all routes for this prefix from this peer
+		if err := h.db.DeleteLiveRoute(update.prefix, 0, update.peer); err != nil {
+			h.logger.Error("Failed to delete live route (no origin ASN)",
+				"prefix", update.prefix,
+				"peer", update.peer,
+				"error", err,
+			)
+		}
+	}
+}
+
+// processWithdrawal handles removing a route from the live routing table
+// nolint:unused // kept for potential future use
+func (h *PrefixHandler) processWithdrawal(_ *database.Prefix, update prefixUpdate) {
+	// For withdrawals, we need to delete the route from live_routes
+	// Since we have the origin ASN from the update, we can delete the specific route
+	if update.originASN > 0 {
+		if err := h.db.DeleteLiveRoute(update.prefix, update.originASN, update.peer); err != nil {
+			h.logger.Error("Failed to delete live route",
+				"prefix", update.prefix,
+				"origin_asn", update.originASN,
+				"peer", update.peer,
+				"error", err,
+			)
+		}
+	} else {
+		// If no origin ASN, just delete all routes for this prefix from this peer
+		if err := h.db.DeleteLiveRoute(update.prefix, 0, update.peer); err != nil {
+			h.logger.Error("Failed to delete live route (no origin ASN)",
+				"prefix", update.prefix,
+				"peer", update.peer,
+				"error", err,
+			)
+		}
+	}
+}
+
+// Stop gracefully stops the handler and flushes remaining batches
+func (h *PrefixHandler) Stop() {
+	close(h.stopCh)
+	h.wg.Wait()
+}

internal/routewatch/routingtablehandler.go

@@ -1,131 +0,0 @@
-package routewatch
-
-import (
-	"log/slog"
-	"strconv"
-
-	"git.eeqj.de/sneak/routewatch/internal/ristypes"
-	"git.eeqj.de/sneak/routewatch/internal/routingtable"
-	"github.com/google/uuid"
-)
-
-const (
-	// routingTableHandlerQueueSize is the queue capacity for in-memory routing table operations
-	routingTableHandlerQueueSize = 10000
-)
-
-// RoutingTableHandler handles BGP messages and updates the in-memory routing table
-type RoutingTableHandler struct {
-	rt     *routingtable.RoutingTable
-	logger *slog.Logger
-}
-
-// NewRoutingTableHandler creates a new routing table handler
-func NewRoutingTableHandler(rt *routingtable.RoutingTable, logger *slog.Logger) *RoutingTableHandler {
-	return &RoutingTableHandler{
-		rt:     rt,
-		logger: logger,
-	}
-}
-
-// WantsMessage returns true if this handler wants to process messages of the given type
-func (h *RoutingTableHandler) WantsMessage(messageType string) bool {
-	// We only care about UPDATE messages for the routing table
-	return messageType == "UPDATE"
-}
-
-// QueueCapacity returns the desired queue capacity for this handler
-func (h *RoutingTableHandler) QueueCapacity() int {
-	// In-memory operations are very fast, so use a large queue
-	return routingTableHandlerQueueSize
-}
-
-// HandleMessage processes a RIS message and updates the routing table
-func (h *RoutingTableHandler) HandleMessage(msg *ristypes.RISMessage) {
-	// Use the pre-parsed timestamp
-	timestamp := msg.ParsedTimestamp
-
-	// Parse peer ASN
-	peerASN, err := strconv.Atoi(msg.PeerASN)
-	if err != nil {
-		h.logger.Error("Failed to parse peer ASN", "peer_asn", msg.PeerASN, "error", err)
-
-		return
-	}
-
-	// Get origin ASN from path (last element)
-	var originASN int
-	if len(msg.Path) > 0 {
-		originASN = msg.Path[len(msg.Path)-1]
-	}
-
-	// Process announcements
-	for _, announcement := range msg.Announcements {
-		for _, prefix := range announcement.Prefixes {
-			// Generate deterministic UUIDs based on the prefix and origin ASN
-			// This ensures consistency across restarts
-			prefixID := uuid.NewSHA1(uuid.NameSpaceURL, []byte(prefix))
-			originASNID := uuid.NewSHA1(uuid.NameSpaceOID, []byte(strconv.Itoa(originASN)))
-
-			// Create route for the routing table
-			route := &routingtable.Route{
-				PrefixID:    prefixID,
-				Prefix:      prefix,
-				OriginASNID: originASNID,
-				OriginASN:   originASN,
-				PeerASN:     peerASN,
-				ASPath:      msg.Path,
-				NextHop:     announcement.NextHop,
-				AnnouncedAt: timestamp,
-			}
-
-			// Add route to routing table
-			h.rt.AddRoute(route)
-		}
-	}
-
-	// Process withdrawals
-	for _, prefix := range msg.Withdrawals {
-		// Generate deterministic UUID for the prefix
-		prefixID := uuid.NewSHA1(uuid.NameSpaceURL, []byte(prefix))
-
-		// Withdraw all routes for this prefix from this peer
-		h.rt.WithdrawRoutesByPrefixAndPeer(prefixID, peerASN)
-	}
-}
-
-// GetRoutingTableStats returns statistics about the routing table
-func (h *RoutingTableHandler) GetRoutingTableStats() map[string]int {
-	return h.rt.Stats()
-}
-
-// GetActiveRouteCount returns the number of active routes
-func (h *RoutingTableHandler) GetActiveRouteCount() int {
-	return h.rt.Size()
-}
-
-// GetRoutesByPrefix returns all routes for a specific prefix
-func (h *RoutingTableHandler) GetRoutesByPrefix(prefixID uuid.UUID) []*routingtable.Route {
-	return h.rt.GetRoutesByPrefix(prefixID)
-}
-
-// GetRoutesByOriginASN returns all routes originated by a specific ASN
-func (h *RoutingTableHandler) GetRoutesByOriginASN(originASNID uuid.UUID) []*routingtable.Route {
-	return h.rt.GetRoutesByOriginASN(originASNID)
-}
-
-// GetRoutesByPeerASN returns all routes received from a specific peer ASN
-func (h *RoutingTableHandler) GetRoutesByPeerASN(peerASN int) []*routingtable.Route {
-	return h.rt.GetRoutesByPeerASN(peerASN)
-}
-
-// GetAllRoutes returns all active routes
-func (h *RoutingTableHandler) GetAllRoutes() []*routingtable.Route {
-	return h.rt.GetAllRoutes()
-}
-
-// ClearRoutingTable clears all routes from the routing table
-func (h *RoutingTableHandler) ClearRoutingTable() {
-	h.rt.Clear()
-	h.logger.Info("Cleared routing table")
-}

internal/routingtable/routingtable.go

@@ -1,553 +0,0 @@
-// Package routingtable provides a thread-safe in-memory representation of the DFZ routing table.
-package routingtable
-
-import (
-	"compress/gzip"
-	"encoding/json"
-	"fmt"
-	"log/slog"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/google/uuid"
-)
-
-const (
-	// routeStalenessThreshold is how old a route can be before we consider it stale
-	// Using 30 minutes as a conservative value for snapshot loading
-	routeStalenessThreshold = 30 * time.Minute
-
-	// snapshotFilename is the name of the snapshot file
-	snapshotFilename = "routewatch-snapshot.json.gz"
-)
-
-// Route represents a single route entry in the routing table
-type Route struct {
-	PrefixID    uuid.UUID `json:"prefix_id"`
-	Prefix      string    `json:"prefix"` // The actual prefix string (e.g., "10.0.0.0/8")
-	OriginASNID uuid.UUID `json:"origin_asn_id"`
-	OriginASN   int       `json:"origin_asn"` // The actual ASN number
-	PeerASN     int       `json:"peer_asn"`
-	ASPath      []int     `json:"as_path"` // Full AS path
-	NextHop     string    `json:"next_hop"`
-	AnnouncedAt time.Time `json:"announced_at"`
-	AddedAt     time.Time `json:"added_at"` // When we added this route to our table
-}
-
-// RouteKey uniquely identifies a route in the table
-type RouteKey struct {
-	PrefixID    uuid.UUID
-	OriginASNID uuid.UUID
-	PeerASN     int
-}
-
-// RoutingTable is a thread-safe in-memory routing table
-type RoutingTable struct {
-	mu     sync.RWMutex
-	routes map[RouteKey]*Route
-
-	// Secondary indexes for efficient lookups
-	byPrefix    map[uuid.UUID]map[RouteKey]*Route // Routes indexed by prefix ID
-	byOriginASN map[uuid.UUID]map[RouteKey]*Route // Routes indexed by origin ASN ID
-	byPeerASN   map[int]map[RouteKey]*Route       // Routes indexed by peer ASN
-
-	// Metrics tracking
-	ipv4Routes       int
-	ipv6Routes       int
-	ipv4Updates      uint64 // Updates counter for rate calculation
-	ipv6Updates      uint64 // Updates counter for rate calculation
-	lastMetricsReset time.Time
-}
-
-// New creates a new routing table, loading from snapshot if available
-func New(logger *slog.Logger) *RoutingTable {
-	rt := &RoutingTable{
-		routes:           make(map[RouteKey]*Route),
-		byPrefix:         make(map[uuid.UUID]map[RouteKey]*Route),
-		byOriginASN:      make(map[uuid.UUID]map[RouteKey]*Route),
-		byPeerASN:        make(map[int]map[RouteKey]*Route),
-		lastMetricsReset: time.Now(),
-	}
-
-	// Try to load from snapshot
-	if err := rt.loadFromSnapshot(logger); err != nil {
-		logger.Warn("Failed to load routing table from snapshot", "error", err)
-	}
-
-	return rt
-}
-
-// AddRoute adds or updates a route in the routing table
-func (rt *RoutingTable) AddRoute(route *Route) {
-	rt.mu.Lock()
-	defer rt.mu.Unlock()
-
-	key := RouteKey{
-		PrefixID:    route.PrefixID,
-		OriginASNID: route.OriginASNID,
-		PeerASN:     route.PeerASN,
-	}
-
-	// If route already exists, remove it from indexes first
-	if existingRoute, exists := rt.routes[key]; exists {
-		rt.removeFromIndexes(key, existingRoute)
-		// Decrement counter for existing route
-		if isIPv6(existingRoute.Prefix) {
-			rt.ipv6Routes--
-		} else {
-			rt.ipv4Routes--
-		}
-	}
-
-	// Set AddedAt if not already set
-	if route.AddedAt.IsZero() {
-		route.AddedAt = time.Now().UTC()
-	}
-
-	// Add to main map
-	rt.routes[key] = route
-
-	// Update indexes
-	rt.addToIndexes(key, route)
-
-	// Update metrics
-	if isIPv6(route.Prefix) {
-		rt.ipv6Routes++
-		atomic.AddUint64(&rt.ipv6Updates, 1)
-	} else {
-		rt.ipv4Routes++
-		atomic.AddUint64(&rt.ipv4Updates, 1)
-	}
-}
-
-// RemoveRoute removes a route from the routing table
-func (rt *RoutingTable) RemoveRoute(prefixID, originASNID uuid.UUID, peerASN int) bool {
-	rt.mu.Lock()
-	defer rt.mu.Unlock()
-
-	key := RouteKey{
-		PrefixID:    prefixID,
-		OriginASNID: originASNID,
-		PeerASN:     peerASN,
-	}
-
-	route, exists := rt.routes[key]
-	if !exists {
-		return false
-	}
-
-	// Remove from indexes
-	rt.removeFromIndexes(key, route)
-
-	// Remove from main map
-	delete(rt.routes, key)
-
-	// Update metrics
-	if isIPv6(route.Prefix) {
-		rt.ipv6Routes--
-		atomic.AddUint64(&rt.ipv6Updates, 1)
-	} else {
-		rt.ipv4Routes--
-		atomic.AddUint64(&rt.ipv4Updates, 1)
-	}
-
-	return true
-}
-
-// WithdrawRoutesByPrefixAndPeer removes all routes for a specific prefix from a specific peer
-func (rt *RoutingTable) WithdrawRoutesByPrefixAndPeer(prefixID uuid.UUID, peerASN int) int {
-	rt.mu.Lock()
-	defer rt.mu.Unlock()
-
-	prefixRoutes, exists := rt.byPrefix[prefixID]
-	if !exists {
-		return 0
-	}
-
-	// Collect keys to delete (can't delete while iterating)
-	var keysToDelete []RouteKey
-	for key, route := range prefixRoutes {
-		if route.PeerASN == peerASN {
-			keysToDelete = append(keysToDelete, key)
-		}
-	}
-
-	// Delete the routes
-	count := 0
-	for _, key := range keysToDelete {
-		route, exists := rt.routes[key]
-		if !exists {
-			continue
-		}
-
-		rt.removeFromIndexes(key, route)
-		delete(rt.routes, key)
-		count++
-
-		// Update metrics
-		if isIPv6(route.Prefix) {
-			rt.ipv6Routes--
-			atomic.AddUint64(&rt.ipv6Updates, 1)
-		} else {
-			rt.ipv4Routes--
-			atomic.AddUint64(&rt.ipv4Updates, 1)
-		}
-	}
-
-	return count
-}
-
-// GetRoute retrieves a specific route
-func (rt *RoutingTable) GetRoute(prefixID, originASNID uuid.UUID, peerASN int) (*Route, bool) {
-	rt.mu.RLock()
-	defer rt.mu.RUnlock()
-
-	key := RouteKey{
-		PrefixID:    prefixID,
-		OriginASNID: originASNID,
-		PeerASN:     peerASN,
-	}
-
-	route, exists := rt.routes[key]
-	if !exists {
-		return nil, false
-	}
-
-	// Return a copy to prevent external modification
-	routeCopy := *route
-
-	return &routeCopy, true
-}
-
-// GetRoutesByPrefix returns all routes for a specific prefix
-func (rt *RoutingTable) GetRoutesByPrefix(prefixID uuid.UUID) []*Route {
-	rt.mu.RLock()
-	defer rt.mu.RUnlock()
-
-	routes := make([]*Route, 0)
-	if prefixRoutes, exists := rt.byPrefix[prefixID]; exists {
-		for _, route := range prefixRoutes {
-			routeCopy := *route
-			routes = append(routes, &routeCopy)
-		}
-	}
-
-	return routes
-}
-
-// GetRoutesByOriginASN returns all routes originated by a specific ASN
-func (rt *RoutingTable) GetRoutesByOriginASN(originASNID uuid.UUID) []*Route {
-	rt.mu.RLock()
-	defer rt.mu.RUnlock()
-
-	routes := make([]*Route, 0)
-	if asnRoutes, exists := rt.byOriginASN[originASNID]; exists {
-		for _, route := range asnRoutes {
-			routeCopy := *route
-			routes = append(routes, &routeCopy)
-		}
-	}
-
-	return routes
-}
-
-// GetRoutesByPeerASN returns all routes received from a specific peer ASN
-func (rt *RoutingTable) GetRoutesByPeerASN(peerASN int) []*Route {
-	rt.mu.RLock()
-	defer rt.mu.RUnlock()
-
-	routes := make([]*Route, 0)
-	if peerRoutes, exists := rt.byPeerASN[peerASN]; exists {
-		for _, route := range peerRoutes {
-			routeCopy := *route
-			routes = append(routes, &routeCopy)
-		}
-	}
-
-	return routes
-}
-
-// GetAllRoutes returns all active routes in the routing table
-func (rt *RoutingTable) GetAllRoutes() []*Route {
-	rt.mu.RLock()
-	defer rt.mu.RUnlock()
-
-	routes := make([]*Route, 0, len(rt.routes))
-	for _, route := range rt.routes {
-		routeCopy := *route
-		routes = append(routes, &routeCopy)
-	}
-
-	return routes
-}
-
-// Size returns the total number of routes in the table
-func (rt *RoutingTable) Size() int {
-	rt.mu.RLock()
-	defer rt.mu.RUnlock()
-
-	return len(rt.routes)
-}
-
-// Stats returns statistics about the routing table
-func (rt *RoutingTable) Stats() map[string]int {
-	rt.mu.RLock()
-	defer rt.mu.RUnlock()
-
-	stats := map[string]int{
-		"total_routes":    len(rt.routes),
-		"unique_prefixes": len(rt.byPrefix),
-		"unique_origins":  len(rt.byOriginASN),
-		"unique_peers":    len(rt.byPeerASN),
-	}
-
-	return stats
-}
-
-// DetailedStats contains detailed routing table statistics
-type DetailedStats struct {
-	IPv4Routes      int
-	IPv6Routes      int
-	IPv4UpdatesRate float64
-	IPv6UpdatesRate float64
-	TotalRoutes     int
-	UniquePrefixes  int
-	UniqueOrigins   int
-	UniquePeers     int
-}
-
-// GetDetailedStats returns detailed statistics including IPv4/IPv6 breakdown and update rates
-func (rt *RoutingTable) GetDetailedStats() DetailedStats {
-	rt.mu.Lock()
-	defer rt.mu.Unlock()
-
-	// Calculate update rates
-	elapsed := time.Since(rt.lastMetricsReset).Seconds()
-	ipv4Updates := atomic.LoadUint64(&rt.ipv4Updates)
-	ipv6Updates := atomic.LoadUint64(&rt.ipv6Updates)
-
-	stats := DetailedStats{
-		IPv4Routes:      rt.ipv4Routes,
-		IPv6Routes:      rt.ipv6Routes,
-		IPv4UpdatesRate: float64(ipv4Updates) / elapsed,
-		IPv6UpdatesRate: float64(ipv6Updates) / elapsed,
-		TotalRoutes:     len(rt.routes),
-		UniquePrefixes:  len(rt.byPrefix),
-		UniqueOrigins:   len(rt.byOriginASN),
-		UniquePeers:     len(rt.byPeerASN),
-	}
-
-	// Reset counters for next period
-	atomic.StoreUint64(&rt.ipv4Updates, 0)
-	atomic.StoreUint64(&rt.ipv6Updates, 0)
-	rt.lastMetricsReset = time.Now()
-
-	return stats
-}
-
-// Clear removes all routes from the routing table
-func (rt *RoutingTable) Clear() {
-	rt.mu.Lock()
-	defer rt.mu.Unlock()
-
-	rt.routes = make(map[RouteKey]*Route)
-	rt.byPrefix = make(map[uuid.UUID]map[RouteKey]*Route)
-	rt.byOriginASN = make(map[uuid.UUID]map[RouteKey]*Route)
-	rt.byPeerASN = make(map[int]map[RouteKey]*Route)
-	rt.ipv4Routes = 0
-	rt.ipv6Routes = 0
-	atomic.StoreUint64(&rt.ipv4Updates, 0)
-	atomic.StoreUint64(&rt.ipv6Updates, 0)
-	rt.lastMetricsReset = time.Now()
-}
-
-// RLock acquires a read lock on the routing table
-// This is exposed for the snapshotter to use
-func (rt *RoutingTable) RLock() {
-	rt.mu.RLock()
-}
-
-// RUnlock releases a read lock on the routing table
-// This is exposed for the snapshotter to use
-func (rt *RoutingTable) RUnlock() {
-	rt.mu.RUnlock()
-}
-
-// GetAllRoutesUnsafe returns all routes without copying
-// IMPORTANT: Caller must hold RLock before calling this method
-func (rt *RoutingTable) GetAllRoutesUnsafe() []*Route {
-	routes := make([]*Route, 0, len(rt.routes))
-	for _, route := range rt.routes {
-		routes = append(routes, route)
-	}
-
-	return routes
-}
-
-// Helper methods for index management
-
-func (rt *RoutingTable) addToIndexes(key RouteKey, route *Route) {
-	// Add to prefix index
-	if rt.byPrefix[route.PrefixID] == nil {
-		rt.byPrefix[route.PrefixID] = make(map[RouteKey]*Route)
-	}
-	rt.byPrefix[route.PrefixID][key] = route
-
-	// Add to origin ASN index
-	if rt.byOriginASN[route.OriginASNID] == nil {
-		rt.byOriginASN[route.OriginASNID] = make(map[RouteKey]*Route)
-	}
-	rt.byOriginASN[route.OriginASNID][key] = route
-
-	// Add to peer ASN index
-	if rt.byPeerASN[route.PeerASN] == nil {
-		rt.byPeerASN[route.PeerASN] = make(map[RouteKey]*Route)
-	}
-	rt.byPeerASN[route.PeerASN][key] = route
-}
-
-func (rt *RoutingTable) removeFromIndexes(key RouteKey, route *Route) {
-	// Remove from prefix index
-	if prefixRoutes, exists := rt.byPrefix[route.PrefixID]; exists {
-		delete(prefixRoutes, key)
-		if len(prefixRoutes) == 0 {
-			delete(rt.byPrefix, route.PrefixID)
-		}
-	}
-
-	// Remove from origin ASN index
-	if asnRoutes, exists := rt.byOriginASN[route.OriginASNID]; exists {
-		delete(asnRoutes, key)
-		if len(asnRoutes) == 0 {
-			delete(rt.byOriginASN, route.OriginASNID)
-		}
-	}
-
-	// Remove from peer ASN index
-	if peerRoutes, exists := rt.byPeerASN[route.PeerASN]; exists {
-		delete(peerRoutes, key)
-		if len(peerRoutes) == 0 {
-			delete(rt.byPeerASN, route.PeerASN)
-		}
-	}
-}
-
-// String returns a string representation of the route key
-func (k RouteKey) String() string {
-	return fmt.Sprintf("%s/%s/%d", k.PrefixID, k.OriginASNID, k.PeerASN)
-}
-
-// isIPv6 returns true if the prefix is an IPv6 address
-func isIPv6(prefix string) bool {
-	return strings.Contains(prefix, ":")
-}
-
-// getStateDirectory returns the appropriate state directory based on the OS
-func getStateDirectory() (string, error) {
-	switch runtime.GOOS {
-	case "darwin":
-		// macOS: Use ~/Library/Application Support/routewatch
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return "", err
-		}
-
-		return filepath.Join(home, "Library", "Application Support", "routewatch"), nil
-	case "linux", "freebsd", "openbsd", "netbsd":
-		// Unix-like: Use /var/lib/routewatch if running as root, otherwise use XDG_STATE_HOME
-		if os.Geteuid() == 0 {
-			return "/var/lib/routewatch", nil
-		}
-		// Check XDG_STATE_HOME first
-		if xdgState := os.Getenv("XDG_STATE_HOME"); xdgState != "" {
-			return filepath.Join(xdgState, "routewatch"), nil
-		}
-		// Fall back to ~/.local/state/routewatch
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return "", err
-		}
-
-		return filepath.Join(home, ".local", "state", "routewatch"), nil
-	default:
-		return "", fmt.Errorf("unsupported operating system: %s", runtime.GOOS)
-	}
-}
-
-// loadFromSnapshot attempts to load the routing table from a snapshot file
-func (rt *RoutingTable) loadFromSnapshot(logger *slog.Logger) error {
-	stateDir, err := getStateDirectory()
-	if err != nil {
-		return fmt.Errorf("failed to determine state directory: %w", err)
-	}
-
-	snapshotPath := filepath.Join(stateDir, snapshotFilename)
-
-	// Check if snapshot file exists
-	if _, err := os.Stat(snapshotPath); os.IsNotExist(err) {
-		logger.Info("No snapshot file found, starting with empty routing table")
-
-		return nil
-	}
-
-	// Open the snapshot file
-	file, err := os.Open(filepath.Clean(snapshotPath))
-	if err != nil {
-		return fmt.Errorf("failed to open snapshot file: %w", err)
-	}
-	defer func() { _ = file.Close() }()
-
-	// Create gzip reader
-	gzReader, err := gzip.NewReader(file)
-	if err != nil {
-		return fmt.Errorf("failed to create gzip reader: %w", err)
-	}
-	defer func() { _ = gzReader.Close() }()
-
-	// Decode the snapshot
-	var snapshot struct {
-		Timestamp time.Time     `json:"timestamp"`
-		Stats     DetailedStats `json:"stats"`
-		Routes    []*Route      `json:"routes"`
-	}
-
-	decoder := json.NewDecoder(gzReader)
-	if err := decoder.Decode(&snapshot); err != nil {
-		return fmt.Errorf("failed to decode snapshot: %w", err)
-	}
-
-	// Calculate staleness cutoff time
-	now := time.Now().UTC()
-	cutoffTime := now.Add(-routeStalenessThreshold)
-
-	// Load non-stale routes
-	loadedCount := 0
-	staleCount := 0
-
-	for _, route := range snapshot.Routes {
-		// Check if route is stale based on AddedAt time
-		if route.AddedAt.Before(cutoffTime) {
-			staleCount++
-
-			continue
-		}
-
-		// Add the route (this will update counters and indexes)
-		rt.AddRoute(route)
-		loadedCount++
-	}
-
-	logger.Info("Loaded routing table from snapshot",
-		"snapshot_time", snapshot.Timestamp,
-		"loaded_routes", loadedCount,
-		"stale_routes", staleCount,
-		"total_routes_in_snapshot", len(snapshot.Routes),
-	)
-
-	return nil
-}

internal/routingtable/routingtable_test.go

@@ -1,226 +0,0 @@
-package routingtable
-
-import (
-	"log/slog"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/google/uuid"
-)
-
-func TestRoutingTable(t *testing.T) {
-	// Create a test logger
-	logger := slog.Default()
-	rt := New(logger)
-
-	// Test data
-	prefixID1 := uuid.New()
-	prefixID2 := uuid.New()
-	originASNID1 := uuid.New()
-	originASNID2 := uuid.New()
-
-	route1 := &Route{
-		PrefixID:    prefixID1,
-		Prefix:      "10.0.0.0/8",
-		OriginASNID: originASNID1,
-		OriginASN:   64512,
-		PeerASN:     64513,
-		ASPath:      []int{64513, 64512},
-		NextHop:     "192.168.1.1",
-		AnnouncedAt: time.Now(),
-	}
-
-	route2 := &Route{
-		PrefixID:    prefixID2,
-		Prefix:      "192.168.0.0/16",
-		OriginASNID: originASNID2,
-		OriginASN:   64514,
-		PeerASN:     64513,
-		ASPath:      []int{64513, 64514},
-		NextHop:     "192.168.1.1",
-		AnnouncedAt: time.Now(),
-	}
-
-	// Test AddRoute
-	rt.AddRoute(route1)
-	rt.AddRoute(route2)
-
-	if rt.Size() != 2 {
-		t.Errorf("Expected 2 routes, got %d", rt.Size())
-	}
-
-	// Test GetRoute
-	retrievedRoute, exists := rt.GetRoute(prefixID1, originASNID1, 64513)
-	if !exists {
-		t.Error("Route 1 should exist")
-	}
-	if retrievedRoute.Prefix != "10.0.0.0/8" {
-		t.Errorf("Expected prefix 10.0.0.0/8, got %s", retrievedRoute.Prefix)
-	}
-
-	// Test GetRoutesByPrefix
-	prefixRoutes := rt.GetRoutesByPrefix(prefixID1)
-	if len(prefixRoutes) != 1 {
-		t.Errorf("Expected 1 route for prefix, got %d", len(prefixRoutes))
-	}
-
-	// Test GetRoutesByPeerASN
-	peerRoutes := rt.GetRoutesByPeerASN(64513)
-	if len(peerRoutes) != 2 {
-		t.Errorf("Expected 2 routes from peer 64513, got %d", len(peerRoutes))
-	}
-
-	// Test RemoveRoute
-	removed := rt.RemoveRoute(prefixID1, originASNID1, 64513)
-	if !removed {
-		t.Error("Route should have been removed")
-	}
-	if rt.Size() != 1 {
-		t.Errorf("Expected 1 route after removal, got %d", rt.Size())
-	}
-
-	// Test WithdrawRoutesByPrefixAndPeer
-	// Add the route back first
-	rt.AddRoute(route1)
-
-	// Add another route for the same prefix from the same peer
-	route3 := &Route{
-		PrefixID:    prefixID1,
-		Prefix:      "10.0.0.0/8",
-		OriginASNID: originASNID2, // Different origin
-		OriginASN:   64515,
-		PeerASN:     64513,
-		ASPath:      []int{64513, 64515},
-		NextHop:     "192.168.1.1",
-		AnnouncedAt: time.Now(),
-	}
-	rt.AddRoute(route3)
-
-	count := rt.WithdrawRoutesByPrefixAndPeer(prefixID1, 64513)
-	if count != 2 {
-		t.Errorf("Expected to withdraw 2 routes, withdrew %d", count)
-	}
-
-	// Should only have route2 left
-	if rt.Size() != 1 {
-		t.Errorf("Expected 1 route after withdrawal, got %d", rt.Size())
-	}
-
-	// Test Stats
-	stats := rt.Stats()
-	if stats["total_routes"] != 1 {
-		t.Errorf("Expected 1 total route in stats, got %d", stats["total_routes"])
-	}
-
-	// Test Clear
-	rt.Clear()
-	if rt.Size() != 0 {
-		t.Errorf("Expected 0 routes after clear, got %d", rt.Size())
-	}
-}
-
-func TestRoutingTableConcurrency(t *testing.T) {
-	// Create a test logger
-	logger := slog.Default()
-	rt := New(logger)
-
-	// Test concurrent access
-	var wg sync.WaitGroup
-	numGoroutines := 10
-	numOperations := 100
-
-	// Start multiple goroutines that add/remove routes
-	for i := 0; i < numGoroutines; i++ {
-		wg.Add(1)
-		go func(id int) {
-			defer wg.Done()
-
-			for j := 0; j < numOperations; j++ {
-				prefixID := uuid.New()
-				originASNID := uuid.New()
-
-				route := &Route{
-					PrefixID:    prefixID,
-					Prefix:      "10.0.0.0/8",
-					OriginASNID: originASNID,
-					OriginASN:   64512 + id,
-					PeerASN:     64500,
-					ASPath:      []int{64500, 64512 + id},
-					NextHop:     "192.168.1.1",
-					AnnouncedAt: time.Now(),
-				}
-
-				// Add route
-				rt.AddRoute(route)
-
-				// Try to get it
-				_, _ = rt.GetRoute(prefixID, originASNID, 64500)
-
-				// Get stats
-				_ = rt.Stats()
-
-				// Remove it
-				rt.RemoveRoute(prefixID, originASNID, 64500)
-			}
-		}(i)
-	}
-
-	wg.Wait()
-
-	// Table should be empty after all operations
-	if rt.Size() != 0 {
-		t.Errorf("Expected empty table after concurrent operations, got %d routes", rt.Size())
-	}
-}
-
-func TestRouteUpdate(t *testing.T) {
-	// Create a test logger
-	logger := slog.Default()
-	rt := New(logger)
-
-	prefixID := uuid.New()
-	originASNID := uuid.New()
-
-	route1 := &Route{
-		PrefixID:    prefixID,
-		Prefix:      "10.0.0.0/8",
-		OriginASNID: originASNID,
-		OriginASN:   64512,
-		PeerASN:     64513,
-		ASPath:      []int{64513, 64512},
-		NextHop:     "192.168.1.1",
-		AnnouncedAt: time.Now(),
-	}
-
-	// Add initial route
-	rt.AddRoute(route1)
-
-	// Update the same route with new next hop
-	route2 := &Route{
-		PrefixID:    prefixID,
-		Prefix:      "10.0.0.0/8",
-		OriginASNID: originASNID,
-		OriginASN:   64512,
-		PeerASN:     64513,
-		ASPath:      []int{64513, 64512},
-		NextHop:     "192.168.1.2", // Changed
-		AnnouncedAt: time.Now().Add(1 * time.Minute),
-	}
-
-	rt.AddRoute(route2)
-
-	// Should still have only 1 route
-	if rt.Size() != 1 {
-		t.Errorf("Expected 1 route after update, got %d", rt.Size())
-	}
-
-	// Check that the route was updated
-	retrievedRoute, exists := rt.GetRoute(prefixID, originASNID, 64513)
-	if !exists {
-		t.Error("Route should exist after update")
-	}
-	if retrievedRoute.NextHop != "192.168.1.2" {
-		t.Errorf("Expected updated next hop 192.168.1.2, got %s", retrievedRoute.NextHop)
-	}
-}

internal/server/middleware.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"log/slog"
 	"net/http"
 	"sync"
 	"time"
@@ -44,7 +45,12 @@ func (rw *responseWriter) Header() http.Header {
 	return rw.ResponseWriter.Header()
 }
 
-// JSONResponseMiddleware wraps all JSON responses with metadata
+// JSONResponseMiddleware is an HTTP middleware that wraps all JSON responses
+// with a @meta field containing execution metadata. The metadata includes the
+// time zone (always UTC), API version, and request execution time in milliseconds.
+//
+// Endpoints "/" and "/status" are excluded from this processing and passed through
+// unchanged. Non-JSON responses and empty responses are also passed through unchanged.
 func JSONResponseMiddleware(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		// Skip non-JSON endpoints
@@ -108,6 +114,7 @@ type timeoutWriter struct {
 	http.ResponseWriter
 	mu      sync.Mutex
 	written bool
+	header  http.Header // cached header to prevent concurrent access
 }
 
 func (tw *timeoutWriter) Write(b []byte) (int, error) {
@@ -133,6 +140,18 @@ func (tw *timeoutWriter) WriteHeader(statusCode int) {
 }
 
 func (tw *timeoutWriter) Header() http.Header {
+	tw.mu.Lock()
+	defer tw.mu.Unlock()
+
+	if tw.written {
+		// Return a copy to prevent modifications after timeout
+		if tw.header == nil {
+			tw.header = make(http.Header)
+		}
+
+		return tw.header
+	}
+
 	return tw.ResponseWriter.Header()
 }
 
@@ -142,8 +161,14 @@ func (tw *timeoutWriter) markWritten() {
 	tw.written = true
 }
 
-// TimeoutMiddleware creates a timeout middleware that returns JSON errors
+// TimeoutMiddleware creates an HTTP middleware that enforces a request timeout.
-func TimeoutMiddleware(timeout time.Duration) func(http.Handler) http.Handler {
+// If the handler does not complete within the specified duration, the middleware
+// returns a JSON error response with HTTP status 408 (Request Timeout).
+//
+// The timeout parameter specifies the maximum duration allowed for request processing.
+// The returned middleware handles panics from the wrapped handler by re-panicking
+// after cleanup, and prevents concurrent writes to the response after timeout occurs.
+func TimeoutMiddleware(timeout time.Duration, logger *slog.Logger) func(http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			startTime := time.Now()
@@ -153,6 +178,7 @@ func TimeoutMiddleware(timeout time.Duration) func(http.Handler) http.Handler {
 
 			tw := &timeoutWriter{
 				ResponseWriter: w,
+				header:         make(http.Header),
 			}
 
 			done := make(chan struct{})
@@ -178,8 +204,20 @@ func TimeoutMiddleware(timeout time.Duration) func(http.Handler) http.Handler {
 				tw.markWritten() // Prevent the handler from writing after timeout
 				execTime := time.Since(startTime)
 
+				// Log the timeout as a warning
+				logger.Warn("Request timeout",
+					"method", r.Method,
+					"path", r.URL.Path,
+					"duration_ms", execTime.Milliseconds(),
+					"remote_addr", r.RemoteAddr,
+				)
+
+				// Write directly to the underlying writer since we've marked tw as written
+				// This is safe because markWritten() prevents the handler from writing
+				tw.mu.Lock()
 				w.Header().Set("Content-Type", "application/json")
 				w.WriteHeader(http.StatusRequestTimeout)
+				tw.mu.Unlock()
 
 				response := map[string]interface{}{
 					"status": "error",
@@ -199,3 +237,147 @@ func TimeoutMiddleware(timeout time.Duration) func(http.Handler) http.Handler {
 		})
 	}
 }
+
+// JSONValidationMiddleware is an HTTP middleware that validates JSON API responses.
+// It ensures that responses with Content-Type "application/json" contain valid JSON.
+//
+// If a response is not valid JSON or is empty when JSON is expected, the middleware
+// returns a properly formatted JSON error response. For timeout errors (status 408),
+// the error message will be "Request timeout". For other errors, it returns
+// "Internal server error" with status 500 if the original status was 200.
+//
+// Non-JSON responses are passed through unchanged.
+func JSONValidationMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Create a custom response writer to capture the response
+		rw := &responseWriter{
+			ResponseWriter: w,
+			body:           &bytes.Buffer{},
+			statusCode:     http.StatusOK,
+		}
+
+		// Serve the request
+		next.ServeHTTP(rw, r)
+
+		// Check if it's meant to be a JSON response
+		contentType := rw.Header().Get("Content-Type")
+		isJSON := contentType == "application/json" || contentType == ""
+
+		// If it's not JSON or has content, pass through
+		if !isJSON && rw.body.Len() > 0 {
+			w.WriteHeader(rw.statusCode)
+			_, _ = w.Write(rw.body.Bytes())
+
+			return
+		}
+
+		// For JSON responses, validate the JSON
+		if rw.body.Len() > 0 {
+			var testParse interface{}
+			if err := json.Unmarshal(rw.body.Bytes(), &testParse); err == nil {
+				// Valid JSON, write it out
+				w.Header().Set("Content-Type", "application/json")
+				w.WriteHeader(rw.statusCode)
+				_, _ = w.Write(rw.body.Bytes())
+
+				return
+			}
+		}
+
+		// If we get here, either there's no body or invalid JSON
+		// Write a proper error response
+		w.Header().Set("Content-Type", "application/json")
+
+		// Determine appropriate status code
+		statusCode := rw.statusCode
+		if statusCode == http.StatusOK {
+			statusCode = http.StatusInternalServerError
+		}
+		w.WriteHeader(statusCode)
+
+		errorMsg := "Internal server error"
+		if statusCode == http.StatusRequestTimeout {
+			errorMsg = "Request timeout"
+		}
+
+		response := map[string]interface{}{
+			"status": "error",
+			"error": map[string]interface{}{
+				"msg":  errorMsg,
+				"code": statusCode,
+			},
+		}
+		_ = json.NewEncoder(w).Encode(response)
+	})
+}
+
+// statusWriter wraps http.ResponseWriter to capture the status code
+type statusWriter struct {
+	http.ResponseWriter
+	statusCode int
+	written    bool
+}
+
+func (sw *statusWriter) WriteHeader(statusCode int) {
+	if !sw.written {
+		sw.statusCode = statusCode
+		sw.written = true
+	}
+	sw.ResponseWriter.WriteHeader(statusCode)
+}
+
+func (sw *statusWriter) Write(b []byte) (int, error) {
+	if !sw.written {
+		sw.statusCode = http.StatusOK
+		sw.written = true
+	}
+
+	return sw.ResponseWriter.Write(b)
+}
+
+// RequestLoggerMiddleware creates a structured logging middleware using slog.
+func RequestLoggerMiddleware(logger *slog.Logger) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			start := time.Now()
+
+			// Wrap response writer to capture status
+			sw := &statusWriter{ResponseWriter: w, statusCode: http.StatusOK}
+
+			// Log request start
+			logger.Debug("HTTP request started",
+				"method", r.Method,
+				"path", r.URL.Path,
+				"remote_addr", r.RemoteAddr,
+				"user_agent", r.UserAgent(),
+			)
+
+			// Serve the request
+			next.ServeHTTP(sw, r)
+
+			// Log request completion
+			duration := time.Since(start)
+			logLevel := slog.LevelInfo
+
+			// Slow query threshold (1 second)
+			const slowQueryThreshold = 1 * time.Second
+
+			if sw.statusCode >= http.StatusInternalServerError {
+				logLevel = slog.LevelError
+			} else if sw.statusCode >= http.StatusBadRequest {
+				logLevel = slog.LevelWarn
+			} else if duration >= slowQueryThreshold {
+				logLevel = slog.LevelWarn
+			}
+
+			logger.Log(r.Context(), logLevel, "HTTP request completed",
+				"method", r.Method,
+				"path", r.URL.Path,
+				"status", sw.statusCode,
+				"duration_ms", duration.Milliseconds(),
+				"remote_addr", r.RemoteAddr,
+				"slow", duration >= slowQueryThreshold,
+			)
+		})
+	}
+}

internal/server/routes.go

@@ -0,0 +1,52 @@
+package server
+
+import (
+	"time"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+)
+
+// setupRoutes configures the HTTP routes
+func (s *Server) setupRoutes() {
+	r := chi.NewRouter()
+
+	// Middleware
+	r.Use(middleware.RequestID)
+	r.Use(middleware.RealIP)
+	r.Use(RequestLoggerMiddleware(s.logger.Logger)) // Structured request logging
+	r.Use(middleware.Recoverer)
+	const requestTimeout = 30 * time.Second // Increased from 8s for slow queries
+	r.Use(TimeoutMiddleware(requestTimeout, s.logger.Logger))
+	r.Use(JSONResponseMiddleware)
+
+	// Routes
+	r.Get("/", s.handleIndex())
+	r.Get("/status", s.handleStatusHTML())
+	r.Get("/status.json", JSONValidationMiddleware(s.handleStatusJSON()).ServeHTTP)
+	r.Get("/.well-known/healthcheck.json", JSONValidationMiddleware(s.handleHealthCheck()).ServeHTTP)
+
+	// AS and prefix detail pages
+	r.Get("/as/{asn}", s.handleASDetail())
+	r.Get("/prefix/{prefix}/{len}", s.handlePrefixDetail())
+	r.Get("/prefixlength/{length}", s.handlePrefixLength())
+	r.Get("/prefixlength6/{length}", s.handlePrefixLength6())
+
+	// IP info JSON endpoints (replaces old /ip redirect)
+	r.Route("/ip", func(r chi.Router) {
+		r.Use(JSONValidationMiddleware)
+		r.Get("/", s.handleIPInfo())       // Client IP
+		r.Get("/{addr}", s.handleIPInfo()) // Specified IP
+	})
+
+	// API routes
+	r.Route("/api/v1", func(r chi.Router) {
+		r.Use(JSONValidationMiddleware)
+		r.Get("/stats", s.handleStats())
+		r.Get("/ip/{ip}", s.handleIPLookup())
+		r.Get("/as/{asn}", s.handleASDetailJSON())
+		r.Get("/prefix/{prefix}/{len}", s.handlePrefixDetailJSON())
+	})
+
+	s.router = r
+}

internal/server/server.go

@@ -3,37 +3,46 @@ package server
 
 import (
 	"context"
-	"encoding/json"
-	"log/slog"
 	"net/http"
 	"os"
 	"time"
 
 	"git.eeqj.de/sneak/routewatch/internal/database"
-	"git.eeqj.de/sneak/routewatch/internal/routingtable"
+	"git.eeqj.de/sneak/routewatch/internal/logger"
 	"git.eeqj.de/sneak/routewatch/internal/streamer"
-	"git.eeqj.de/sneak/routewatch/internal/templates"
 	"github.com/go-chi/chi/v5"
-	"github.com/go-chi/chi/v5/middleware"
 )
 
+// ASNFetcherStats contains WHOIS fetcher statistics.
+type ASNFetcherStats struct {
+	SuccessesLastHour int
+	ErrorsLastHour    int
+	CurrentInterval   time.Duration
+	ConsecutiveFails  int
+}
+
+// ASNFetcher is an interface for queuing ASN WHOIS lookups.
+type ASNFetcher interface {
+	QueueImmediate(asn int)
+	GetStats() ASNFetcherStats
+}
+
 // Server provides HTTP endpoints for status monitoring
 type Server struct {
-	router       *chi.Mux
+	router     *chi.Mux
-	db           database.Store
+	db         database.Store
-	routingTable *routingtable.RoutingTable
+	streamer   *streamer.Streamer
-	streamer     *streamer.Streamer
+	logger     *logger.Logger
-	logger       *slog.Logger
+	srv        *http.Server
-	srv          *http.Server
+	asnFetcher ASNFetcher
 }
 
 // New creates a new HTTP server
-func New(db database.Store, rt *routingtable.RoutingTable, streamer *streamer.Streamer, logger *slog.Logger) *Server {
+func New(db database.Store, streamer *streamer.Streamer, logger *logger.Logger) *Server {
 	s := &Server{
-		db:           db,
+		db:       db,
-		routingTable: rt,
+		streamer: streamer,
-		streamer:     streamer,
+		logger:   logger,
-		logger:       logger,
 	}
 
 	s.setupRoutes()
@@ -41,32 +50,6 @@ func New(db database.Store, rt *routingtable.RoutingTable, streamer *streamer.St
 	return s
 }
 
-// setupRoutes configures the HTTP routes
-func (s *Server) setupRoutes() {
-	r := chi.NewRouter()
-
-	// Middleware
-	r.Use(middleware.RequestID)
-	r.Use(middleware.RealIP)
-	r.Use(middleware.Logger)
-	r.Use(middleware.Recoverer)
-	const requestTimeout = 2 * time.Second
-	r.Use(TimeoutMiddleware(requestTimeout))
-	r.Use(JSONResponseMiddleware)
-
-	// Routes
-	r.Get("/", s.handleRoot())
-	r.Get("/status", s.handleStatusHTML())
-	r.Get("/status.json", s.handleStatusJSON())
-
-	// API routes
-	r.Route("/api/v1", func(r chi.Router) {
-		r.Get("/stats", s.handleStats())
-	})
-
-	s.router = r
-}
-
 // Start starts the HTTP server
 func (s *Server) Start() error {
 	port := os.Getenv("PORT")
@@ -74,16 +57,27 @@ func (s *Server) Start() error {
 		port = "8080"
 	}
 
-	const readHeaderTimeout = 10 * time.Second
+	const (
+		readHeaderTimeout = 40 * time.Second
+		readTimeout       = 60 * time.Second
+		writeTimeout      = 60 * time.Second
+		idleTimeout       = 120 * time.Second
+	)
+
 	s.srv = &http.Server{
 		Addr:              ":" + port,
 		Handler:           s.router,
 		ReadHeaderTimeout: readHeaderTimeout,
+		ReadTimeout:       readTimeout,
+		WriteTimeout:      writeTimeout,
+		IdleTimeout:       idleTimeout,
 	}
 
-	s.logger.Info("Starting HTTP server", "port", port)
+	s.logger.Info("Starting HTTP server", "port", port, "addr", s.srv.Addr)
 
+	// Start in goroutine but log when actually listening
 	go func() {
+		s.logger.Info("HTTP server listening", "addr", s.srv.Addr)
 		if err := s.srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
 			s.logger.Error("HTTP server error", "error", err)
 		}
@@ -103,255 +97,7 @@ func (s *Server) Stop(ctx context.Context) error {
 	return s.srv.Shutdown(ctx)
 }
 
-// handleRoot returns a handler that redirects to /status
+// SetASNFetcher sets the ASN WHOIS fetcher for on-demand lookups.
-func (s *Server) handleRoot() http.HandlerFunc {
+func (s *Server) SetASNFetcher(fetcher ASNFetcher) {
-	return func(w http.ResponseWriter, r *http.Request) {
+	s.asnFetcher = fetcher
-		http.Redirect(w, r, "/status", http.StatusSeeOther)
-	}
-}
-
-// handleStatusJSON returns a handler that serves JSON statistics
-func (s *Server) handleStatusJSON() http.HandlerFunc {
-	// Stats represents the statistics response
-	type Stats struct {
-		Uptime            string  `json:"uptime"`
-		TotalMessages     uint64  `json:"total_messages"`
-		TotalBytes        uint64  `json:"total_bytes"`
-		MessagesPerSec    float64 `json:"messages_per_sec"`
-		MbitsPerSec       float64 `json:"mbits_per_sec"`
-		Connected         bool    `json:"connected"`
-		ASNs              int     `json:"asns"`
-		Prefixes          int     `json:"prefixes"`
-		IPv4Prefixes      int     `json:"ipv4_prefixes"`
-		IPv6Prefixes      int     `json:"ipv6_prefixes"`
-		Peerings          int     `json:"peerings"`
-		DatabaseSizeBytes int64   `json:"database_size_bytes"`
-		LiveRoutes        int     `json:"live_routes"`
-		IPv4Routes        int     `json:"ipv4_routes"`
-		IPv6Routes        int     `json:"ipv6_routes"`
-		IPv4UpdatesPerSec float64 `json:"ipv4_updates_per_sec"`
-		IPv6UpdatesPerSec float64 `json:"ipv6_updates_per_sec"`
-	}
-
-	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 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()
-		if metrics.ConnectedSince.IsZero() {
-			uptime = "0s"
-		}
-
-		const bitsPerMegabit = 1000000.0
-
-		// Get detailed routing table stats
-		rtStats := s.routingTable.GetDetailedStats()
-
-		stats := Stats{
-			Uptime:            uptime,
-			TotalMessages:     metrics.TotalMessages,
-			TotalBytes:        metrics.TotalBytes,
-			MessagesPerSec:    metrics.MessagesPerSec,
-			MbitsPerSec:       metrics.BitsPerSec / bitsPerMegabit,
-			Connected:         metrics.Connected,
-			ASNs:              dbStats.ASNs,
-			Prefixes:          dbStats.Prefixes,
-			IPv4Prefixes:      dbStats.IPv4Prefixes,
-			IPv6Prefixes:      dbStats.IPv6Prefixes,
-			Peerings:          dbStats.Peerings,
-			DatabaseSizeBytes: dbStats.FileSizeBytes,
-			LiveRoutes:        rtStats.TotalRoutes,
-			IPv4Routes:        rtStats.IPv4Routes,
-			IPv6Routes:        rtStats.IPv6Routes,
-			IPv4UpdatesPerSec: rtStats.IPv4UpdatesRate,
-			IPv6UpdatesPerSec: rtStats.IPv6UpdatesRate,
-		}
-
-		w.Header().Set("Content-Type", "application/json")
-		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)
-		}
-	}
-}
-
-// handleStats returns a handler that serves API v1 statistics
-func (s *Server) handleStats() http.HandlerFunc {
-	// StatsResponse represents the API statistics response
-	type StatsResponse struct {
-		Uptime            string  `json:"uptime"`
-		TotalMessages     uint64  `json:"total_messages"`
-		TotalBytes        uint64  `json:"total_bytes"`
-		MessagesPerSec    float64 `json:"messages_per_sec"`
-		MbitsPerSec       float64 `json:"mbits_per_sec"`
-		Connected         bool    `json:"connected"`
-		ASNs              int     `json:"asns"`
-		Prefixes          int     `json:"prefixes"`
-		IPv4Prefixes      int     `json:"ipv4_prefixes"`
-		IPv6Prefixes      int     `json:"ipv6_prefixes"`
-		Peerings          int     `json:"peerings"`
-		DatabaseSizeBytes int64   `json:"database_size_bytes"`
-		LiveRoutes        int     `json:"live_routes"`
-		IPv4Routes        int     `json:"ipv4_routes"`
-		IPv6Routes        int     `json:"ipv6_routes"`
-		IPv4UpdatesPerSec float64 `json:"ipv4_updates_per_sec"`
-		IPv6UpdatesPerSec float64 `json:"ipv6_updates_per_sec"`
-	}
-
-	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 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()
-		if metrics.ConnectedSince.IsZero() {
-			uptime = "0s"
-		}
-
-		const bitsPerMegabit = 1000000.0
-
-		// Get detailed routing table stats
-		rtStats := s.routingTable.GetDetailedStats()
-
-		stats := StatsResponse{
-			Uptime:            uptime,
-			TotalMessages:     metrics.TotalMessages,
-			TotalBytes:        metrics.TotalBytes,
-			MessagesPerSec:    metrics.MessagesPerSec,
-			MbitsPerSec:       metrics.BitsPerSec / bitsPerMegabit,
-			Connected:         metrics.Connected,
-			ASNs:              dbStats.ASNs,
-			Prefixes:          dbStats.Prefixes,
-			IPv4Prefixes:      dbStats.IPv4Prefixes,
-			IPv6Prefixes:      dbStats.IPv6Prefixes,
-			Peerings:          dbStats.Peerings,
-			DatabaseSizeBytes: dbStats.FileSizeBytes,
-			LiveRoutes:        rtStats.TotalRoutes,
-			IPv4Routes:        rtStats.IPv4Routes,
-			IPv6Routes:        rtStats.IPv6Routes,
-			IPv4UpdatesPerSec: rtStats.IPv4UpdatesRate,
-			IPv6UpdatesPerSec: rtStats.IPv6UpdatesRate,
-		}
-
-		w.Header().Set("Content-Type", "application/json")
-		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)
-		}
-	}
-}
-
-// handleStatusHTML returns a handler that serves the HTML status page
-func (s *Server) handleStatusHTML() http.HandlerFunc {
-	return func(w http.ResponseWriter, _ *http.Request) {
-		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-
-		tmpl := templates.StatusTemplate()
-		if err := tmpl.Execute(w, nil); err != nil {
-			s.logger.Error("Failed to render template", "error", err)
-			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-		}
-	}
 }

internal/snapshotter/snapshotter.go

@@ -1,270 +0,0 @@
-// Package snapshotter provides functionality for creating periodic and on-demand
-// snapshots of the routing table state.
-package snapshotter
-
-import (
-	"compress/gzip"
-	"context"
-	"encoding/json"
-	"fmt"
-	"log/slog"
-	"os"
-	"path/filepath"
-	"runtime"
-	"sync"
-	"time"
-
-	"git.eeqj.de/sneak/routewatch/internal/routingtable"
-)
-
-const (
-	snapshotInterval = 10 * time.Minute
-	snapshotFilename = "routewatch-snapshot.json.gz"
-	tempFileSuffix   = ".tmp"
-)
-
-// Snapshotter handles periodic and on-demand snapshots of the routing table
-type Snapshotter struct {
-	rt           *routingtable.RoutingTable
-	stateDir     string
-	logger       *slog.Logger
-	ctx          context.Context
-	cancel       context.CancelFunc
-	mu           sync.Mutex // Ensures only one snapshot runs at a time
-	wg           sync.WaitGroup
-	lastSnapshot time.Time
-}
-
-// New creates a new Snapshotter instance
-func New(rt *routingtable.RoutingTable, logger *slog.Logger) (*Snapshotter, error) {
-	stateDir, err := getStateDirectory()
-	if err != nil {
-		return nil, fmt.Errorf("failed to determine state directory: %w", err)
-	}
-
-	// Ensure state directory exists
-	const stateDirPerms = 0750
-	if err := os.MkdirAll(stateDir, stateDirPerms); err != nil {
-		return nil, fmt.Errorf("failed to create state directory: %w", err)
-	}
-
-	s := &Snapshotter{
-		rt:       rt,
-		stateDir: stateDir,
-		logger:   logger,
-	}
-
-	return s, nil
-}
-
-// Start begins the periodic snapshot process
-func (s *Snapshotter) Start(ctx context.Context) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	if s.ctx != nil {
-		// Already started
-		return
-	}
-
-	ctx, cancel := context.WithCancel(ctx)
-	s.ctx = ctx
-	s.cancel = cancel
-
-	// Start periodic snapshot goroutine
-	s.wg.Add(1)
-	go s.periodicSnapshot()
-}
-
-// getStateDirectory returns the appropriate state directory based on the OS
-func getStateDirectory() (string, error) {
-	switch runtime.GOOS {
-	case "darwin":
-		// macOS: Use ~/Library/Application Support/routewatch
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return "", err
-		}
-
-		return filepath.Join(home, "Library", "Application Support", "routewatch"), nil
-	case "linux", "freebsd", "openbsd", "netbsd":
-		// Unix-like: Use /var/lib/routewatch if running as root, otherwise use XDG_STATE_HOME
-		if os.Geteuid() == 0 {
-			return "/var/lib/routewatch", nil
-		}
-		// Check XDG_STATE_HOME first
-		if xdgState := os.Getenv("XDG_STATE_HOME"); xdgState != "" {
-			return filepath.Join(xdgState, "routewatch"), nil
-		}
-		// Fall back to ~/.local/state/routewatch
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return "", err
-		}
-
-		return filepath.Join(home, ".local", "state", "routewatch"), nil
-	default:
-		return "", fmt.Errorf("unsupported operating system: %s", runtime.GOOS)
-	}
-}
-
-// periodicSnapshot runs periodic snapshots
-func (s *Snapshotter) periodicSnapshot() {
-	defer s.wg.Done()
-
-	ticker := time.NewTicker(snapshotInterval)
-	defer ticker.Stop()
-
-	// Wait for the first interval before taking any snapshots
-	for {
-		select {
-		case <-s.ctx.Done():
-			return
-		case <-ticker.C:
-			if err := s.TakeSnapshot(); err != nil {
-				s.logger.Error("Failed to take periodic snapshot", "error", err)
-			}
-		}
-	}
-}
-
-// TakeSnapshot creates a snapshot of the current routing table state
-func (s *Snapshotter) TakeSnapshot() error {
-	// Ensure only one snapshot runs at a time
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	start := time.Now()
-	s.logger.Info("Starting routing table snapshot")
-
-	// Get a copy of all routes while holding read lock
-	copyStart := time.Now()
-	s.rt.RLock()
-	routes := s.rt.GetAllRoutesUnsafe() // We'll need to add this method
-	s.rt.RUnlock()
-
-	// Get stats separately to avoid deadlock
-	stats := s.rt.GetDetailedStats()
-
-	s.logger.Info("Copied routes from routing table",
-		"duration", time.Since(copyStart),
-		"route_count", len(routes))
-
-	// Create snapshot data structure
-	snapshot := struct {
-		Timestamp time.Time                  `json:"timestamp"`
-		Stats     routingtable.DetailedStats `json:"stats"`
-		Routes    []*routingtable.Route      `json:"routes"`
-	}{
-		Timestamp: time.Now().UTC(),
-		Stats:     stats,
-		Routes:    routes,
-	}
-
-	// Serialize to JSON
-	marshalStart := time.Now()
-	jsonData, err := json.Marshal(snapshot)
-	if err != nil {
-		return fmt.Errorf("failed to marshal snapshot: %w", err)
-	}
-	s.logger.Info("Marshaled snapshot to JSON",
-		"duration", time.Since(marshalStart),
-		"size_bytes", len(jsonData))
-
-	// Write compressed data to temporary file
-	tempPath := filepath.Join(s.stateDir, snapshotFilename+tempFileSuffix)
-	finalPath := filepath.Join(s.stateDir, snapshotFilename)
-
-	// Clean the paths to avoid any path traversal issues
-	tempPath = filepath.Clean(tempPath)
-	finalPath = filepath.Clean(finalPath)
-
-	tempFile, err := os.Create(tempPath)
-	if err != nil {
-		return fmt.Errorf("failed to create temporary file: %w", err)
-	}
-	defer func() {
-		_ = tempFile.Close()
-		// Clean up temp file if it still exists
-		_ = os.Remove(tempPath)
-	}()
-
-	// Create gzip writer
-	gzipWriter := gzip.NewWriter(tempFile)
-	gzipWriter.Comment = fmt.Sprintf("RouteWatch snapshot taken at %s", snapshot.Timestamp.Format(time.RFC3339))
-
-	// Write compressed data
-	writeStart := time.Now()
-	if _, err := gzipWriter.Write(jsonData); err != nil {
-		return fmt.Errorf("failed to write compressed data: %w", err)
-	}
-
-	// Close gzip writer to flush all data
-	if err := gzipWriter.Close(); err != nil {
-		return fmt.Errorf("failed to close gzip writer: %w", err)
-	}
-
-	// Sync to disk
-	if err := tempFile.Sync(); err != nil {
-		return fmt.Errorf("failed to sync temporary file: %w", err)
-	}
-
-	// Close temp file before rename
-	if err := tempFile.Close(); err != nil {
-		return fmt.Errorf("failed to close temporary file: %w", err)
-	}
-
-	// Atomically rename temp file to final location
-	if err := os.Rename(tempPath, finalPath); err != nil {
-		return fmt.Errorf("failed to rename temporary file: %w", err)
-	}
-	s.logger.Info("Wrote compressed snapshot to disk",
-		"duration", time.Since(writeStart))
-
-	duration := time.Since(start)
-	s.lastSnapshot = time.Now()
-
-	s.logger.Info("Routing table snapshot completed",
-		"duration", duration,
-		"routes", len(routes),
-		"ipv4_routes", stats.IPv4Routes,
-		"ipv6_routes", stats.IPv6Routes,
-		"size_bytes", len(jsonData),
-		"path", finalPath,
-	)
-
-	return nil
-}
-
-// Shutdown performs a final snapshot and cleans up resources
-func (s *Snapshotter) Shutdown() error {
-	s.logger.Info("Shutting down snapshotter")
-
-	// Cancel context to stop periodic snapshots
-	if s.cancel != nil {
-		s.cancel()
-	}
-
-	// Wait for periodic snapshot goroutine to finish
-	s.wg.Wait()
-
-	// Take final snapshot
-	if err := s.TakeSnapshot(); err != nil {
-		return fmt.Errorf("failed to take final snapshot: %w", err)
-	}
-
-	return nil
-}
-
-// GetLastSnapshotTime returns the time of the last successful snapshot
-func (s *Snapshotter) GetLastSnapshotTime() time.Time {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	return s.lastSnapshot
-}
-
-// GetSnapshotPath returns the path to the snapshot file
-func (s *Snapshotter) GetSnapshotPath() string {
-	return filepath.Join(s.stateDir, snapshotFilename)
-}

internal/streamer/streamer.go

@@ -4,54 +4,92 @@ package streamer
 
 import (
 	"bufio"
+	"compress/gzip"
 	"context"
 	"encoding/json"
 	"fmt"
-	"log/slog"
+	"io"
+	"math"
+	"math/rand"
 	"net/http"
-	"os"
 	"sync"
 	"sync/atomic"
 	"time"
 
+	"git.eeqj.de/sneak/routewatch/internal/logger"
 	"git.eeqj.de/sneak/routewatch/internal/metrics"
 	"git.eeqj.de/sneak/routewatch/internal/ristypes"
 )
 
+// countingReader wraps an io.Reader and counts bytes read
+type countingReader struct {
+	reader io.Reader
+	count  int64
+}
+
+// Read implements io.Reader and counts bytes
+func (c *countingReader) Read(p []byte) (int, error) {
+	n, err := c.reader.Read(p)
+	atomic.AddInt64(&c.count, int64(n))
+
+	return n, err
+}
+
+// Count returns the total bytes read
+func (c *countingReader) Count() int64 {
+	return atomic.LoadInt64(&c.count)
+}
+
+// Configuration constants for the RIS Live streamer.
 const (
-	risLiveURL            = "https://ris-live.ripe.net/v1/stream/?format=json"
+	risLiveURL = "https://ris-live.ripe.net/v1/stream/?format=json&" +
+		"client=https%3A%2F%2Fgit.eeqj.de%2Fsneak%2Froutewatch"
 	metricsWindowSize     = 60 // seconds for rolling average
 	metricsUpdateRate     = time.Second
+	minBackoffDelay       = 5 * time.Second
+	maxBackoffDelay       = 320 * time.Second
 	metricsLogInterval    = 10 * time.Second
 	bytesPerKB            = 1024
 	bytesPerMB            = 1024 * 1024
 	maxConcurrentHandlers = 800 // Maximum number of concurrent message handlers
+
+	// Backpressure constants
+	backpressureThreshold = 0.5 // Start dropping at 50% queue utilization
+	backpressureSlope     = 2.0 // Slope for linear drop probability increase
 )
 
-// MessageHandler is an interface for handling RIS messages
+// MessageHandler defines the interface for processing RIS messages.
+// Implementations must specify which message types they want to receive,
+// how to process messages, and their desired queue capacity.
 type MessageHandler interface {
-	// WantsMessage returns true if this handler wants to process messages of the given type
+	// WantsMessage returns true if this handler wants to process messages of the given type.
 	WantsMessage(messageType string) bool
 
-	// HandleMessage processes a RIS message
+	// HandleMessage processes a RIS message. This method is called from a dedicated
+	// goroutine for each handler, so implementations do not need to be goroutine-safe
+	// with respect to other handlers.
 	HandleMessage(msg *ristypes.RISMessage)
 
-	// QueueCapacity returns the desired queue capacity for this handler
+	// QueueCapacity returns the desired queue capacity for this handler.
-	// Handlers that process quickly can have larger queues
+	// Handlers that process quickly can have larger queues to buffer bursts.
+	// When the queue fills up, messages will be dropped according to the
+	// backpressure algorithm.
 	QueueCapacity() int
 }
 
-// RawMessageHandler is a callback for handling raw JSON lines from the stream
+// RawMessageHandler is a function type for processing raw JSON lines from the stream.
+// It receives the unmodified JSON line as a string before any parsing occurs.
 type RawMessageHandler func(line string)
 
 // handlerMetrics tracks performance metrics for a handler
 type handlerMetrics struct {
-	processedCount uint64        // Total messages processed
+	processedCount     uint64        // Total messages processed
-	droppedCount   uint64        // Total messages dropped
+	droppedCount       uint64        // Total messages dropped
-	totalTime      time.Duration // Total processing time (for average calculation)
+	totalTime          time.Duration // Total processing time (for average calculation)
-	minTime        time.Duration // Minimum processing time
+	minTime            time.Duration // Minimum processing time
-	maxTime        time.Duration // Maximum processing time
+	maxTime            time.Duration // Maximum processing time
-	mu             sync.Mutex    // Protects the metrics
+	queueHighWaterMark int           // Maximum queue length seen
+	mu                 sync.Mutex    // Protects the metrics
 }
 
 // handlerInfo wraps a handler with its queue and metrics
@@ -61,9 +99,12 @@ type handlerInfo struct {
 	metrics handlerMetrics
 }
 
-// Streamer handles streaming BGP updates from RIS Live
+// Streamer manages a connection to the RIPE RIS Live streaming API for receiving
+// real-time BGP UPDATE messages. It handles automatic reconnection with exponential
+// backoff, dispatches messages to registered handlers via per-handler queues, and
+// implements backpressure to prevent queue overflow during high traffic periods.
 type Streamer struct {
-	logger       *slog.Logger
+	logger       *logger.Logger
 	client       *http.Client
 	handlers     []*handlerInfo
 	rawHandler   RawMessageHandler
@@ -71,22 +112,36 @@ type Streamer struct {
 	cancel       context.CancelFunc
 	running      bool
 	metrics      *metrics.Tracker
-	totalDropped uint64 // Total dropped messages across all handlers
+	totalDropped uint64     // Total dropped messages across all handlers
+	random       *rand.Rand // Random number generator for backpressure drops
+	bgpPeers     map[string]bool // Track active BGP peers by peer IP
+	bgpPeersMu   sync.RWMutex    // Protects bgpPeers map
 }
 
-// New creates a new RIS streamer
+// New creates a new Streamer instance configured to connect to the RIS Live API.
-func New(logger *slog.Logger, metrics *metrics.Tracker) *Streamer {
+// The logger is used for structured logging of connection events and errors.
+// The metrics tracker is used to record message counts, bytes received, and connection status.
+func New(logger *logger.Logger, metrics *metrics.Tracker) *Streamer {
 	return &Streamer{
 		logger: logger,
 		client: &http.Client{
 			Timeout: 0, // No timeout for streaming
+			Transport: &http.Transport{
+				// Disable automatic gzip decompression so we can measure wire bytes
+				DisableCompression: true,
+			},
 		},
 		handlers: make([]*handlerInfo, 0),
 		metrics:  metrics,
+		//nolint:gosec // Non-cryptographic randomness is fine for backpressure
+		random:   rand.New(rand.NewSource(time.Now().UnixNano())),
+		bgpPeers: make(map[string]bool),
 	}
 }
 
-// RegisterHandler adds a callback for message processing
+// RegisterHandler adds a MessageHandler to receive parsed RIS messages.
+// Each handler gets its own dedicated queue and worker goroutine for processing.
+// If the streamer is already running, the handler's worker is started immediately.
 func (s *Streamer) RegisterHandler(handler MessageHandler) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -95,6 +150,9 @@ func (s *Streamer) RegisterHandler(handler MessageHandler) {
 	info := &handlerInfo{
 		handler: handler,
 		queue:   make(chan *ristypes.RISMessage, handler.QueueCapacity()),
+		metrics: handlerMetrics{
+			minTime: time.Duration(math.MaxInt64), // Initialize to max so first value sets the floor
+		},
 	}
 
 	s.handlers = append(s.handlers, info)
@@ -105,14 +163,19 @@ func (s *Streamer) RegisterHandler(handler MessageHandler) {
 	}
 }
 
-// RegisterRawHandler sets a callback for raw message lines
+// RegisterRawHandler sets a callback to receive raw JSON lines from the stream
+// before they are parsed. Only one raw handler can be registered at a time;
+// subsequent calls will replace the previous handler.
 func (s *Streamer) RegisterRawHandler(handler RawMessageHandler) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	s.rawHandler = handler
 }
 
-// Start begins streaming in a goroutine
+// Start begins streaming BGP updates from the RIS Live API in a background goroutine.
+// It starts worker goroutines for each registered handler and manages automatic
+// reconnection with exponential backoff on connection failures.
+// Returns an error if the streamer is already running.
 func (s *Streamer) Start() error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -131,9 +194,7 @@ func (s *Streamer) Start() error {
 	}
 
 	go func() {
-		if err := s.stream(ctx); err != nil {
+		s.streamWithReconnect(ctx)
-			s.logger.Error("Streaming error", "error", err)
-		}
 		s.mu.Lock()
 		s.running = false
 		s.mu.Unlock()
@@ -142,7 +203,9 @@ func (s *Streamer) Start() error {
 	return nil
 }
 
-// Stop halts the streaming
+// Stop halts the streaming connection and shuts down all handler workers.
+// It cancels the streaming context, closes all handler queues, and updates
+// the connection status in metrics. This method is safe to call multiple times.
 func (s *Streamer) Stop() {
 	s.mu.Lock()
 	if s.cancel != nil {
@@ -170,7 +233,7 @@ func (s *Streamer) runHandlerWorker(info *handlerInfo) {
 		info.metrics.totalTime += elapsed
 
 		// Update min time
-		if info.metrics.minTime == 0 || elapsed < info.metrics.minTime {
+		if elapsed < info.metrics.minTime {
 			info.metrics.minTime = elapsed
 		}
 
@@ -182,7 +245,8 @@ func (s *Streamer) runHandlerWorker(info *handlerInfo) {
 	}
 }
 
-// IsRunning returns whether the streamer is currently active
+// IsRunning reports whether the streamer is currently connected and processing messages.
+// This is safe to call concurrently from multiple goroutines.
 func (s *Streamer) IsRunning() bool {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
@@ -190,12 +254,78 @@ func (s *Streamer) IsRunning() bool {
 	return s.running
 }
 
-// GetMetrics returns current streaming metrics
+// GetMetrics returns the current streaming metrics including message counts,
+// bytes received, and throughput rates. The returned struct is a snapshot
+// of the current state and is safe to use without synchronization.
 func (s *Streamer) GetMetrics() metrics.StreamMetrics {
 	return s.metrics.GetStreamMetrics()
 }
 
-// GetDroppedMessages returns the total number of dropped messages
+// GetMetricsTracker returns the underlying metrics.Tracker instance for direct access
+// to metrics recording and retrieval functionality.
+func (s *Streamer) GetMetricsTracker() *metrics.Tracker {
+	return s.metrics
+}
+
+// HandlerStats contains performance metrics for a single message handler.
+// It includes queue utilization, message counts, and processing time statistics.
+type HandlerStats struct {
+	Name               string
+	QueueLength        int
+	QueueCapacity      int
+	QueueHighWaterMark int
+	ProcessedCount     uint64
+	DroppedCount       uint64
+	AvgProcessTime     time.Duration
+	MinProcessTime     time.Duration
+	MaxProcessTime     time.Duration
+}
+
+// GetHandlerStats returns a snapshot of performance statistics for all registered
+// handlers. The returned slice contains one HandlerStats entry per handler with
+// current queue depth, processed/dropped counts, and processing time statistics.
+func (s *Streamer) GetHandlerStats() []HandlerStats {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	stats := make([]HandlerStats, 0, len(s.handlers))
+
+	for _, info := range s.handlers {
+		info.metrics.mu.Lock()
+
+		hs := HandlerStats{
+			Name:               fmt.Sprintf("%T", info.handler),
+			QueueLength:        len(info.queue),
+			QueueCapacity:      cap(info.queue),
+			QueueHighWaterMark: info.metrics.queueHighWaterMark,
+			ProcessedCount:     info.metrics.processedCount,
+			DroppedCount:       info.metrics.droppedCount,
+			MinProcessTime:     info.metrics.minTime,
+			MaxProcessTime:     info.metrics.maxTime,
+		}
+
+		// Calculate average time
+		if info.metrics.processedCount > 0 {
+			processedCount := info.metrics.processedCount
+			const maxInt64 = 1<<63 - 1
+			if processedCount > maxInt64 {
+				processedCount = maxInt64
+			}
+			//nolint:gosec // processedCount is explicitly bounded above
+			hs.AvgProcessTime = info.metrics.totalTime / time.Duration(processedCount)
+		}
+
+		info.metrics.mu.Unlock()
+
+		stats = append(stats, hs)
+	}
+
+	return stats
+}
+
+// GetDroppedMessages returns the total number of messages dropped across all handlers
+// due to queue overflow or backpressure. This counter is monotonically increasing
+// and is safe to call concurrently.
 func (s *Streamer) GetDroppedMessages() uint64 {
 	return atomic.LoadUint64(&s.totalDropped)
 }
@@ -214,16 +344,18 @@ func (s *Streamer) logMetrics() {
 		uptime,
 		"total_messages",
 		metrics.TotalMessages,
-		"total_bytes",
+		"wire_bytes",
+		metrics.TotalWireBytes,
+		"wire_mb",
+		fmt.Sprintf("%.2f", float64(metrics.TotalWireBytes)/bytesPerMB),
+		"wire_mbps",
+		fmt.Sprintf("%.2f", metrics.WireBitsPerSec/bitsPerMegabit),
+		"decompressed_bytes",
 		metrics.TotalBytes,
-		"total_mb",
+		"decompressed_mb",
 		fmt.Sprintf("%.2f", float64(metrics.TotalBytes)/bytesPerMB),
 		"messages_per_sec",
 		fmt.Sprintf("%.2f", metrics.MessagesPerSec),
-		"bits_per_sec",
-		fmt.Sprintf("%.0f", metrics.BitsPerSec),
-		"mbps",
-		fmt.Sprintf("%.2f", metrics.BitsPerSec/bitsPerMegabit),
 		"total_dropped",
 		totalDropped,
 	)
@@ -264,12 +396,81 @@ func (s *Streamer) updateMetrics(messageBytes int) {
 	s.metrics.RecordMessage(int64(messageBytes))
 }
 
+// streamWithReconnect handles streaming with automatic reconnection and exponential backoff
+func (s *Streamer) streamWithReconnect(ctx context.Context) {
+	backoffDelay := minBackoffDelay
+	consecutiveFailures := 0
+
+	for {
+		select {
+		case <-ctx.Done():
+			s.logger.Info("Stream context cancelled, stopping reconnection attempts")
+
+			return
+		default:
+		}
+
+		// Attempt to stream
+		startTime := time.Now()
+		err := s.stream(ctx)
+		streamDuration := time.Since(startTime)
+
+		if err == nil {
+			// Clean exit (context cancelled)
+			return
+		}
+
+		// Log the error
+		s.logger.Error("Stream disconnected",
+			"error", err,
+			"consecutive_failures", consecutiveFailures+1,
+			"stream_duration", streamDuration)
+		s.metrics.SetConnected(false)
+
+		// Check if context is cancelled
+		if ctx.Err() != nil {
+			return
+		}
+
+		// If we streamed for more than 30 seconds, reset the backoff
+		// This indicates we had a successful connection that received data
+		if streamDuration > 30*time.Second {
+			s.logger.Info("Resetting backoff delay due to successful connection",
+				"stream_duration", streamDuration)
+			backoffDelay = minBackoffDelay
+			consecutiveFailures = 0
+		} else {
+			// Increment consecutive failures
+			consecutiveFailures++
+		}
+
+		// Wait with exponential backoff
+		s.logger.Info("Waiting before reconnection attempt",
+			"delay_seconds", backoffDelay.Seconds(),
+			"consecutive_failures", consecutiveFailures)
+
+		select {
+		case <-ctx.Done():
+			return
+		case <-time.After(backoffDelay):
+			// Double the backoff delay for next time, up to max
+			backoffDelay *= 2
+			if backoffDelay > maxBackoffDelay {
+				backoffDelay = maxBackoffDelay
+			}
+		}
+	}
+}
+
 func (s *Streamer) stream(ctx context.Context) error {
 	req, err := http.NewRequestWithContext(ctx, "GET", risLiveURL, nil)
 	if err != nil {
 		return fmt.Errorf("failed to create request: %w", err)
 	}
 
+	// Explicitly request gzip compression
+	req.Header.Set("Accept-Encoding", "gzip")
+
 	resp, err := s.client.Do(req)
 	if err != nil {
 		return fmt.Errorf("failed to connect to RIS Live: %w", err)
@@ -284,9 +485,28 @@ func (s *Streamer) stream(ctx context.Context) error {
 		return fmt.Errorf("unexpected status code: %d", resp.StatusCode)
 	}
 
-	s.logger.Info("Connected to RIS Live stream")
+	// Wrap body with counting reader to track actual wire bytes
+	wireCounter := &countingReader{reader: resp.Body}
+
+	// Check if response is gzip-compressed and decompress if needed
+	var reader io.Reader = wireCounter
+	if resp.Header.Get("Content-Encoding") == "gzip" {
+		gzReader, err := gzip.NewReader(wireCounter)
+		if err != nil {
+			return fmt.Errorf("failed to create gzip reader: %w", err)
+		}
+		defer func() { _ = gzReader.Close() }()
+		reader = gzReader
+		s.logger.Info("Connected to RIS Live stream", "compression", "gzip")
+	} else {
+		s.logger.Info("Connected to RIS Live stream", "compression", "none")
+	}
+
 	s.metrics.SetConnected(true)
 
+	// Track wire bytes for metrics updates
+	var lastWireBytes int64
+
 	// Start metrics logging goroutine
 	metricsTicker := time.NewTicker(metricsLogInterval)
 	defer metricsTicker.Stop()
@@ -302,7 +522,27 @@ func (s *Streamer) stream(ctx context.Context) error {
 		}
 	}()
 
-	scanner := bufio.NewScanner(resp.Body)
+	// Wire byte update ticker - update metrics with actual wire bytes periodically
+	wireUpdateTicker := time.NewTicker(time.Second)
+	defer wireUpdateTicker.Stop()
+
+	go func() {
+		for {
+			select {
+			case <-wireUpdateTicker.C:
+				currentBytes := wireCounter.Count()
+				delta := currentBytes - lastWireBytes
+				if delta > 0 {
+					s.metrics.RecordWireBytes(delta)
+					lastWireBytes = currentBytes
+				}
+			case <-ctx.Done():
+				return
+			}
+		}
+	}()
+
+	scanner := bufio.NewScanner(reader)
 
 	for scanner.Scan() {
 		select {
@@ -318,7 +558,7 @@ func (s *Streamer) stream(ctx context.Context) error {
 			continue
 		}
 
-		// Update metrics with message size
+		// Update metrics with decompressed message size
 		s.updateMetrics(len(line))
 
 		// Call raw handler if registered
@@ -334,10 +574,13 @@ func (s *Streamer) stream(ctx context.Context) error {
 		// Parse the message first
 		var wrapper ristypes.RISLiveMessage
 		if err := json.Unmarshal(line, &wrapper); err != nil {
-			// Output the raw line and panic on parse failure
+			// Log the error and return to trigger reconnection
-			fmt.Fprintf(os.Stderr, "Failed to parse JSON: %v\n", err)
+			s.logger.Error("Failed to parse JSON",
-			fmt.Fprintf(os.Stderr, "Raw line: %s\n", string(line))
+				"error", err,
-			panic(fmt.Sprintf("JSON parse error: %v", err))
+				"line", string(line),
+				"line_length", len(line))
+
+			return fmt.Errorf("JSON parse error: %w", err)
 		}
 
 		// Check if it's a ris_message wrapper
@@ -368,18 +611,32 @@ func (s *Streamer) stream(ctx context.Context) error {
 			// BGP keepalive messages - silently process
 			continue
 		case "OPEN":
-			// BGP open messages
+			// BGP open messages - track peer as active
+			s.bgpPeersMu.Lock()
+			s.bgpPeers[msg.Peer] = true
+			peerCount := len(s.bgpPeers)
+			s.bgpPeersMu.Unlock()
+			s.metrics.SetBGPPeerCount(peerCount)
+
 			s.logger.Info("BGP session opened",
 				"peer", msg.Peer,
 				"peer_asn", msg.PeerASN,
+				"total_peers", peerCount,
 			)
 
 			continue
 		case "NOTIFICATION":
-			// BGP notification messages (errors)
+			// BGP notification messages (session closed)
+			s.bgpPeersMu.Lock()
+			delete(s.bgpPeers, msg.Peer)
+			peerCount := len(s.bgpPeers)
+			s.bgpPeersMu.Unlock()
+			s.metrics.SetBGPPeerCount(peerCount)
+
 			s.logger.Warn("BGP notification",
 				"peer", msg.Peer,
 				"peer_asn", msg.PeerASN,
+				"total_peers", peerCount,
 			)
 
 			continue
@@ -387,32 +644,43 @@ func (s *Streamer) stream(ctx context.Context) error {
 			// Peer state changes - silently ignore
 			continue
 		default:
-			fmt.Fprintf(
+			s.logger.Warn("Unknown message type, skipping",
-				os.Stderr,
+				"type", msg.Type,
-				"UNKNOWN MESSAGE TYPE: %s\nRAW MESSAGE: %s\n",
-				msg.Type,
-				string(line),
-			)
-			panic(
-				fmt.Sprintf(
-					"Unknown RIS message type: %s",
-					msg.Type,
-				),
 			)
+
+			continue
 		}
 
 		// Dispatch to interested handlers
 		s.mu.RLock()
 		for _, info := range s.handlers {
-			if info.handler.WantsMessage(msg.Type) {
+			if !info.handler.WantsMessage(msg.Type) {
-				select {
+				continue
-				case info.queue <- &msg:
+			}
-					// Message queued successfully
+
-				default:
+			// Check if we should drop due to backpressure
-					// Queue is full, drop the message
+			if s.shouldDropForBackpressure(info) {
-					atomic.AddUint64(&info.metrics.droppedCount, 1)
+				atomic.AddUint64(&info.metrics.droppedCount, 1)
-					atomic.AddUint64(&s.totalDropped, 1)
+				atomic.AddUint64(&s.totalDropped, 1)
+
+				continue
+			}
+
+			// Try to queue the message
+			select {
+			case info.queue <- &msg:
+				// Message queued successfully
+				// Update high water mark if needed
+				queueLen := len(info.queue)
+				info.metrics.mu.Lock()
+				if queueLen > info.metrics.queueHighWaterMark {
+					info.metrics.queueHighWaterMark = queueLen
 				}
+				info.metrics.mu.Unlock()
+			default:
+				// Queue is full, drop the message
+				atomic.AddUint64(&info.metrics.droppedCount, 1)
+				atomic.AddUint64(&s.totalDropped, 1)
 			}
 		}
 		s.mu.RUnlock()
@@ -424,3 +692,25 @@ func (s *Streamer) stream(ctx context.Context) error {
 
 	return nil
 }
+
+// shouldDropForBackpressure determines if a message should be dropped based on queue utilization
+func (s *Streamer) shouldDropForBackpressure(info *handlerInfo) bool {
+	// Calculate queue utilization
+	queueLen := len(info.queue)
+	queueCap := cap(info.queue)
+	utilization := float64(queueLen) / float64(queueCap)
+
+	// No drops below threshold
+	if utilization < backpressureThreshold {
+		return false
+	}
+
+	// Calculate drop probability (0.0 at threshold, 1.0 at 100% full)
+	dropProbability := (utilization - backpressureThreshold) * backpressureSlope
+	if dropProbability > 1.0 {
+		dropProbability = 1.0
+	}
+
+	// Random drop based on probability
+	return s.random.Float64() < dropProbability
+}

internal/streamer/streamer_test.go

@@ -3,12 +3,12 @@ package streamer
 import (
 	"testing"
 
+	"git.eeqj.de/sneak/routewatch/internal/logger"
 	"git.eeqj.de/sneak/routewatch/internal/metrics"
-	"log/slog"
 )
 
 func TestNewStreamer(t *testing.T) {
-	logger := slog.Default()
+	logger := logger.New()
 	metricsTracker := metrics.New()
 	s := New(logger, metricsTracker)
 

internal/templates/as_detail.html

@@ -0,0 +1,346 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AS{{.ASN.ASN}} - {{.ASN.Handle}} - RouteWatch</title>
+    <style>
+        * {
+            box-sizing: border-box;
+        }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            margin: 0;
+            padding: 0;
+            background: #f5f5f5;
+            color: #333;
+        }
+
+        /* Navbar styles */
+        .navbar {
+            background: #2c3e50;
+            padding: 0 20px;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            height: 56px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .navbar-brand {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 18px;
+            font-weight: 600;
+        }
+        .navbar-brand a {
+            color: white;
+            text-decoration: none;
+        }
+        .navbar-brand a:hover {
+            color: #ecf0f1;
+        }
+        .navbar-brand .by {
+            font-weight: normal;
+            color: #95a5a6;
+            font-size: 14px;
+        }
+        .navbar-brand .author {
+            color: #3498db;
+            font-weight: normal;
+        }
+        .navbar-brand .author:hover {
+            text-decoration: underline;
+        }
+        .navbar-links {
+            display: flex;
+            gap: 20px;
+        }
+        .navbar-links a {
+            color: #ecf0f1;
+            text-decoration: none;
+            font-size: 14px;
+            padding: 8px 12px;
+            border-radius: 4px;
+            transition: background-color 0.2s;
+        }
+        .navbar-links a:hover {
+            background: rgba(255,255,255,0.1);
+        }
+        .navbar-links a.active {
+            background: rgba(255,255,255,0.15);
+        }
+
+        /* Main content */
+        .main-content {
+            padding: 20px;
+        }
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            background: white;
+            padding: 30px;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        h1 {
+            margin: 0 0 10px 0;
+            color: #2c3e50;
+        }
+        .subtitle {
+            color: #7f8c8d;
+            margin-bottom: 30px;
+        }
+        .info-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+            gap: 20px;
+            margin-bottom: 30px;
+        }
+        .info-card {
+            background: #f8f9fa;
+            padding: 20px;
+            border-radius: 6px;
+            border-left: 4px solid #3498db;
+        }
+        .info-label {
+            font-size: 14px;
+            color: #7f8c8d;
+            margin-bottom: 5px;
+        }
+        .info-value {
+            font-size: 24px;
+            font-weight: bold;
+            color: #2c3e50;
+        }
+        .prefix-section {
+            margin-top: 30px;
+        }
+        .prefix-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 20px;
+        }
+        .prefix-header h2 {
+            margin: 0;
+            color: #2c3e50;
+        }
+        .prefix-count {
+            background: #e74c3c;
+            color: white;
+            padding: 5px 12px;
+            border-radius: 20px;
+            font-size: 14px;
+            font-weight: bold;
+        }
+        .prefix-table {
+            width: 100%;
+            border-collapse: collapse;
+            background: white;
+            border: 1px solid #e0e0e0;
+            border-radius: 6px;
+            overflow: hidden;
+        }
+        .prefix-table th {
+            background: #34495e;
+            color: white;
+            padding: 12px;
+            text-align: left;
+            font-weight: 600;
+        }
+        .prefix-table td {
+            padding: 12px;
+            border-bottom: 1px solid #e0e0e0;
+        }
+        .prefix-table tr:hover {
+            background: #f8f9fa;
+        }
+        .prefix-table tr:last-child td {
+            border-bottom: none;
+        }
+        .prefix-link {
+            color: #3498db;
+            text-decoration: none;
+            font-family: monospace;
+        }
+        .prefix-link:hover {
+            text-decoration: underline;
+        }
+        .age {
+            color: #7f8c8d;
+            font-size: 14px;
+        }
+        .nav-link {
+            display: inline-block;
+            margin-bottom: 20px;
+            color: #3498db;
+            text-decoration: none;
+        }
+        .nav-link:hover {
+            text-decoration: underline;
+        }
+        .empty-state {
+            text-align: center;
+            padding: 40px;
+            color: #7f8c8d;
+        }
+        @media (max-width: 768px) {
+            .container {
+                padding: 20px;
+            }
+            .info-grid {
+                grid-template-columns: 1fr;
+            }
+        }
+    </style>
+</head>
+<body>
+    <nav class="navbar">
+        <div class="navbar-brand">
+            <a href="/">routewatch</a>
+            <span class="by">by</span>
+            <a href="https://sneak.berlin" class="author">@sneak</a>
+        </div>
+        <div class="navbar-links">
+            <a href="/">Home</a>
+            <a href="/status">Status</a>
+        </div>
+    </nav>
+
+    <main class="main-content">
+    <div class="container">
+        
+        <h1>AS{{.ASN.ASN}}{{if .ASN.Handle}} - {{.ASN.Handle}}{{end}}</h1>
+        {{if .ASN.Description}}
+        <p class="subtitle">{{.ASN.Description}}</p>
+        {{end}}
+        
+        <div class="info-grid">
+            <div class="info-card">
+                <div class="info-label">Total Prefixes</div>
+                <div class="info-value">{{.TotalCount}}</div>
+            </div>
+            <div class="info-card">
+                <div class="info-label">IPv4 Prefixes</div>
+                <div class="info-value">{{.IPv4Count}}</div>
+            </div>
+            <div class="info-card">
+                <div class="info-label">IPv6 Prefixes</div>
+                <div class="info-value">{{.IPv6Count}}</div>
+            </div>
+            <div class="info-card">
+                <div class="info-label">Peer ASNs</div>
+                <div class="info-value">{{.PeerCount}}</div>
+            </div>
+            <div class="info-card">
+                <div class="info-label">First Seen</div>
+                <div class="info-value">{{.ASN.FirstSeen.Format "2006-01-02"}}</div>
+            </div>
+        </div>
+
+        {{if .IPv4Prefixes}}
+        <div class="prefix-section">
+            <div class="prefix-header">
+                <h2>IPv4 Prefixes</h2>
+                <span class="prefix-count">{{.IPv4Count}}</span>
+            </div>
+            <table class="prefix-table">
+                <thead>
+                    <tr>
+                        <th>Prefix</th>
+                        <th>Mask Length</th>
+                        <th>Last Updated</th>
+                        <th>Age</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {{range .IPv4Prefixes}}
+                    <tr>
+                        <td><a href="{{.Prefix | prefixURL}}" class="prefix-link">{{.Prefix}}</a></td>
+                        <td>/{{.MaskLength}}</td>
+                        <td>{{.LastUpdated.Format "2006-01-02 15:04:05"}}</td>
+                        <td class="age">{{.LastUpdated | timeSince}}</td>
+                    </tr>
+                    {{end}}
+                </tbody>
+            </table>
+        </div>
+        {{end}}
+
+        {{if .IPv6Prefixes}}
+        <div class="prefix-section">
+            <div class="prefix-header">
+                <h2>IPv6 Prefixes</h2>
+                <span class="prefix-count">{{.IPv6Count}}</span>
+            </div>
+            <table class="prefix-table">
+                <thead>
+                    <tr>
+                        <th>Prefix</th>
+                        <th>Mask Length</th>
+                        <th>Last Updated</th>
+                        <th>Age</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {{range .IPv6Prefixes}}
+                    <tr>
+                        <td><a href="{{.Prefix | prefixURL}}" class="prefix-link">{{.Prefix}}</a></td>
+                        <td>/{{.MaskLength}}</td>
+                        <td>{{.LastUpdated.Format "2006-01-02 15:04:05"}}</td>
+                        <td class="age">{{.LastUpdated | timeSince}}</td>
+                    </tr>
+                    {{end}}
+                </tbody>
+            </table>
+        </div>
+        {{end}}
+
+        {{if eq .TotalCount 0}}
+        <div class="empty-state">
+            <p>No prefixes announced by this AS</p>
+        </div>
+        {{end}}
+
+        {{if .Peers}}
+        <div class="prefix-section">
+            <div class="prefix-header">
+                <h2>Peer ASNs</h2>
+                <span class="prefix-count">{{.PeerCount}}</span>
+            </div>
+            <table class="prefix-table">
+                <thead>
+                    <tr>
+                        <th>ASN</th>
+                        <th>Handle</th>
+                        <th>Description</th>
+                        <th>First Seen</th>
+                        <th>Last Seen</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {{range .Peers}}
+                    <tr>
+                        <td><a href="/as/{{.ASN}}" class="prefix-link">AS{{.ASN}}</a></td>
+                        <td>{{if .Handle}}{{.Handle}}{{else}}-{{end}}</td>
+                        <td>{{if .Description}}{{.Description}}{{else}}-{{end}}</td>
+                        <td>{{.FirstSeen.Format "2006-01-02"}}</td>
+                        <td>{{.LastSeen.Format "2006-01-02"}}</td>
+                    </tr>
+                    {{end}}
+                </tbody>
+            </table>
+        </div>
+        {{else}}
+        <div class="prefix-section">
+            <h2>Peer ASNs</h2>
+            <div class="empty-state">
+                <p>No peering relationships found for this AS</p>
+            </div>
+        </div>
+        {{end}}
+    </div>
+    </main>
+</body>
+</html>

internal/templates/index.html

@@ -0,0 +1,447 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>RouteWatch - BGP Route Monitor</title>
+    <style>
+        * {
+            box-sizing: border-box;
+        }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            margin: 0;
+            padding: 0;
+            background: #f5f5f5;
+            color: #333;
+        }
+
+        /* Navbar styles */
+        .navbar {
+            background: #2c3e50;
+            padding: 0 20px;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            height: 56px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .navbar-brand {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 18px;
+            font-weight: 600;
+        }
+        .navbar-brand a {
+            color: white;
+            text-decoration: none;
+        }
+        .navbar-brand a:hover {
+            color: #ecf0f1;
+        }
+        .navbar-brand .by {
+            font-weight: normal;
+            color: #95a5a6;
+            font-size: 14px;
+        }
+        .navbar-brand .author {
+            color: #3498db;
+            font-weight: normal;
+        }
+        .navbar-brand .author:hover {
+            text-decoration: underline;
+        }
+        .navbar-links {
+            display: flex;
+            gap: 20px;
+        }
+        .navbar-links a {
+            color: #ecf0f1;
+            text-decoration: none;
+            font-size: 14px;
+            padding: 8px 12px;
+            border-radius: 4px;
+            transition: background-color 0.2s;
+        }
+        .navbar-links a:hover {
+            background: rgba(255,255,255,0.1);
+        }
+        .navbar-links a.active {
+            background: rgba(255,255,255,0.15);
+        }
+
+        /* Main content */
+        .main-content {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 30px 20px;
+        }
+
+        /* Stats overview */
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 20px;
+            margin-bottom: 40px;
+        }
+        .stat-card {
+            background: white;
+            padding: 24px;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            text-align: center;
+        }
+        .stat-value {
+            font-size: 32px;
+            font-weight: bold;
+            color: #2c3e50;
+            margin-bottom: 8px;
+        }
+        .stat-label {
+            font-size: 14px;
+            color: #7f8c8d;
+            text-transform: uppercase;
+            letter-spacing: 0.5px;
+        }
+        .stat-card.connected .stat-value {
+            color: #27ae60;
+        }
+        .stat-card.disconnected .stat-value {
+            color: #e74c3c;
+        }
+
+        /* Search section */
+        .search-section {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(350px, 1fr));
+            gap: 24px;
+            margin-bottom: 40px;
+        }
+        .search-card {
+            background: white;
+            padding: 24px;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .search-card h2 {
+            margin: 0 0 16px 0;
+            font-size: 18px;
+            color: #2c3e50;
+        }
+        .search-input-group {
+            display: flex;
+            gap: 10px;
+        }
+        .search-input-group input {
+            flex: 1;
+            padding: 12px 16px;
+            border: 1px solid #ddd;
+            border-radius: 6px;
+            font-size: 14px;
+            outline: none;
+            transition: border-color 0.2s;
+        }
+        .search-input-group input:focus {
+            border-color: #3498db;
+        }
+        .search-input-group button {
+            padding: 12px 24px;
+            background: #3498db;
+            color: white;
+            border: none;
+            border-radius: 6px;
+            font-size: 14px;
+            cursor: pointer;
+            transition: background-color 0.2s;
+        }
+        .search-input-group button:hover {
+            background: #2980b9;
+        }
+        .search-input-group button:disabled {
+            background: #bdc3c7;
+            cursor: not-allowed;
+        }
+        .search-hint {
+            font-size: 12px;
+            color: #95a5a6;
+            margin-top: 8px;
+        }
+
+        /* IP Lookup result */
+        .ip-result {
+            margin-top: 16px;
+            display: none;
+        }
+        .ip-result.visible {
+            display: block;
+        }
+        .ip-result-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 8px;
+        }
+        .ip-result-header h3 {
+            margin: 0;
+            font-size: 14px;
+            color: #2c3e50;
+        }
+        .ip-result-header button {
+            background: none;
+            border: none;
+            color: #e74c3c;
+            cursor: pointer;
+            font-size: 12px;
+        }
+        .ip-result pre {
+            background: #2c3e50;
+            color: #ecf0f1;
+            padding: 16px;
+            border-radius: 6px;
+            overflow-x: auto;
+            font-size: 12px;
+            line-height: 1.5;
+            margin: 0;
+            max-height: 400px;
+            overflow-y: auto;
+        }
+        .ip-result .error {
+            background: #fee;
+            color: #c00;
+            padding: 12px;
+            border-radius: 6px;
+            font-size: 14px;
+        }
+        .ip-result .loading {
+            color: #7f8c8d;
+            font-style: italic;
+        }
+
+        /* Footer */
+        .footer {
+            margin-top: 40px;
+            padding: 20px;
+            background: white;
+            border-radius: 8px;
+            box-shadow: 0 -2px 10px rgba(0,0,0,0.05);
+            text-align: center;
+            color: #7f8c8d;
+            font-size: 14px;
+        }
+        .footer a {
+            color: #3498db;
+            text-decoration: none;
+        }
+        .footer a:hover {
+            text-decoration: underline;
+        }
+        .footer .separator {
+            margin: 0 10px;
+            color: #ddd;
+        }
+    </style>
+</head>
+<body>
+    <nav class="navbar">
+        <div class="navbar-brand">
+            <a href="/">routewatch</a>
+            <span class="by">by</span>
+            <a href="https://sneak.berlin" class="author">@sneak</a>
+        </div>
+        <div class="navbar-links">
+            <a href="/" class="active">Home</a>
+            <a href="/status">Status</a>
+        </div>
+    </nav>
+
+    <main class="main-content">
+        <div class="stats-grid">
+            <div class="stat-card" id="status-card">
+                <div class="stat-value" id="stat-status">-</div>
+                <div class="stat-label">Status</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="stat-routes">-</div>
+                <div class="stat-label">Live Routes</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="stat-asns">-</div>
+                <div class="stat-label">Autonomous Systems</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="stat-prefixes">-</div>
+                <div class="stat-label">Prefixes</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="stat-peers">-</div>
+                <div class="stat-label">BGP Peers</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="stat-updates">-</div>
+                <div class="stat-label">Updates/sec</div>
+            </div>
+        </div>
+
+        <div class="search-section">
+            <div class="search-card">
+                <h2>AS Number Lookup</h2>
+                <form id="asn-form" class="search-input-group">
+                    <input type="text" id="asn-input" placeholder="e.g., 15169 or AS15169" autocomplete="off">
+                    <button type="submit">Lookup</button>
+                </form>
+                <p class="search-hint">Enter an AS number to view its announced prefixes and peers</p>
+            </div>
+
+            <div class="search-card">
+                <h2>AS Name Search</h2>
+                <form id="asname-form" class="search-input-group">
+                    <input type="text" id="asname-input" placeholder="e.g., Google, Cloudflare" autocomplete="off">
+                    <button type="submit">Search</button>
+                </form>
+                <p class="search-hint">Search for autonomous systems by organization name</p>
+                <div id="asname-results"></div>
+            </div>
+
+            <div class="search-card">
+                <h2>IP Address Lookup</h2>
+                <form id="ip-form" class="search-input-group">
+                    <input type="text" id="ip-input" placeholder="e.g., 8.8.8.8 or 2001:4860:4860::8888" autocomplete="off">
+                    <button type="submit">Lookup</button>
+                </form>
+                <p class="search-hint">Get routing information for any IP address</p>
+                <div id="ip-result" class="ip-result">
+                    <div class="ip-result-header">
+                        <h3>Result</h3>
+                        <button type="button" id="ip-result-close">Clear</button>
+                    </div>
+                    <pre id="ip-result-content"></pre>
+                </div>
+            </div>
+        </div>
+    </main>
+
+    <footer class="footer">
+        <span><a href="{{appRepoURL}}">{{appName}}</a> by <a href="{{appAuthorURL}}">{{appAuthor}}</a></span>
+        <span class="separator">|</span>
+        <span>{{appLicense}}</span>
+        <span class="separator">|</span>
+        <span><a href="{{appGitCommitURL}}">{{appGitRevision}}</a></span>
+    </footer>
+
+    <script>
+        function formatNumber(num) {
+            if (num >= 1000000) {
+                return (num / 1000000).toFixed(1) + 'M';
+            } else if (num >= 1000) {
+                return (num / 1000).toFixed(1) + 'K';
+            }
+            return num.toLocaleString();
+        }
+
+        // Fetch and display stats
+        function updateStats() {
+            fetch('/api/v1/stats')
+                .then(response => response.json())
+                .then(response => {
+                    if (response.status !== 'ok') return;
+                    const data = response.data;
+
+                    const statusCard = document.getElementById('status-card');
+                    const statusEl = document.getElementById('stat-status');
+                    statusEl.textContent = data.connected ? 'Connected' : 'Disconnected';
+                    statusCard.className = 'stat-card ' + (data.connected ? 'connected' : 'disconnected');
+
+                    document.getElementById('stat-routes').textContent = formatNumber(data.live_routes);
+                    document.getElementById('stat-asns').textContent = formatNumber(data.asns);
+                    document.getElementById('stat-prefixes').textContent = formatNumber(data.prefixes);
+
+                    if (data.stream) {
+                        document.getElementById('stat-peers').textContent = formatNumber(data.stream.bgp_peer_count);
+                    }
+
+                    const totalUpdates = data.ipv4_updates_per_sec + data.ipv6_updates_per_sec;
+                    document.getElementById('stat-updates').textContent = totalUpdates.toFixed(1);
+                })
+                .catch(() => {
+                    document.getElementById('stat-status').textContent = 'Error';
+                    document.getElementById('status-card').className = 'stat-card disconnected';
+                });
+        }
+
+        // ASN lookup
+        document.getElementById('asn-form').addEventListener('submit', function(e) {
+            e.preventDefault();
+            let asn = document.getElementById('asn-input').value.trim();
+            // Remove 'AS' prefix if present
+            asn = asn.replace(/^AS/i, '');
+            if (asn && /^\d+$/.test(asn)) {
+                window.location.href = '/as/' + asn;
+            }
+        });
+
+        // AS name search
+        document.getElementById('asname-form').addEventListener('submit', function(e) {
+            e.preventDefault();
+            const query = document.getElementById('asname-input').value.trim();
+            if (!query) return;
+
+            const resultsDiv = document.getElementById('asname-results');
+            resultsDiv.innerHTML = '<p class="loading" style="color: #7f8c8d; margin-top: 12px;">Searching...</p>';
+
+            // Use a simple client-side search against the asinfo data
+            // For now, redirect to AS page if it looks like an ASN
+            if (/^\d+$/.test(query)) {
+                window.location.href = '/as/' + query;
+                return;
+            }
+
+            // Show a message that server-side search is coming
+            resultsDiv.innerHTML = '<p style="color: #7f8c8d; margin-top: 12px; font-size: 13px;">AS name search coming soon. For now, try an AS number.</p>';
+        });
+
+        // IP lookup
+        document.getElementById('ip-form').addEventListener('submit', function(e) {
+            e.preventDefault();
+            const ip = document.getElementById('ip-input').value.trim();
+            if (!ip) return;
+
+            const resultDiv = document.getElementById('ip-result');
+            const contentEl = document.getElementById('ip-result-content');
+
+            resultDiv.classList.add('visible');
+            contentEl.className = '';
+            contentEl.textContent = 'Loading...';
+            contentEl.classList.add('loading');
+
+            fetch('/ip/' + encodeURIComponent(ip))
+                .then(response => response.json())
+                .then(response => {
+                    contentEl.classList.remove('loading');
+                    if (response.status === 'error') {
+                        contentEl.className = 'error';
+                        contentEl.textContent = 'Error: ' + response.error.msg;
+                    } else {
+                        contentEl.className = '';
+                        contentEl.textContent = JSON.stringify(response.data, null, 2);
+                    }
+                })
+                .catch(error => {
+                    contentEl.classList.remove('loading');
+                    contentEl.className = 'error';
+                    contentEl.textContent = 'Error: ' + error.message;
+                });
+        });
+
+        // Close IP result
+        document.getElementById('ip-result-close').addEventListener('click', function() {
+            document.getElementById('ip-result').classList.remove('visible');
+            document.getElementById('ip-input').value = '';
+        });
+
+        // Initial load and refresh stats every 5 seconds
+        updateStats();
+        setInterval(updateStats, 5000);
+    </script>
+</body>
+</html>

internal/templates/prefix_detail.html

@@ -0,0 +1,334 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{{.Prefix}} - RouteWatch</title>
+    <style>
+        * {
+            box-sizing: border-box;
+        }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            margin: 0;
+            padding: 0;
+            background: #f5f5f5;
+            color: #333;
+        }
+
+        /* Navbar styles */
+        .navbar {
+            background: #2c3e50;
+            padding: 0 20px;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            height: 56px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .navbar-brand {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 18px;
+            font-weight: 600;
+        }
+        .navbar-brand a {
+            color: white;
+            text-decoration: none;
+        }
+        .navbar-brand a:hover {
+            color: #ecf0f1;
+        }
+        .navbar-brand .by {
+            font-weight: normal;
+            color: #95a5a6;
+            font-size: 14px;
+        }
+        .navbar-brand .author {
+            color: #3498db;
+            font-weight: normal;
+        }
+        .navbar-brand .author:hover {
+            text-decoration: underline;
+        }
+        .navbar-links {
+            display: flex;
+            gap: 20px;
+        }
+        .navbar-links a {
+            color: #ecf0f1;
+            text-decoration: none;
+            font-size: 14px;
+            padding: 8px 12px;
+            border-radius: 4px;
+            transition: background-color 0.2s;
+        }
+        .navbar-links a:hover {
+            background: rgba(255,255,255,0.1);
+        }
+        .navbar-links a.active {
+            background: rgba(255,255,255,0.15);
+        }
+
+        /* Main content */
+        .main-content {
+            padding: 20px;
+        }
+        .container {
+            width: 90%;
+            max-width: 1600px;
+            margin: 0 auto;
+            background: white;
+            padding: 30px;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        h1 {
+            margin: 0 0 10px 0;
+            color: #2c3e50;
+            font-family: monospace;
+            font-size: 28px;
+        }
+        .subtitle {
+            color: #7f8c8d;
+            margin-bottom: 30px;
+        }
+        .info-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 20px;
+            margin-bottom: 30px;
+        }
+        .info-card {
+            background: #f8f9fa;
+            padding: 20px;
+            border-radius: 6px;
+            border-left: 4px solid #3498db;
+        }
+        .info-label {
+            font-size: 14px;
+            color: #7f8c8d;
+            margin-bottom: 5px;
+        }
+        .info-value {
+            font-size: 24px;
+            font-weight: bold;
+            color: #2c3e50;
+        }
+        .routes-section {
+            margin-top: 30px;
+        }
+        .routes-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 20px;
+        }
+        .routes-header h2 {
+            margin: 0;
+            color: #2c3e50;
+        }
+        .route-count {
+            background: #e74c3c;
+            color: white;
+            padding: 5px 12px;
+            border-radius: 20px;
+            font-size: 14px;
+            font-weight: bold;
+        }
+        .route-table {
+            width: 100%;
+            border-collapse: collapse;
+            background: white;
+            border: 1px solid #e0e0e0;
+            border-radius: 6px;
+            overflow: hidden;
+        }
+        .route-table th {
+            background: #34495e;
+            color: white;
+            padding: 12px;
+            text-align: left;
+            font-weight: 600;
+        }
+        .route-table td {
+            padding: 12px;
+            border-bottom: 1px solid #e0e0e0;
+            white-space: nowrap;
+        }
+        .route-table tr:hover {
+            background: #f8f9fa;
+        }
+        .route-table tr:last-child td {
+            border-bottom: none;
+        }
+        .as-link {
+            color: #3498db;
+            text-decoration: none;
+        }
+        .as-link:hover {
+            text-decoration: underline;
+        }
+        .peer-ip {
+            font-family: monospace;
+            font-size: 14px;
+            color: #555;
+        }
+        .as-path {
+            font-family: monospace;
+            font-size: 13px;
+            color: #666;
+            max-width: 600px;
+            word-wrap: break-word;
+            white-space: normal !important;
+            line-height: 1.5;
+        }
+        .as-path .as-link {
+            font-weight: 600;
+        }
+        .age {
+            color: #7f8c8d;
+            font-size: 14px;
+        }
+        .nav-link {
+            display: inline-block;
+            margin-bottom: 20px;
+            color: #3498db;
+            text-decoration: none;
+        }
+        .nav-link:hover {
+            text-decoration: underline;
+        }
+        .origins-section {
+            margin-top: 30px;
+            background: #f8f9fa;
+            padding: 20px;
+            border-radius: 6px;
+        }
+        .origins-section h3 {
+            margin-top: 0;
+            color: #2c3e50;
+        }
+        .origin-list {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 10px;
+        }
+        .origin-item {
+            background: white;
+            padding: 10px 15px;
+            border-radius: 4px;
+            border: 1px solid #e0e0e0;
+        }
+        .empty-state {
+            text-align: center;
+            padding: 40px;
+            color: #7f8c8d;
+        }
+        @media (max-width: 768px) {
+            .container {
+                padding: 20px;
+            }
+            .info-grid {
+                grid-template-columns: 1fr;
+            }
+            .route-table {
+                font-size: 14px;
+            }
+            .as-path {
+                max-width: 100%;
+            }
+        }
+    </style>
+</head>
+<body>
+    <nav class="navbar">
+        <div class="navbar-brand">
+            <a href="/">routewatch</a>
+            <span class="by">by</span>
+            <a href="https://sneak.berlin" class="author">@sneak</a>
+        </div>
+        <div class="navbar-links">
+            <a href="/">Home</a>
+            <a href="/status">Status</a>
+        </div>
+    </nav>
+
+    <main class="main-content">
+    <div class="container">
+        <h1>{{.Prefix}}</h1>
+        <p class="subtitle">IPv{{.IPVersion}} Prefix{{if .MaskLength}} • /{{.MaskLength}}{{end}}</p>
+        
+        <div class="info-grid">
+            <div class="info-card">
+                <div class="info-label">Seen from Peers</div>
+                <div class="info-value">{{.PeerCount}}</div>
+            </div>
+            <div class="info-card">
+                <div class="info-label">Origin ASNs</div>
+                <div class="info-value">{{.OriginCount}}</div>
+            </div>
+            <div class="info-card">
+                <div class="info-label">IP Version</div>
+                <div class="info-value">IPv{{.IPVersion}}</div>
+            </div>
+        </div>
+
+        {{if .Origins}}
+        <div class="origins-section">
+            <h3>Origin ASNs</h3>
+            <div class="origin-list">
+                {{range .Origins}}
+                <div class="origin-item">
+                    <a href="/as/{{.ASN}}" class="as-link">AS{{.ASN}}</a>
+                    {{if .Handle}} ({{.Handle}}){{end}}
+                    <span style="color: #7f8c8d; margin-left: 10px;">{{.PeerCount}} peer{{if ne .PeerCount 1}}s{{end}}</span>
+                </div>
+                {{end}}
+            </div>
+        </div>
+        {{end}}
+
+        {{if .Routes}}
+        <div class="routes-section">
+            <div class="routes-header">
+                <h2>Route Details</h2>
+                <span class="route-count">{{.PeerCount}} route{{if ne .PeerCount 1}}s{{end}}</span>
+            </div>
+            <table class="route-table">
+                <thead>
+                    <tr>
+                        <th>Origin AS</th>
+                        <th>Peer IP</th>
+                        <th>AS Path</th>
+                        <th>Next Hop</th>
+                        <th>Last Updated</th>
+                        <th>Age</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {{range .Routes}}
+                    <tr>
+                        <td>
+                            <a href="/as/{{.OriginASN}}" class="as-link">AS{{.OriginASN}}</a>
+                        </td>
+                        <td class="peer-ip">{{.PeerIP}}</td>
+                        <td class="as-path">{{range $i, $as := .ASPathWithHandle}}{{if $i}} → {{end}}<a href="/as/{{$as.ASN}}" class="as-link">{{if $as.Handle}}{{$as.Handle}}{{else}}AS{{$as.ASN}}{{end}}</a>{{end}}</td>
+                        <td class="peer-ip">{{.NextHop}}</td>
+                        <td>{{.LastUpdated.Format "2006-01-02 15:04:05"}}</td>
+                        <td class="age">{{.LastUpdated | timeSince}}</td>
+                    </tr>
+                    {{end}}
+                </tbody>
+            </table>
+        </div>
+        {{else}}
+        <div class="empty-state">
+            <p>No routes found for this prefix</p>
+        </div>
+        {{end}}
+    </div>
+    </main>
+</body>
+</html>

internal/templates/prefix_length.html

@@ -0,0 +1,185 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Prefixes with /{{ .MaskLength }} - RouteWatch</title>
+    <style>
+        * {
+            box-sizing: border-box;
+        }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            margin: 0;
+            padding: 0;
+            background: #f5f5f5;
+        }
+
+        /* Navbar styles */
+        .navbar {
+            background: #2c3e50;
+            padding: 0 20px;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            height: 56px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .navbar-brand {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 18px;
+            font-weight: 600;
+        }
+        .navbar-brand a {
+            color: white;
+            text-decoration: none;
+        }
+        .navbar-brand a:hover {
+            color: #ecf0f1;
+        }
+        .navbar-brand .by {
+            font-weight: normal;
+            color: #95a5a6;
+            font-size: 14px;
+        }
+        .navbar-brand .author {
+            color: #3498db;
+            font-weight: normal;
+        }
+        .navbar-brand .author:hover {
+            text-decoration: underline;
+        }
+        .navbar-links {
+            display: flex;
+            gap: 20px;
+        }
+        .navbar-links a {
+            color: #ecf0f1;
+            text-decoration: none;
+            font-size: 14px;
+            padding: 8px 12px;
+            border-radius: 4px;
+            transition: background-color 0.2s;
+        }
+        .navbar-links a:hover {
+            background: rgba(255,255,255,0.1);
+        }
+        .navbar-links a.active {
+            background: rgba(255,255,255,0.15);
+        }
+
+        /* Main content */
+        .main-content {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 20px;
+        }
+        h1 {
+            color: #333;
+            margin-bottom: 10px;
+        }
+        .subtitle {
+            color: #666;
+            margin-bottom: 30px;
+        }
+        .info-card {
+            background: white;
+            padding: 20px;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            margin-bottom: 20px;
+        }
+        table {
+            width: 100%;
+            border-collapse: collapse;
+            background: white;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            border-radius: 8px;
+            overflow: hidden;
+        }
+        th {
+            background: #f8f9fa;
+            padding: 12px;
+            text-align: left;
+            font-weight: 600;
+            color: #333;
+            border-bottom: 2px solid #dee2e6;
+        }
+        td {
+            padding: 12px;
+            border-bottom: 1px solid #eee;
+        }
+        tr:last-child td {
+            border-bottom: none;
+        }
+        tr:hover {
+            background: #f8f9fa;
+        }
+        a {
+            color: #0066cc;
+            text-decoration: none;
+        }
+        a:hover {
+            text-decoration: underline;
+        }
+        .prefix-link {
+            font-family: 'SF Mono', Monaco, 'Cascadia Mono', 'Roboto Mono', Consolas, 'Courier New', monospace;
+        }
+        .as-link {
+            white-space: nowrap;
+        }
+        .age {
+            color: #666;
+            font-size: 0.9em;
+        }
+        .back-link {
+            display: inline-block;
+            margin-bottom: 20px;
+            color: #0066cc;
+        }
+    </style>
+</head>
+<body>
+    <nav class="navbar">
+        <div class="navbar-brand">
+            <a href="/">routewatch</a>
+            <span class="by">by</span>
+            <a href="https://sneak.berlin" class="author">@sneak</a>
+        </div>
+        <div class="navbar-links">
+            <a href="/">Home</a>
+            <a href="/status">Status</a>
+        </div>
+    </nav>
+
+    <main class="main-content">
+    <h1>IPv{{ .IPVersion }} Prefixes with /{{ .MaskLength }}</h1>
+    <p class="subtitle">Showing {{ .Count }} randomly selected prefixes</p>
+    
+    <table>
+        <thead>
+            <tr>
+                <th>Prefix</th>
+                <th>Age</th>
+                <th>Origin AS</th>
+            </tr>
+        </thead>
+        <tbody>
+            {{ range .Prefixes }}
+            <tr>
+                <td><a href="{{ .Prefix | prefixURL }}" class="prefix-link">{{ .Prefix }}</a></td>
+                <td class="age">{{ .Age }}</td>
+                <td>
+                    <a href="/as/{{ .OriginASN }}" class="as-link">
+                        AS{{ .OriginASN }}{{ if .OriginASDescription }} ({{ .OriginASDescription }}){{ end }}
+                    </a>
+                </td>
+            </tr>
+            {{ end }}
+        </tbody>
+    </table>
+    </main>
+</body>
+</html>

internal/templates/status.html

@@ -5,12 +5,76 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>RouteWatch Status</title>
     <style>
+        * {
+            box-sizing: border-box;
+        }
         body {
             font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            margin: 0;
+            padding: 0;
+            background: #f5f5f5;
+        }
+
+        /* Navbar styles */
+        .navbar {
+            background: #2c3e50;
+            padding: 0 20px;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            height: 56px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .navbar-brand {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 18px;
+            font-weight: 600;
+        }
+        .navbar-brand a {
+            color: white;
+            text-decoration: none;
+        }
+        .navbar-brand a:hover {
+            color: #ecf0f1;
+        }
+        .navbar-brand .by {
+            font-weight: normal;
+            color: #95a5a6;
+            font-size: 14px;
+        }
+        .navbar-brand .author {
+            color: #3498db;
+            font-weight: normal;
+        }
+        .navbar-brand .author:hover {
+            text-decoration: underline;
+        }
+        .navbar-links {
+            display: flex;
+            gap: 20px;
+        }
+        .navbar-links a {
+            color: #ecf0f1;
+            text-decoration: none;
+            font-size: 14px;
+            padding: 8px 12px;
+            border-radius: 4px;
+            transition: background-color 0.2s;
+        }
+        .navbar-links a:hover {
+            background: rgba(255,255,255,0.1);
+        }
+        .navbar-links a.active {
+            background: rgba(255,255,255,0.15);
+        }
+
+        /* Main content */
+        .main-content {
             max-width: 1200px;
             margin: 0 auto;
             padding: 20px;
-            background: #f5f5f5;
         }
         h1 {
             color: #333;
@@ -49,6 +113,16 @@
             font-family: 'SF Mono', Monaco, 'Cascadia Mono', 'Roboto Mono', Consolas, 'Courier New', monospace;
             color: #333;
         }
+        .metric-value.metric-link {
+            text-decoration: underline;
+            text-decoration-style: dashed;
+            text-underline-offset: 2px;
+            cursor: pointer;
+        }
+        .metric-value.metric-link:hover {
+            color: #0066cc;
+            text-decoration-style: solid;
+        }
         .connected {
             color: #22c55e;
         }
@@ -62,14 +136,47 @@
             border-radius: 4px;
             margin-top: 20px;
         }
+        .footer {
+            margin-top: 40px;
+            padding: 20px;
+            background: white;
+            border-radius: 8px;
+            box-shadow: 0 -2px 10px rgba(0,0,0,0.1);
+            text-align: center;
+            color: #666;
+            font-size: 14px;
+        }
+        .footer a {
+            color: #0066cc;
+            text-decoration: none;
+        }
+        .footer a:hover {
+            text-decoration: underline;
+        }
+        .footer .separator {
+            margin: 0 10px;
+            color: #ccc;
+        }
     </style>
 </head>
 <body>
-    <h1>RouteWatch Status</h1>
+    <nav class="navbar">
+        <div class="navbar-brand">
+            <a href="/">routewatch</a>
+            <span class="by">by</span>
+            <a href="https://sneak.berlin" class="author">@sneak</a>
+        </div>
+        <div class="navbar-links">
+            <a href="/">Home</a>
+            <a href="/status" class="active">Status</a>
+        </div>
+    </nav>
+
+    <main class="main-content">
     <div id="error" class="error" style="display: none;"></div>
     <div class="status-grid">
         <div class="status-card">
-            <h2>Connection Status</h2>
+            <h2>RouteWatch</h2>
             <div class="metric">
                 <span class="metric-label">Status</span>
                 <span class="metric-value" id="connected">-</span>
@@ -78,10 +185,34 @@
                 <span class="metric-label">Uptime</span>
                 <span class="metric-value" id="uptime">-</span>
             </div>
+            <div class="metric">
+                <span class="metric-label">Go Version</span>
+                <span class="metric-value" id="go_version">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Goroutines</span>
+                <span class="metric-value" id="goroutines">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Memory Usage</span>
+                <span class="metric-value" id="memory_usage">-</span>
+            </div>
         </div>
         
         <div class="status-card">
             <h2>Stream Statistics</h2>
+            <div class="metric">
+                <span class="metric-label">Connection Duration</span>
+                <span class="metric-value" id="connection_duration">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Reconnections</span>
+                <span class="metric-value" id="reconnect_count">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">BGP Peers</span>
+                <span class="metric-value" id="bgp_peer_count">-</span>
+            </div>
             <div class="metric">
                 <span class="metric-label">Total Messages</span>
                 <span class="metric-value" id="total_messages">-</span>
@@ -90,13 +221,49 @@
                 <span class="metric-label">Messages/sec</span>
                 <span class="metric-value" id="messages_per_sec">-</span>
             </div>
+            <div class="metric">
+                <span class="metric-label">Announcements</span>
+                <span class="metric-value" id="announcements">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Withdrawals</span>
+                <span class="metric-value" id="withdrawals">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Route Churn/sec</span>
+                <span class="metric-value" id="route_churn_per_sec">-</span>
+            </div>
             <div class="metric">
                 <span class="metric-label">Total Data</span>
-                <span class="metric-value" id="total_bytes">-</span>
+                <span class="metric-value" id="total_wire_bytes">-</span>
             </div>
             <div class="metric">
                 <span class="metric-label">Throughput</span>
-                <span class="metric-value" id="mbits_per_sec">-</span>
+                <span class="metric-value" id="wire_mbits_per_sec">-</span>
+            </div>
+        </div>
+
+        <div class="status-card">
+            <h2>GC Statistics</h2>
+            <div class="metric">
+                <span class="metric-label">GC Runs</span>
+                <span class="metric-value" id="gc_num">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Total Pause</span>
+                <span class="metric-value" id="gc_total_pause">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Last Pause</span>
+                <span class="metric-value" id="gc_last_pause">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Heap Alloc</span>
+                <span class="metric-value" id="gc_heap_alloc">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Heap Sys</span>
+                <span class="metric-value" id="gc_heap_sys">-</span>
             </div>
         </div>
         
@@ -110,18 +277,14 @@
                 <span class="metric-label">Total Prefixes</span>
                 <span class="metric-value" id="prefixes">-</span>
             </div>
-            <div class="metric">
-                <span class="metric-label">IPv4 Prefixes</span>
-                <span class="metric-value" id="ipv4_prefixes">-</span>
-            </div>
-            <div class="metric">
-                <span class="metric-label">IPv6 Prefixes</span>
-                <span class="metric-value" id="ipv6_prefixes">-</span>
-            </div>
             <div class="metric">
                 <span class="metric-label">Peerings</span>
                 <span class="metric-value" id="peerings">-</span>
             </div>
+            <div class="metric">
+                <span class="metric-label">Peers</span>
+                <span class="metric-value" id="peers">-</span>
+            </div>
             <div class="metric">
                 <span class="metric-label">Database Size</span>
                 <span class="metric-value" id="database_size">-</span>
@@ -134,6 +297,14 @@
                 <span class="metric-label">Live Routes</span>
                 <span class="metric-value" id="live_routes">-</span>
             </div>
+            <div class="metric">
+                <span class="metric-label">IPv4 Prefixes</span>
+                <span class="metric-value" id="ipv4_prefixes">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">IPv6 Prefixes</span>
+                <span class="metric-value" id="ipv6_prefixes">-</span>
+            </div>
             <div class="metric">
                 <span class="metric-label">IPv4 Routes</span>
                 <span class="metric-value" id="ipv4_routes">-</span>
@@ -150,7 +321,67 @@
                 <span class="metric-label">IPv6 Updates/sec</span>
                 <span class="metric-value" id="ipv6_updates_per_sec">-</span>
             </div>
+            <div class="metric">
+                <span class="metric-label">Oldest Route</span>
+                <span class="metric-value" id="oldest_route">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Newest Route</span>
+                <span class="metric-value" id="newest_route">-</span>
+            </div>
         </div>
+
+        <div class="status-card">
+            <h2>WHOIS Fetcher</h2>
+            <div class="metric">
+                <span class="metric-label">Fresh ASNs</span>
+                <span class="metric-value" id="whois_fresh">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Stale ASNs</span>
+                <span class="metric-value" id="whois_stale">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Never Fetched</span>
+                <span class="metric-value" id="whois_never">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Fresh %</span>
+                <span class="metric-value" id="whois_percent">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Successes (1h)</span>
+                <span class="metric-value" id="whois_successes">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Errors (1h)</span>
+                <span class="metric-value" id="whois_errors">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Current Interval</span>
+                <span class="metric-value" id="whois_interval">-</span>
+            </div>
+        </div>
+    </div>
+
+    <div class="status-grid">
+        <div class="status-card">
+            <h2>IPv4 Prefix Distribution</h2>
+            <div id="ipv4-prefix-distribution">
+                <!-- Will be populated dynamically -->
+            </div>
+        </div>
+        
+        <div class="status-card">
+            <h2>IPv6 Prefix Distribution</h2>
+            <div id="ipv6-prefix-distribution">
+                <!-- Will be populated dynamically -->
+            </div>
+        </div>
+    </div>
+    
+    <div id="handler-stats-container" class="status-grid">
+        <!-- Handler stats will be dynamically added here -->
     </div>
     
     <script>
@@ -166,6 +397,158 @@
             return num.toLocaleString();
         }
         
+        function formatProcessingTime(ms) {
+            if (ms < 0.001) {
+                return (ms * 1000).toFixed(0) + ' µs';
+            } else if (ms < 0.01) {
+                return (ms * 1000).toFixed(1) + ' µs';
+            } else if (ms < 1) {
+                return ms.toFixed(3) + ' ms';
+            } else {
+                return ms.toFixed(2) + ' ms';
+            }
+        }
+
+        function formatRelativeTime(isoString) {
+            if (!isoString) return '-';
+            const date = new Date(isoString);
+            const now = new Date();
+            const diffMs = now - date;
+            const diffSec = Math.floor(diffMs / 1000);
+            const diffMin = Math.floor(diffSec / 60);
+            const diffHour = Math.floor(diffMin / 60);
+            const diffDay = Math.floor(diffHour / 24);
+
+            if (diffSec < 60) return diffSec + 's ago';
+            if (diffMin < 60) return diffMin + 'm ago';
+            if (diffHour < 24) return diffHour + 'h ' + (diffMin % 60) + 'm ago';
+            return diffDay + 'd ' + (diffHour % 24) + 'h ago';
+        }
+
+        function updatePrefixDistribution(elementId, distribution) {
+            const container = document.getElementById(elementId);
+            container.innerHTML = '';
+            
+            if (!distribution || distribution.length === 0) {
+                container.innerHTML = '<div class="metric"><span class="metric-label">No data</span></div>';
+                return;
+            }
+            
+            // Sort by mask length
+            distribution.sort((a, b) => a.mask_length - b.mask_length);
+            
+            // Determine the URL path based on whether this is IPv4 or IPv6
+            const isIPv6 = elementId.includes('ipv6');
+            const urlPath = isIPv6 ? '/prefixlength6/' : '/prefixlength/';
+            
+            distribution.forEach(item => {
+                const metric = document.createElement('div');
+                metric.className = 'metric';
+                metric.innerHTML = `
+                    <span class="metric-label">/${item.mask_length}</span>
+                    <a href="${urlPath}${item.mask_length}" class="metric-value metric-link">${formatNumber(item.count)}</a>
+                `;
+                container.appendChild(metric);
+            });
+        }
+        
+        function updateHandlerStats(handlerStats) {
+            const container = document.getElementById('handler-stats-container');
+            container.innerHTML = '';
+            
+            handlerStats.forEach(handler => {
+                const card = document.createElement('div');
+                card.className = 'status-card';
+                
+                // Extract handler name (remove package prefix)
+                const handlerName = handler.name.split('.').pop();
+                
+                card.innerHTML = `
+                    <h2>${handlerName}</h2>
+                    <div class="metric">
+                        <span class="metric-label">Queue</span>
+                        <span class="metric-value">${handler.queue_length}/${handler.queue_capacity}</span>
+                    </div>
+                    <div class="metric">
+                        <span class="metric-label">High Water Mark</span>
+                        <span class="metric-value">${handler.queue_high_water_mark}/${handler.queue_capacity} (${Math.round(handler.queue_high_water_mark * 100 / handler.queue_capacity)}%)</span>
+                    </div>
+                    <div class="metric">
+                        <span class="metric-label">Processed</span>
+                        <span class="metric-value">${formatNumber(handler.processed_count)}</span>
+                    </div>
+                    <div class="metric">
+                        <span class="metric-label">Dropped</span>
+                        <span class="metric-value ${handler.dropped_count > 0 ? 'disconnected' : ''}">${formatNumber(handler.dropped_count)}</span>
+                    </div>
+                    <div class="metric">
+                        <span class="metric-label">Avg Time</span>
+                        <span class="metric-value">${formatProcessingTime(handler.avg_process_time_ms)}</span>
+                    </div>
+                    <div class="metric">
+                        <span class="metric-label">Min/Max Time</span>
+                        <span class="metric-value">${formatProcessingTime(handler.min_process_time_ms)} / ${formatProcessingTime(handler.max_process_time_ms)}</span>
+                    </div>
+                `;
+                
+                container.appendChild(card);
+            });
+        }
+        
+        function resetAllFields() {
+            // Reset all metric fields to '-'
+            document.getElementById('connected').textContent = '-';
+            document.getElementById('connected').className = 'metric-value';
+            document.getElementById('uptime').textContent = '-';
+            document.getElementById('go_version').textContent = '-';
+            document.getElementById('goroutines').textContent = '-';
+            document.getElementById('memory_usage').textContent = '-';
+            document.getElementById('connection_duration').textContent = '-';
+            document.getElementById('reconnect_count').textContent = '-';
+            document.getElementById('bgp_peer_count').textContent = '-';
+            document.getElementById('total_messages').textContent = '-';
+            document.getElementById('messages_per_sec').textContent = '-';
+            document.getElementById('announcements').textContent = '-';
+            document.getElementById('withdrawals').textContent = '-';
+            document.getElementById('route_churn_per_sec').textContent = '-';
+            document.getElementById('total_wire_bytes').textContent = '-';
+            document.getElementById('wire_mbits_per_sec').textContent = '-';
+            document.getElementById('gc_num').textContent = '-';
+            document.getElementById('gc_total_pause').textContent = '-';
+            document.getElementById('gc_last_pause').textContent = '-';
+            document.getElementById('gc_heap_alloc').textContent = '-';
+            document.getElementById('gc_heap_sys').textContent = '-';
+            document.getElementById('asns').textContent = '-';
+            document.getElementById('prefixes').textContent = '-';
+            document.getElementById('ipv4_prefixes').textContent = '-';
+            document.getElementById('ipv6_prefixes').textContent = '-';
+            document.getElementById('peerings').textContent = '-';
+            document.getElementById('peers').textContent = '-';
+            document.getElementById('database_size').textContent = '-';
+            document.getElementById('live_routes').textContent = '-';
+            document.getElementById('ipv4_routes').textContent = '-';
+            document.getElementById('ipv6_routes').textContent = '-';
+            document.getElementById('ipv4_updates_per_sec').textContent = '-';
+            document.getElementById('ipv6_updates_per_sec').textContent = '-';
+            document.getElementById('oldest_route').textContent = '-';
+            document.getElementById('newest_route').textContent = '-';
+            document.getElementById('whois_fresh').textContent = '-';
+            document.getElementById('whois_stale').textContent = '-';
+            document.getElementById('whois_never').textContent = '-';
+            document.getElementById('whois_percent').textContent = '-';
+            document.getElementById('whois_successes').textContent = '-';
+            document.getElementById('whois_errors').textContent = '-';
+            document.getElementById('whois_errors').className = 'metric-value';
+            document.getElementById('whois_interval').textContent = '-';
+
+            // Clear handler stats
+            document.getElementById('handler-stats-container').innerHTML = '';
+            
+            // Clear prefix distributions
+            document.getElementById('ipv4-prefix-distribution').innerHTML = '<div class="metric"><span class="metric-label">No data</span></div>';
+            document.getElementById('ipv6-prefix-distribution').innerHTML = '<div class="metric"><span class="metric-label">No data</span></div>';
+        }
+        
         function updateStatus() {
             fetch('/api/v1/stats')
                 .then(response => response.json())
@@ -174,6 +557,7 @@
                     if (response.status === 'error') {
                         document.getElementById('error').textContent = 'Error: ' + response.error.msg;
                         document.getElementById('error').style.display = 'block';
+                        resetAllFields();
                         return;
                     }
                     
@@ -187,21 +571,66 @@
                     
                     // Update all metrics
                     document.getElementById('uptime').textContent = data.uptime;
+                    document.getElementById('go_version').textContent = data.go_version;
+                    document.getElementById('goroutines').textContent = formatNumber(data.goroutines);
+                    document.getElementById('memory_usage').textContent = data.memory_usage;
+                    document.getElementById('connection_duration').textContent = data.connection_duration;
+                    document.getElementById('reconnect_count').textContent = formatNumber(data.reconnect_count);
                     document.getElementById('total_messages').textContent = formatNumber(data.total_messages);
                     document.getElementById('messages_per_sec').textContent = data.messages_per_sec.toFixed(1);
-                    document.getElementById('total_bytes').textContent = formatBytes(data.total_bytes);
+                    document.getElementById('total_wire_bytes').textContent = formatBytes(data.total_wire_bytes);
-                    document.getElementById('mbits_per_sec').textContent = data.mbits_per_sec.toFixed(2) + ' Mbps';
+                    document.getElementById('wire_mbits_per_sec').textContent = data.wire_mbits_per_sec.toFixed(2) + ' Mbps';
                     document.getElementById('asns').textContent = formatNumber(data.asns);
                     document.getElementById('prefixes').textContent = formatNumber(data.prefixes);
                     document.getElementById('ipv4_prefixes').textContent = formatNumber(data.ipv4_prefixes);
                     document.getElementById('ipv6_prefixes').textContent = formatNumber(data.ipv6_prefixes);
                     document.getElementById('peerings').textContent = formatNumber(data.peerings);
+                    document.getElementById('peers').textContent = formatNumber(data.peers);
                     document.getElementById('database_size').textContent = formatBytes(data.database_size_bytes);
                     document.getElementById('live_routes').textContent = formatNumber(data.live_routes);
                     document.getElementById('ipv4_routes').textContent = formatNumber(data.ipv4_routes);
                     document.getElementById('ipv6_routes').textContent = formatNumber(data.ipv6_routes);
                     document.getElementById('ipv4_updates_per_sec').textContent = data.ipv4_updates_per_sec.toFixed(1);
                     document.getElementById('ipv6_updates_per_sec').textContent = data.ipv6_updates_per_sec.toFixed(1);
+                    document.getElementById('oldest_route').textContent = formatRelativeTime(data.oldest_route);
+                    document.getElementById('newest_route').textContent = formatRelativeTime(data.newest_route);
+
+                    // Update stream stats
+                    if (data.stream) {
+                        document.getElementById('bgp_peer_count').textContent = formatNumber(data.stream.bgp_peer_count);
+                        document.getElementById('announcements').textContent = formatNumber(data.stream.announcements);
+                        document.getElementById('withdrawals').textContent = formatNumber(data.stream.withdrawals);
+                        document.getElementById('route_churn_per_sec').textContent = data.stream.route_churn_per_sec.toFixed(1);
+                    }
+
+                    // Update GC stats
+                    if (data.gc) {
+                        document.getElementById('gc_num').textContent = formatNumber(data.gc.num_gc);
+                        document.getElementById('gc_total_pause').textContent = data.gc.total_pause_ms + ' ms';
+                        document.getElementById('gc_last_pause').textContent = data.gc.last_pause_ms.toFixed(3) + ' ms';
+                        document.getElementById('gc_heap_alloc').textContent = formatBytes(data.gc.heap_alloc_bytes);
+                        document.getElementById('gc_heap_sys').textContent = formatBytes(data.gc.heap_sys_bytes);
+                    }
+
+                    // Update WHOIS stats
+                    if (data.whois_stats) {
+                        document.getElementById('whois_fresh').textContent = formatNumber(data.whois_stats.fresh_asns);
+                        document.getElementById('whois_stale').textContent = formatNumber(data.whois_stats.stale_asns);
+                        document.getElementById('whois_never').textContent = formatNumber(data.whois_stats.never_fetched);
+                        document.getElementById('whois_percent').textContent = data.whois_stats.fresh_percent.toFixed(1) + '%';
+                        document.getElementById('whois_successes').textContent = formatNumber(data.whois_stats.successes_last_hour);
+                        const errorsEl = document.getElementById('whois_errors');
+                        errorsEl.textContent = formatNumber(data.whois_stats.errors_last_hour);
+                        errorsEl.className = 'metric-value' + (data.whois_stats.errors_last_hour > 0 ? ' disconnected' : '');
+                        document.getElementById('whois_interval').textContent = data.whois_stats.current_interval;
+                    }
+
+                    // Update handler stats
+                    updateHandlerStats(data.handler_stats || []);
+                    
+                    // Update prefix distribution
+                    updatePrefixDistribution('ipv4-prefix-distribution', data.ipv4_prefix_distribution);
+                    updatePrefixDistribution('ipv6-prefix-distribution', data.ipv6_prefix_distribution);
                     
                     // Clear any errors
                     document.getElementById('error').style.display = 'none';
@@ -209,12 +638,22 @@
                 .catch(error => {
                     document.getElementById('error').textContent = 'Error fetching status: ' + error;
                     document.getElementById('error').style.display = 'block';
+                    resetAllFields();
                 });
         }
         
-        // Update immediately and then every 500ms
+        // Update immediately and then every 2 seconds
         updateStatus();
-        setInterval(updateStatus, 500);
+        setInterval(updateStatus, 2000);
     </script>
+    </main>
+
+    <footer class="footer">
+        <span><a href="{{appRepoURL}}">{{appName}}</a> by <a href="{{appAuthorURL}}">{{appAuthor}}</a></span>
+        <span class="separator">|</span>
+        <span>{{appLicense}}</span>
+        <span class="separator">|</span>
+        <span><a href="{{appGitCommitURL}}">{{appGitRevision}}</a></span>
+    </footer>
 </body>
 </html>

internal/templates/templates.go

@@ -4,15 +4,41 @@ package templates
 import (
 	_ "embed"
 	"html/template"
+	"net/url"
+	"strings"
 	"sync"
+	"time"
+
+	"git.eeqj.de/sneak/routewatch/internal/version"
 )
 
+//go:embed index.html
+var indexHTML string
+
 //go:embed status.html
 var statusHTML string
 
+//go:embed as_detail.html
+var asDetailHTML string
+
+//go:embed prefix_detail.html
+var prefixDetailHTML string
+
+//go:embed prefix_length.html
+var prefixLengthHTML string
+
 // Templates contains all parsed templates
 type Templates struct {
+	// Index is the template for the home page
+	Index *template.Template
+	// Status is the template for the main status page
 	Status *template.Template
+	// ASDetail is the template for displaying AS (Autonomous System) details
+	ASDetail *template.Template
+	// PrefixDetail is the template for displaying prefix details
+	PrefixDetail *template.Template
+	// PrefixLength is the template for displaying prefixes by length
+	PrefixLength *template.Template
 }
 
 var (
@@ -22,17 +48,108 @@ var (
 	once sync.Once
 )
 
+const (
+	hoursPerDay        = 24
+	daysPerMonth       = 30
+	cidrPartCount      = 2 // A CIDR has two parts: prefix and length
+)
+
+// timeSince returns a human-readable duration since the given time
+func timeSince(t time.Time) string {
+	duration := time.Since(t)
+	if duration < time.Minute {
+		return "just now"
+	}
+	if duration < time.Hour {
+		minutes := int(duration.Minutes())
+		if minutes == 1 {
+			return "1 minute ago"
+		}
+
+		return duration.Truncate(time.Minute).String() + " ago"
+	}
+	if duration < hoursPerDay*time.Hour {
+		hours := int(duration.Hours())
+		if hours == 1 {
+			return "1 hour ago"
+		}
+
+		return duration.Truncate(time.Hour).String() + " ago"
+	}
+	days := int(duration.Hours() / hoursPerDay)
+	if days == 1 {
+		return "1 day ago"
+	}
+	if days < daysPerMonth {
+		return duration.Truncate(hoursPerDay*time.Hour).String() + " ago"
+	}
+
+	return t.Format("2006-01-02")
+}
+
+// prefixURL generates a URL path for a prefix in CIDR notation.
+// Takes a prefix like "192.168.1.0/24" and returns "/prefix/192.168.1.0/24"
+// with the prefix part URL-encoded to handle IPv6 colons.
+func prefixURL(cidr string) string {
+	// Split CIDR into prefix and length
+	parts := strings.SplitN(cidr, "/", cidrPartCount)
+	if len(parts) != cidrPartCount {
+		// Fallback if no slash found
+		return "/prefix/" + url.PathEscape(cidr) + "/0"
+	}
+
+	return "/prefix/" + url.PathEscape(parts[0]) + "/" + parts[1]
+}
+
 // initTemplates parses all embedded templates
 func initTemplates() {
 	var err error
 
 	defaultTemplates = &Templates{}
 
+	// Create common template functions
+	funcs := template.FuncMap{
+		"timeSince":        timeSince,
+		"urlEncode":        url.QueryEscape,
+		"prefixURL":        prefixURL,
+		"appName":          func() string { return version.Name },
+		"appAuthor":        func() string { return version.Author },
+		"appAuthorURL":     func() string { return version.AuthorURL },
+		"appLicense":       func() string { return version.License },
+		"appRepoURL":       func() string { return version.RepoURL },
+		"appGitRevision":   func() string { return version.GitRevisionShort },
+		"appGitCommitURL":  func() string { return version.CommitURL() },
+	}
+
+	// Parse index template
+	defaultTemplates.Index, err = template.New("index").Funcs(funcs).Parse(indexHTML)
+	if err != nil {
+		panic("failed to parse index template: " + err.Error())
+	}
+
 	// Parse status template
-	defaultTemplates.Status, err = template.New("status").Parse(statusHTML)
+	defaultTemplates.Status, err = template.New("status").Funcs(funcs).Parse(statusHTML)
 	if err != nil {
 		panic("failed to parse status template: " + err.Error())
 	}
+
+	// Parse AS detail template
+	defaultTemplates.ASDetail, err = template.New("asDetail").Funcs(funcs).Parse(asDetailHTML)
+	if err != nil {
+		panic("failed to parse AS detail template: " + err.Error())
+	}
+
+	// Parse prefix detail template
+	defaultTemplates.PrefixDetail, err = template.New("prefixDetail").Funcs(funcs).Parse(prefixDetailHTML)
+	if err != nil {
+		panic("failed to parse prefix detail template: " + err.Error())
+	}
+
+	// Parse prefix length template
+	defaultTemplates.PrefixLength, err = template.New("prefixLength").Funcs(funcs).Parse(prefixLengthHTML)
+	if err != nil {
+		panic("failed to parse prefix length template: " + err.Error())
+	}
 }
 
 // Get returns the singleton Templates instance
@@ -42,7 +159,27 @@ func Get() *Templates {
 	return defaultTemplates
 }
 
+// IndexTemplate returns the parsed index template
+func IndexTemplate() *template.Template {
+	return Get().Index
+}
+
 // StatusTemplate returns the parsed status template
 func StatusTemplate() *template.Template {
 	return Get().Status
 }
+
+// ASDetailTemplate returns the parsed AS detail template
+func ASDetailTemplate() *template.Template {
+	return Get().ASDetail
+}
+
+// PrefixDetailTemplate returns the parsed prefix detail template
+func PrefixDetailTemplate() *template.Template {
+	return Get().PrefixDetail
+}
+
+// PrefixLengthTemplate returns the parsed prefix length template
+func PrefixLengthTemplate() *template.Template {
+	return Get().PrefixLength
+}

internal/version/version.go

@@ -0,0 +1,34 @@
+// Package version provides build version information
+package version
+
+// Build-time variables set via ldflags
+//
+//nolint:gochecknoglobals // These must be variables to allow ldflags injection at build time
+var (
+	// GitRevision is the git commit hash
+	GitRevision = "unknown"
+	// GitRevisionShort is the short git commit hash (7 chars)
+	GitRevisionShort = "unknown"
+)
+
+const (
+	// Name is the program name
+	Name = "routewatch"
+	// Author is the program author
+	Author = "@sneak"
+	// AuthorURL is the author's website
+	AuthorURL = "https://sneak.berlin"
+	// License is the program license
+	License = "WTFPL"
+	// RepoURL is the git repository URL
+	RepoURL = "https://git.eeqj.de/sneak/routewatch"
+)
+
+// CommitURL returns the URL to view the current commit
+func CommitURL() string {
+	if GitRevision == "unknown" {
+		return RepoURL
+	}
+
+	return RepoURL + "/commit/" + GitRevision
+}

internal/whois/whois.go

@@ -0,0 +1,347 @@
+// Package whois provides WHOIS lookup functionality for ASN information.
+package whois
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"net"
+	"regexp"
+	"strings"
+	"time"
+)
+
+// Timeout constants for WHOIS queries.
+const (
+	dialTimeout  = 10 * time.Second
+	readTimeout  = 30 * time.Second
+	writeTimeout = 5 * time.Second
+)
+
+// Parsing constants.
+const (
+	keyValueParts       = 2 // Expected parts when splitting "key: value"
+	lacnicDateFormatLen = 8 // Length of YYYYMMDD date format
+)
+
+// WHOIS server addresses.
+const (
+	whoisServerIANA    = "whois.iana.org:43"
+	whoisServerARIN    = "whois.arin.net:43"
+	whoisServerRIPE    = "whois.ripe.net:43"
+	whoisServerAPNIC   = "whois.apnic.net:43"
+	whoisServerLACNIC  = "whois.lacnic.net:43"
+	whoisServerAFRINIC = "whois.afrinic.net:43"
+)
+
+// RIR identifiers.
+const (
+	RIRARIN   = "ARIN"
+	RIRRIPE   = "RIPE"
+	RIRAPNIC  = "APNIC"
+	RIRLACNIC = "LACNIC"
+	RIRAFRNIC = "AFRINIC"
+)
+
+// ASNInfo contains parsed WHOIS information for an ASN.
+type ASNInfo struct {
+	ASN         int
+	ASName      string
+	OrgName     string
+	OrgID       string
+	Address     string
+	CountryCode string
+	AbuseEmail  string
+	AbusePhone  string
+	TechEmail   string
+	TechPhone   string
+	RIR         string
+	RegDate     *time.Time
+	LastMod     *time.Time
+	RawResponse string
+}
+
+// Client performs WHOIS lookups for ASNs.
+type Client struct {
+	// Dialer for creating connections (can be overridden for testing)
+	dialer *net.Dialer
+}
+
+// NewClient creates a new WHOIS client.
+func NewClient() *Client {
+	return &Client{
+		dialer: &net.Dialer{
+			Timeout: dialTimeout,
+		},
+	}
+}
+
+// LookupASN queries WHOIS for the given ASN and returns parsed information.
+func (c *Client) LookupASN(ctx context.Context, asn int) (*ASNInfo, error) {
+	// Query IANA first to find the authoritative RIR
+	query := fmt.Sprintf("AS%d", asn)
+
+	ianaResp, err := c.query(ctx, whoisServerIANA, query)
+	if err != nil {
+		return nil, fmt.Errorf("IANA query failed: %w", err)
+	}
+
+	// Determine RIR from IANA response
+	rir, whoisServer := c.parseIANAReferral(ianaResp)
+	if whoisServer == "" {
+		// No referral, try to parse what we have
+		return c.parseResponse(asn, rir, ianaResp), nil
+	}
+
+	// Query the authoritative RIR
+	rirResp, err := c.query(ctx, whoisServer, query)
+	if err != nil {
+		// Return partial data from IANA if RIR query fails
+		info := c.parseResponse(asn, rir, ianaResp)
+		info.RawResponse = ianaResp + "\n--- RIR query failed: " + err.Error() + " ---\n"
+
+		return info, nil
+	}
+
+	// Combine responses and parse
+	fullResponse := ianaResp + "\n" + rirResp
+	info := c.parseResponse(asn, rir, fullResponse)
+	info.RawResponse = fullResponse
+
+	return info, nil
+}
+
+// query performs a raw WHOIS query to the specified server.
+func (c *Client) query(ctx context.Context, server, query string) (string, error) {
+	conn, err := c.dialer.DialContext(ctx, "tcp", server)
+	if err != nil {
+		return "", fmt.Errorf("dial %s: %w", server, err)
+	}
+	defer func() { _ = conn.Close() }()
+
+	// Set deadlines
+	if err := conn.SetWriteDeadline(time.Now().Add(writeTimeout)); err != nil {
+		return "", fmt.Errorf("set write deadline: %w", err)
+	}
+
+	// Send query
+	if _, err := fmt.Fprintf(conn, "%s\r\n", query); err != nil {
+		return "", fmt.Errorf("write query: %w", err)
+	}
+
+	// Read response
+	if err := conn.SetReadDeadline(time.Now().Add(readTimeout)); err != nil {
+		return "", fmt.Errorf("set read deadline: %w", err)
+	}
+
+	var sb strings.Builder
+	scanner := bufio.NewScanner(conn)
+	for scanner.Scan() {
+		sb.WriteString(scanner.Text())
+		sb.WriteString("\n")
+	}
+
+	if err := scanner.Err(); err != nil {
+		return sb.String(), fmt.Errorf("read response: %w", err)
+	}
+
+	return sb.String(), nil
+}
+
+// parseIANAReferral extracts the RIR and WHOIS server from an IANA response.
+func (c *Client) parseIANAReferral(response string) (rir, whoisServer string) {
+	lines := strings.Split(response, "\n")
+
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+
+		// Look for "refer:" line
+		if strings.HasPrefix(strings.ToLower(line), "refer:") {
+			server := strings.TrimSpace(strings.TrimPrefix(line, "refer:"))
+			server = strings.TrimSpace(strings.TrimPrefix(server, "Refer:"))
+
+			switch {
+			case strings.Contains(server, "arin"):
+				return RIRARIN, whoisServerARIN
+			case strings.Contains(server, "ripe"):
+				return RIRRIPE, whoisServerRIPE
+			case strings.Contains(server, "apnic"):
+				return RIRAPNIC, whoisServerAPNIC
+			case strings.Contains(server, "lacnic"):
+				return RIRLACNIC, whoisServerLACNIC
+			case strings.Contains(server, "afrinic"):
+				return RIRAFRNIC, whoisServerAFRINIC
+			default:
+				// Unknown server, add port if missing
+				if !strings.Contains(server, ":") {
+					server += ":43"
+				}
+
+				return "", server
+			}
+		}
+
+		// Also check organisation line for RIR hints
+		if strings.HasPrefix(strings.ToLower(line), "organisation:") {
+			org := strings.ToLower(line)
+			switch {
+			case strings.Contains(org, "arin"):
+				rir = RIRARIN
+			case strings.Contains(org, "ripe"):
+				rir = RIRRIPE
+			case strings.Contains(org, "apnic"):
+				rir = RIRAPNIC
+			case strings.Contains(org, "lacnic"):
+				rir = RIRLACNIC
+			case strings.Contains(org, "afrinic"):
+				rir = RIRAFRNIC
+			}
+		}
+	}
+
+	return rir, ""
+}
+
+// parseResponse extracts ASN information from a WHOIS response.
+func (c *Client) parseResponse(asn int, rir, response string) *ASNInfo {
+	info := &ASNInfo{
+		ASN:         asn,
+		RIR:         rir,
+		RawResponse: response,
+	}
+
+	lines := strings.Split(response, "\n")
+	var addressLines []string
+
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, "%") || strings.HasPrefix(line, "#") {
+			continue
+		}
+
+		// Split on first colon
+		parts := strings.SplitN(line, ":", keyValueParts)
+		if len(parts) != keyValueParts {
+			continue
+		}
+
+		key := strings.TrimSpace(strings.ToLower(parts[0]))
+		value := strings.TrimSpace(parts[1])
+
+		if value == "" {
+			continue
+		}
+
+		switch key {
+		// AS Name (varies by RIR)
+		case "asname", "as-name":
+			if info.ASName == "" {
+				info.ASName = value
+			}
+
+		// Organization
+		case "orgname", "org-name", "owner":
+			if info.OrgName == "" {
+				info.OrgName = value
+			}
+		case "orgid", "org-id", "org":
+			if info.OrgID == "" {
+				info.OrgID = value
+			}
+
+		// Address (collect multiple lines)
+		case "address":
+			addressLines = append(addressLines, value)
+
+		// Country
+		case "country":
+			if info.CountryCode == "" && len(value) == 2 {
+				info.CountryCode = strings.ToUpper(value)
+			}
+
+		// Abuse contact
+		case "orgabuseemail", "abuse-mailbox":
+			if info.AbuseEmail == "" {
+				info.AbuseEmail = value
+			}
+		case "orgabusephone":
+			if info.AbusePhone == "" {
+				info.AbusePhone = value
+			}
+
+		// Tech contact
+		case "orgtechemail":
+			if info.TechEmail == "" {
+				info.TechEmail = value
+			}
+		case "orgtechphone":
+			if info.TechPhone == "" {
+				info.TechPhone = value
+			}
+
+		// Registration dates
+		case "regdate", "created":
+			if info.RegDate == nil {
+				info.RegDate = c.parseDate(value)
+			}
+		case "updated", "last-modified", "changed":
+			if info.LastMod == nil {
+				info.LastMod = c.parseDate(value)
+			}
+		}
+	}
+
+	// Combine address lines
+	if len(addressLines) > 0 {
+		info.Address = strings.Join(addressLines, "\n")
+	}
+
+	// Extract abuse email from comment lines (common in ARIN responses)
+	if info.AbuseEmail == "" {
+		info.AbuseEmail = c.extractAbuseEmail(response)
+	}
+
+	return info
+}
+
+// parseDate attempts to parse various date formats used in WHOIS responses.
+func (c *Client) parseDate(value string) *time.Time {
+	// Common formats
+	formats := []string{
+		"2006-01-02",
+		"2006-01-02T15:04:05Z",
+		"2006-01-02T15:04:05-07:00",
+		"20060102",
+		"02-Jan-2006",
+	}
+
+	// Clean up value
+	value = strings.TrimSpace(value)
+	// Handle "YYYYMMDD" format from LACNIC
+	if len(value) == lacnicDateFormatLen {
+		if _, err := time.Parse("20060102", value); err == nil {
+			t, _ := time.Parse("20060102", value)
+
+			return &t
+		}
+	}
+
+	for _, format := range formats {
+		if t, err := time.Parse(format, value); err == nil {
+			return &t
+		}
+	}
+
+	return nil
+}
+
+// extractAbuseEmail extracts abuse email from response using regex.
+func (c *Client) extractAbuseEmail(response string) string {
+	// Look for "Abuse contact for 'AS...' is 'email@domain'"
+	re := regexp.MustCompile(`[Aa]buse contact.*?is\s+['"]?([^\s'"]+@[^\s'"]+)['"]?`)
+	if matches := re.FindStringSubmatch(response); len(matches) > 1 {
+		return matches[1]
+	}
+
+	return ""
+}