Answer 504, not 408, when a request outlasts its time limit (closes #70)

The hand-written time limit middleware answered 408 and wrote that
answer from its own goroutine while the handler could still be writing.
It is replaced by chi's middleware.Timeout, placed after
JSONResponseMiddleware so its 504 is not lost behind a 200.
JSONValidationMiddleware answers 504 with the JSON error body when the
time limit has passed and the handler wrote nothing. status.json and
/api/v1/stats answer 504 themselves when their 4-second database read
runs out, instead of 408 or an empty answer that became 500.

Model: opus-5-5

README.md

@@ -144,9 +144,8 @@ routewatch/
 - **Reconnection**: Exponential backoff (5s-320s) with reset after 30s of stable connection
 - **IP Lookup**: the most specific live route is found by looking up the
   address's prefix at each mask length, longest first, in the prefix index
-  (at most 25 lookups for IPv4, 113 for IPv6); prefixes are stored in the
+  (at most 33 lookups for IPv4, 129 for IPv6); prefixes are stored in the
-  text form Go's `net/netip` prints. Routes shorter than /8 for IPv4 or /16
+  text form Go's `net/netip` prints
-  for IPv6, such as a default route, are not used.
 
 ### Database Schema
 

internal/database/database.go

@@ -37,14 +37,6 @@ const (
 	ipv6Bits       = 128
 )
 
-// The IP lookup does not use routes shorter than these mask lengths. A default
-// route or a route this short only says where a peer sends traffic it has no
-// better route for; it does not say who holds the address.
-const (
-	minLookupMaskLengthV4 = 8
-	minLookupMaskLengthV6 = 16
-)
-
 // SQLite memory tuning. cache_size and busy_timeout go in the DSN so every
 // pooled connection gets them; the heap limits are process-wide and set once.
 const (
@@ -1884,12 +1876,11 @@ func (d *Database) GetIPInfo(ip string) (*IPInfo, error) {
 // GetIPInfoContext returns comprehensive IP information with context support.
 //
 // It finds the most specific live route for the address with point lookups on
-// the prefix index: for each mask length from the longest (32 or 128) down to
+// the prefix index: for each mask length from the longest (32 or 128) down to 0
-// minLookupMaskLengthV4 or minLookupMaskLengthV6 it looks up the address's
+// it looks up the address's network prefix at that length, and the first length
-// network prefix at that length, and the first length with a live route wins.
+// with a live route wins. That is at most 33 or 129 indexed lookups, however
-// That is at most 25 or 113 indexed lookups, however many routes are live. The
+// many routes are live. The prefix is looked up in the text form net/netip
-// prefix is looked up in the text form net/netip prints, which is the form the
+// prints, which is the form the prefix handler stores.
-// prefix handler stores.
 func (d *Database) GetIPInfoContext(ctx context.Context, ip string) (*IPInfo, error) {
 	addr, err := netip.ParseAddr(ip)
 	if err != nil {
@@ -1900,11 +1891,9 @@ func (d *Database) GetIPInfoContext(ctx context.Context, ip string) (*IPInfo, er
 
 	info := &IPInfo{IP: ip, IPVersion: ipVersionV6}
 	routesTable, prefixesTable := "live_routes_v6", "prefixes_v6"
-	minMaskLength := minLookupMaskLengthV6
 	if addr.Is4() {
 		info.IPVersion = ipVersionV4
 		routesTable, prefixesTable = "live_routes_v4", "prefixes_v4"
-		minMaskLength = minLookupMaskLengthV4
 	}
 
 	// Route info with peer count and prefix first_seen
@@ -1945,7 +1934,7 @@ func (d *Database) GetIPInfoContext(ctx context.Context, ip string) (*IPInfo, er
 	var whoisUpdatedAt sql.NullTime
 
 	found := false
-	for bits := addr.BitLen(); bits >= minMaskLength; bits-- {
+	for bits := addr.BitLen(); bits >= 0; bits-- {
 		prefix := netip.PrefixFrom(addr, bits).Masked().String()
 		err := stmt.QueryRowContext(ctx, prefix).Scan(
 			&info.Netblock,

internal/database/database_test.go

@@ -133,78 +133,6 @@ func TestGetIPInfoFindsMostSpecificLiveRoute(t *testing.T) {
 	lookup("2001:db8:1:2::3", "2001:db8:1::/48")
 }
 
-// TestGetIPInfoIgnoresShortRoutes checks that the IP lookup does not report a
-// default route, or a route shorter than /8 for IPv4 or /16 for IPv6, as the
-// route for an address, and that a route of exactly /8 or /16, or longer, still
-// is. The prefixes are written out so that a wrong limit fails the test.
-func TestGetIPInfoIgnoresShortRoutes(t *testing.T) {
-	cfg := &config.Config{StateDir: t.TempDir()}
-
-	db, err := New(cfg, logger.New())
-	if err != nil {
-		t.Fatalf("failed to create database: %v", err)
-	}
-	defer func() { _ = db.Close() }()
-
-	ts := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC)
-	announce := func(prefix string, asn int) {
-		t.Helper()
-
-		err := db.UpsertLiveRouteBatch([]*LiveRoute{{
-			ID:          uuid.New(),
-			Prefix:      prefix,
-			MaskLength:  netip.MustParsePrefix(prefix).Bits(),
-			IPVersion:   detectIPVersion(prefix),
-			OriginASN:   asn,
-			PeerIP:      testPeerIP,
-			ASPath:      []int{asn},
-			NextHop:     testPeerIP,
-			LastUpdated: ts,
-		}})
-		if err != nil {
-			t.Fatalf("UpsertLiveRouteBatch(%s): %v", prefix, err)
-		}
-	}
-
-	// lookup checks that ip resolves to the live prefix netblock from asn.
-	lookup := func(ip, netblock string, asn int) {
-		t.Helper()
-
-		info, err := db.GetIPInfo(ip)
-		if err != nil {
-			t.Errorf("GetIPInfo(%s): %v", ip, err)
-
-			return
-		}
-		if info.Netblock != netblock || info.ASN != asn {
-			t.Errorf("GetIPInfo(%s) = %s AS%d, want %s AS%d", ip, info.Netblock, info.ASN, netblock, asn)
-		}
-	}
-
-	// Default and very short routes, and routes one bit shorter than each limit.
-	announce("2000::/3", 64500)
-	announce("0.0.0.0/0", 64500)
-	announce("2000::/15", 64500)
-	announce("192.0.0.0/7", 64500)
-
-	for _, ip := range []string{"2001:db8::1", "192.0.2.1"} {
-		if info, err := db.GetIPInfo(ip); !errors.Is(err, ErrNoRoute) {
-			t.Errorf("GetIPInfo(%s) with only short routes = %+v, %v; want ErrNoRoute", ip, info, err)
-		}
-	}
-
-	// Routes of exactly the minimum length are used.
-	announce("2001::/16", 64501)
-	announce("192.0.0.0/8", 64501)
-
-	lookup("2001:db8::1", "2001::/16", 64501)
-	lookup("192.0.2.1", "192.0.0.0/8", 64501)
-
-	announce("2001:db8::/32", 64502)
-
-	lookup("2001:db8::1", "2001:db8::/32", 64502)
-}
-
 // TestConnectionPoolPragmas holds several pooled connections open at once and
 // checks each one carries the per-connection settings from the DSN, plus the
 // process-wide hard heap limit, and sees the new file with auto_vacuum

internal/metrics/metrics.go

@@ -60,22 +60,17 @@ func New() *Tracker {
 	}
 }
 
-// SetConnected updates the connection status. Every connection after the
+// SetConnected updates the connection status
-// first counts one reconnect.
 func (t *Tracker) SetConnected(connected bool) {
-	t.isConnected.Store(connected)
+	wasConnected := t.isConnected.Swap(connected)
-	if !connected {
+	if connected {
-		return
+		t.mu.Lock()
-	}
+		t.connectedSince = time.Now()
-
+		t.mu.Unlock()
-	t.mu.Lock()
+		// Increment reconnect count (but not for the initial connection)
-	// connectedSince is zero until the first connection.
+		if wasConnected || t.reconnectCount.Load() > 0 {
-	connectedBefore := !t.connectedSince.IsZero()
+			t.reconnectCount.Add(1)
-	t.connectedSince = time.Now()
+		}
-	t.mu.Unlock()
-
-	if connectedBefore {
-		t.reconnectCount.Add(1)
 	}
 }
 

internal/metrics/metrics_test.go

@@ -1,21 +0,0 @@
-package metrics
-
-import "testing"
-
-// TestReconnectCount connects three times with a disconnect between each, the
-// way the streamer does, and expects every connection after the first to count
-// one reconnect.
-func TestReconnectCount(t *testing.T) {
-	tracker := New()
-
-	tracker.SetConnected(true)
-	tracker.SetConnected(false)
-	tracker.SetConnected(true)
-	tracker.SetConnected(false)
-	tracker.SetConnected(true)
-
-	const wantReconnects = 2
-	if got := tracker.GetReconnectCount(); got != wantReconnects {
-		t.Fatalf("reconnect count = %d, want %d", got, wantReconnects)
-	}
-}

internal/routewatch/prefixhandler.go

@@ -105,24 +105,7 @@ func (h *PrefixHandler) HandleMessage(msg *ristypes.RISMessage) {
 	h.mu.Lock()
 	defer h.mu.Unlock()
 
-	// Withdrawals are queued before announcements, because the batch keeps
+	// Process announcements
-	// each peer's last update for a prefix: a message that lists a prefix as
-	// both withdrawn and announced keeps the route (RFC 4271 section 4.3).
-	for _, prefix := range msg.Withdrawals {
-		h.batch = append(h.batch, prefixUpdate{
-			prefix:      canonicalPrefix(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()
-		}
-	}
-
 	for _, announcement := range msg.Announcements {
 		for _, prefix := range announcement.Prefixes {
 			h.batch = append(h.batch, prefixUpdate{
@@ -140,6 +123,22 @@ func (h *PrefixHandler) HandleMessage(msg *ristypes.RISMessage) {
 		}
 	}
 
+	// Process withdrawals
+	for _, prefix := range msg.Withdrawals {
+		h.batch = append(h.batch, prefixUpdate{
+			prefix:      canonicalPrefix(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()
@@ -180,14 +179,14 @@ func (h *PrefixHandler) flushBatchLocked() {
 	startTime := time.Now()
 	batchSize := len(h.batch)
 
-	// For each prefix and peer, keep only the last update the feed delivered.
+	// Group updates by prefix to deduplicate
-	// Updates from different peers for the same prefix are all kept. Arrival
+	// For each prefix, keep the latest update
-	// order decides, not the timestamp: timestamps are whole seconds, so
+	prefixMap := make(map[string]prefixUpdate)
-	// updates within one second carry the same one.
-	type prefixAndPeer struct{ prefix, peer string }
-	lastUpdates := make(map[prefixAndPeer]prefixUpdate)
 	for _, update := range h.batch {
-		lastUpdates[prefixAndPeer{update.prefix, update.peer}] = update
+		key := update.prefix
+		if existing, ok := prefixMap[key]; !ok || update.timestamp.After(existing.timestamp) {
+			prefixMap[key] = update
+		}
 	}
 
 	// Collect routes to upsert and delete
@@ -197,7 +196,7 @@ func (h *PrefixHandler) flushBatchLocked() {
 	// Collect unique prefixes to update
 	prefixesToUpdate := make(map[string]time.Time)
 
-	for _, update := range lastUpdates {
+	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
@@ -256,7 +255,7 @@ func (h *PrefixHandler) flushBatchLocked() {
 	elapsed := time.Since(startTime)
 	h.logger.Debug("Flushed prefix batch",
 		"batch_size", batchSize,
-		"unique_prefixes", len(prefixesToUpdate),
+		"unique_prefixes", len(prefixMap),
 		"success", successCount,
 		"duration_ms", elapsed.Milliseconds(),
 	)

internal/routewatch/prefixhandler_test.go

@@ -1,9 +1,7 @@
 package routewatch
 
 import (
-	"context"
 	"errors"
-	"slices"
 	"testing"
 	"time"
 
@@ -74,140 +72,3 @@ func TestPrefixHandlerStoresPrefixesTheIPLookupFinds(t *testing.T) {
 		}
 	}
 }
-
-// TestPrefixHandlerAppliesEachPeersLastUpdateInABatch runs updates for one
-// prefix through the prefix handler into a real database. All updates carry the
-// same timestamp, as updates within one second of the feed do. Within a batch,
-// the last update each peer sent for the prefix decides whether that peer has a
-// live route for it, and updates from different peers are all applied. The
-// in-memory route count and prefix distribution must match the route table.
-func TestPrefixHandlerAppliesEachPeersLastUpdateInABatch(t *testing.T) {
-	const (
-		prefix           = "198.51.100.0/24"
-		prefixMaskLength = 24
-		otherPeerIP      = "2001:db8:ffff::2"
-	)
-
-	ts := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC)
-	announce := func(peer string) *ristypes.RISMessage {
-		return &ristypes.RISMessage{
-			Peer:            peer,
-			Path:            ristypes.ASPath{testASNA, testASNB},
-			ParsedTimestamp: ts,
-			Announcements:   []ristypes.RISAnnouncement{{NextHop: peer, Prefixes: []string{prefix}}},
-		}
-	}
-	withdraw := func(peer string) *ristypes.RISMessage {
-		return &ristypes.RISMessage{Peer: peer, ParsedTimestamp: ts, Withdrawals: []string{prefix}}
-	}
-	announceAndWithdraw := func(peer string) *ristypes.RISMessage {
-		msg := announce(peer)
-		msg.Withdrawals = []string{prefix}
-
-		return msg
-	}
-
-	tests := []struct {
-		name string
-		// Each inner list is handled and then flushed as one batch.
-		batches [][]*ristypes.RISMessage
-		// The peers left with a live route for the prefix, by peer IP.
-		wantPeers []string
-	}{
-		{
-			name:      "two peers announce the prefix",
-			batches:   [][]*ristypes.RISMessage{{announce(testPeerIP), announce(otherPeerIP)}},
-			wantPeers: []string{testPeerIP, otherPeerIP},
-		},
-		{
-			name: "two peers withdraw the prefix",
-			batches: [][]*ristypes.RISMessage{
-				{announce(testPeerIP)},
-				{announce(otherPeerIP)},
-				{withdraw(testPeerIP), withdraw(otherPeerIP)},
-			},
-		},
-		{
-			name:    "a peer announces and then withdraws the prefix",
-			batches: [][]*ristypes.RISMessage{{announce(testPeerIP), withdraw(testPeerIP)}},
-		},
-		{
-			name: "a peer withdraws and then re-announces the prefix",
-			batches: [][]*ristypes.RISMessage{
-				{announce(testPeerIP)},
-				{withdraw(testPeerIP), announce(testPeerIP)},
-			},
-			wantPeers: []string{testPeerIP},
-		},
-		{
-			// RFC 4271 section 4.3: the announcement counts, not the withdrawal.
-			name: "one message announces and withdraws the prefix",
-			batches: [][]*ristypes.RISMessage{
-				{announce(testPeerIP)},
-				{announceAndWithdraw(testPeerIP)},
-			},
-			wantPeers: []string{testPeerIP},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			db, err := database.New(&config.Config{StateDir: t.TempDir()}, logger.New())
-			if err != nil {
-				t.Fatalf("failed to create database: %v", err)
-			}
-			defer func() { _ = db.Close() }()
-
-			// Built without NewPrefixHandler's flush timer, so the test flushes itself.
-			h := &PrefixHandler{db: db, logger: logger.New()}
-			for _, batch := range tt.batches {
-				for _, msg := range batch {
-					h.HandleMessage(msg)
-				}
-				h.mu.Lock()
-				h.flushBatchLocked()
-				h.mu.Unlock()
-			}
-
-			ctx := context.Background()
-			routes, err := db.GetPrefixDetailsContext(ctx, prefix)
-			if err != nil && !errors.Is(err, database.ErrNoRoute) {
-				t.Fatalf("GetPrefixDetailsContext: %v", err)
-			}
-			var gotPeers []string
-			for _, route := range routes {
-				gotPeers = append(gotPeers, route.PeerIP)
-			}
-			if !slices.Equal(gotPeers, tt.wantPeers) {
-				t.Errorf("peers with a live route for %s = %v, want %v", prefix, gotPeers, tt.wantPeers)
-			}
-
-			stats, err := db.GetStatsContext(ctx)
-			if err != nil {
-				t.Fatalf("GetStatsContext: %v", err)
-			}
-			tableRoutesV4, _, err := db.GetLiveRouteCountsContext(ctx)
-			if err != nil {
-				t.Fatalf("GetLiveRouteCountsContext: %v", err)
-			}
-			if stats.IPv4Routes != len(tt.wantPeers) || tableRoutesV4 != len(tt.wantPeers) {
-				t.Errorf("IPv4 live routes: %d in memory, %d in the table, want %d",
-					stats.IPv4Routes, tableRoutesV4, len(tt.wantPeers))
-			}
-
-			var wantDistribution []database.PrefixDistribution
-			if len(tt.wantPeers) > 0 {
-				wantDistribution = []database.PrefixDistribution{{MaskLength: prefixMaskLength, Count: 1}}
-			}
-			queryDistributionV4, _, err := db.GetPrefixDistributionContext(ctx)
-			if err != nil {
-				t.Fatalf("GetPrefixDistributionContext: %v", err)
-			}
-			if !slices.Equal(stats.IPv4PrefixDistribution, wantDistribution) ||
-				!slices.Equal(queryDistributionV4, wantDistribution) {
-				t.Errorf("IPv4 prefix distribution: %v in memory, %v from the table, want %v",
-					stats.IPv4PrefixDistribution, queryDistributionV4, wantDistribution)
-			}
-		})
-	}
-}

internal/server/handlers.go

@@ -7,7 +7,6 @@ import (
 	"errors"
 	"net"
 	"net/http"
-	"net/netip"
 	"runtime"
 	"sort"
 	"strconv"
@@ -206,11 +205,7 @@ func (s *Server) handleStatusJSON() http.HandlerFunc {
 			return
 		case err := <-errChan:
 			s.logger.Error("Failed to get database stats", "error", err)
-			if deadlinePassed(ctx) {
+			writeJSONError(w, http.StatusInternalServerError, err.Error())
-				writeJSONError(w, http.StatusGatewayTimeout, requestTimeoutMessage)
-			} else {
-				writeJSONError(w, http.StatusInternalServerError, err.Error())
-			}
 
 			return
 		case dbStats = <-statsChan:
@@ -424,11 +419,7 @@ func (s *Server) handleStats() http.HandlerFunc {
 			return
 		case err := <-errChan:
 			s.logger.Error("Failed to get database stats", "error", err)
-			if deadlinePassed(ctx) {
+			writeJSONError(w, http.StatusInternalServerError, err.Error())
-				writeJSONError(w, http.StatusGatewayTimeout, requestTimeoutMessage)
-			} else {
-				writeJSONError(w, http.StatusInternalServerError, err.Error())
-			}
 
 			return
 		case dbStats = <-statsChan:
@@ -631,13 +622,6 @@ func (s *Server) handleIPInfo() http.HandlerFunc {
 			}
 		}
 
-		// The time limit passed while resolving host names.
-		if deadlinePassed(ctx) {
-			writeJSONError(w, http.StatusGatewayTimeout, requestTimeoutMessage)
-
-			return
-		}
-
 		if len(ipsToLookup) == 0 {
 			writeJSONError(w, http.StatusBadRequest, "No valid IPs or hostnames provided")
 
@@ -680,13 +664,6 @@ func (s *Server) handleIPInfo() http.HandlerFunc {
 			}
 		}
 
-		// The time limit passed while looking up the IPs.
-		if deadlinePassed(ctx) {
-			writeJSONError(w, http.StatusGatewayTimeout, requestTimeoutMessage)
-
-			return
-		}
-
 		// Return response (even if no results, include errors)
 		if len(response.Results) == 0 && len(response.Errors) > 0 {
 			writeJSONError(w, http.StatusNotFound, "No routes found: "+response.Errors[0])
@@ -726,12 +703,9 @@ func (s *Server) handleASDetailJSON() http.HandlerFunc {
 
 		asInfo, prefixes, err := s.db.GetASDetailsContext(r.Context(), asn)
 		if err != nil {
-			switch {
+			if errors.Is(err, database.ErrNoRoute) {
-			case errors.Is(err, database.ErrNoRoute):
 				writeJSONError(w, http.StatusNotFound, err.Error())
-			case deadlinePassed(r.Context()):
+			} else {
-				writeJSONError(w, http.StatusGatewayTimeout, requestTimeoutMessage)
-			default:
 				writeJSONError(w, http.StatusInternalServerError, err.Error())
 			}
 
@@ -775,24 +749,14 @@ func (s *Server) handlePrefixDetailJSON() http.HandlerFunc {
 			return
 		}
 
-		// Look the prefix up in the text form net/netip prints, the form the
+		// Combine prefix and length into CIDR notation
-		// tables store, so that any valid way of writing it finds the route.
+		prefix := prefixParam + "/" + lenParam
-		parsed, err := netip.ParsePrefix(prefixParam + "/" + lenParam)
-		if err != nil {
-			writeJSONError(w, http.StatusBadRequest, err.Error())
-
-			return
-		}
-		prefix := parsed.Masked().String()
 
 		routes, err := s.db.GetPrefixDetailsContext(r.Context(), prefix)
 		if err != nil {
-			switch {
+			if errors.Is(err, database.ErrNoRoute) {
-			case errors.Is(err, database.ErrNoRoute):
 				writeJSONError(w, http.StatusNotFound, err.Error())
-			case deadlinePassed(r.Context()):
+			} else {
-				writeJSONError(w, http.StatusGatewayTimeout, requestTimeoutMessage)
-			default:
 				writeJSONError(w, http.StatusInternalServerError, err.Error())
 			}
 
@@ -832,12 +796,9 @@ func (s *Server) handleASDetail() http.HandlerFunc {
 
 		asInfo, prefixes, err := s.db.GetASDetailsContext(r.Context(), asn)
 		if err != nil {
-			switch {
+			if errors.Is(err, database.ErrNoRoute) {
-			case errors.Is(err, database.ErrNoRoute):
 				http.Error(w, "AS not found", http.StatusNotFound)
-			case deadlinePassed(r.Context()):
+			} else {
-				http.Error(w, requestTimeoutMessage, http.StatusGatewayTimeout)
-			default:
 				s.logger.Error("Failed to get AS details", "error", err)
 				http.Error(w, "Internal server error", http.StatusInternalServerError)
 			}
@@ -952,24 +913,14 @@ func (s *Server) handlePrefixDetail() http.HandlerFunc {
 			return
 		}
 
-		// Look the prefix up in the text form net/netip prints, the form the
+		// Combine prefix and length into CIDR notation
-		// tables store, so that any valid way of writing it finds the route.
+		prefix := prefixParam + "/" + lenParam
-		parsed, err := netip.ParsePrefix(prefixParam + "/" + lenParam)
-		if err != nil {
-			http.Error(w, "Invalid prefix", http.StatusBadRequest)
-
-			return
-		}
-		prefix := parsed.Masked().String()
 
 		routes, err := s.db.GetPrefixDetailsContext(r.Context(), prefix)
 		if err != nil {
-			switch {
+			if errors.Is(err, database.ErrNoRoute) {
-			case errors.Is(err, database.ErrNoRoute):
 				http.Error(w, "Prefix not found", http.StatusNotFound)
-			case deadlinePassed(r.Context()):
+			} else {
-				http.Error(w, requestTimeoutMessage, http.StatusGatewayTimeout)
-			default:
 				s.logger.Error("Failed to get prefix details", "error", err)
 				http.Error(w, "Internal server error", http.StatusInternalServerError)
 			}
@@ -1123,12 +1074,8 @@ func (s *Server) handlePrefixLength() http.HandlerFunc {
 		const maxPrefixes = 500
 		prefixes, err := s.db.GetRandomPrefixesByLengthContext(r.Context(), maskLength, ipVersion, maxPrefixes)
 		if err != nil {
-			if deadlinePassed(r.Context()) {
+			s.logger.Error("Failed to get prefixes by length", "error", err)
-				http.Error(w, requestTimeoutMessage, http.StatusGatewayTimeout)
+			http.Error(w, "Internal server error", http.StatusInternalServerError)
-			} else {
-				s.logger.Error("Failed to get prefixes by length", "error", err)
-				http.Error(w, "Internal server error", http.StatusInternalServerError)
-			}
 
 			return
 		}
@@ -1218,12 +1165,8 @@ func (s *Server) handlePrefixLength6() http.HandlerFunc {
 		const maxPrefixes = 500
 		prefixes, err := s.db.GetRandomPrefixesByLengthContext(r.Context(), maskLength, ipVersion, maxPrefixes)
 		if err != nil {
-			if deadlinePassed(r.Context()) {
+			s.logger.Error("Failed to get prefixes by length", "error", err)
-				http.Error(w, requestTimeoutMessage, http.StatusGatewayTimeout)
+			http.Error(w, "Internal server error", http.StatusInternalServerError)
-			} else {
-				s.logger.Error("Failed to get prefixes by length", "error", err)
-				http.Error(w, "Internal server error", http.StatusInternalServerError)
-			}
 
 			return
 		}

internal/server/handlers_test.go

@@ -148,58 +148,6 @@ func TestStatsHandlersAnswerFromMemory(t *testing.T) {
 	}
 }
 
-// TestPrefixDetailHandlersParsePrefix checks that both prefix pages find a
-// stored route whatever valid text form the URL writes its prefix in, and
-// answer 400 for a prefix that does not parse. The tables store the form
-// net/netip prints. Before the fix the URL text was looked up as typed, so
-// "2001:DB8:0:0::/32" was not found although "2001:db8::/32" was stored, and
-// "foo/24" answered 500 (https://git.eeqj.de/sneak/routewatch/issues/71).
-func TestPrefixDetailHandlersParsePrefix(t *testing.T) {
-	db, err := database.New(&config.Config{StateDir: t.TempDir()}, logger.New())
-	if err != nil {
-		t.Fatalf("database.New: %v", err)
-	}
-	t.Cleanup(func() { _ = db.Close() })
-
-	ts := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC)
-	if err := db.UpsertLiveRouteBatch([]*database.LiveRoute{
-		{
-			ID: uuid.New(), Prefix: "192.0.2.0/24", MaskLength: 24, IPVersion: 4,
-			OriginASN: 64500, PeerIP: "198.51.100.1", ASPath: []int{64500}, NextHop: "198.51.100.1",
-			LastUpdated: ts,
-		},
-		{
-			ID: uuid.New(), Prefix: "2001:db8::/32", MaskLength: 32, IPVersion: 6,
-			OriginASN: 64501, PeerIP: "2001:db8::1", ASPath: []int{64501}, NextHop: "2001:db8::1",
-			LastUpdated: ts,
-		},
-	}); err != nil {
-		t.Fatalf("UpsertLiveRouteBatch: %v", err)
-	}
-
-	s := New(db, streamer.New(logger.New(), metrics.New()), logger.New(), &config.Config{})
-
-	tests := []struct {
-		path string
-		want int
-	}{
-		{"/api/v1/prefix/foo/24", http.StatusBadRequest},
-		{"/prefix/foo/24", http.StatusBadRequest},
-		{"/api/v1/prefix/2001:DB8:0:0::/32", http.StatusOK},
-		{"/prefix/2001:DB8:0:0::/32", http.StatusOK},
-		{"/api/v1/prefix/192.0.2.1/24", http.StatusOK},
-		{"/prefix/192.0.2.1/24", http.StatusOK},
-	}
-
-	for _, tt := range tests {
-		rec := httptest.NewRecorder()
-		s.router.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, tt.path, nil))
-		if rec.Code != tt.want {
-			t.Errorf("%s: status %d, want %d; body %s", tt.path, rec.Code, tt.want, rec.Body)
-		}
-	}
-}
-
 // shortRequestDeadline is the deadline the tests below give a request. The
 // server's 30-second limit and the stats handlers' 4-second limit inherit it,
 // so the tests do not wait for either.
@@ -273,85 +221,6 @@ func TestStatsHandlersAnswer504WhenDatabaseReadRunsOut(t *testing.T) {
 	}
 }
 
-// slowDB embeds database.Store (left nil) and overrides the reads the routes
-// in TestRoutesAnswer504WhenDatabaseReadIsCutOff make. Each read waits until
-// its context ends and returns the context's error, as a slow database read
-// cut off by a time limit does.
-type slowDB struct {
-	database.Store
-}
-
-func (slowDB) GetStatsContext(ctx context.Context) (database.Stats, error) {
-	<-ctx.Done()
-
-	return database.Stats{}, ctx.Err()
-}
-
-func (slowDB) GetIPInfoContext(ctx context.Context, _ string) (*database.IPInfo, error) {
-	<-ctx.Done()
-
-	return nil, ctx.Err()
-}
-
-func (slowDB) GetASDetailsContext(ctx context.Context, _ int) (*database.ASN, []database.LiveRoute, error) {
-	<-ctx.Done()
-
-	return nil, nil, ctx.Err()
-}
-
-func (slowDB) GetPrefixDetailsContext(ctx context.Context, _ string) ([]database.LiveRoute, error) {
-	<-ctx.Done()
-
-	return nil, ctx.Err()
-}
-
-func (slowDB) GetRandomPrefixesByLengthContext(ctx context.Context, _, _, _ int) ([]database.LiveRoute, error) {
-	<-ctx.Done()
-
-	return nil, ctx.Err()
-}
-
-// TestRoutesAnswer504WhenDatabaseReadIsCutOff sends a request through the
-// server's router for each route that reads the database, with a store whose
-// reads fail when the request's time limit passes. Each route answers 504, the
-// JSON routes with the JSON error body. Before the fix they answered 408 or,
-// when the handler wrote first, its own error: 500, or 404 on the IP lookups.
-// The health check is left out: it answers 503 when its own 2-second ping runs
-// out.
-func TestRoutesAnswer504WhenDatabaseReadIsCutOff(t *testing.T) {
-	s := New(slowDB{}, streamer.New(logger.New(), metrics.New()), logger.New(), &config.Config{})
-
-	tests := []struct {
-		path         string
-		wantJSONBody bool
-	}{
-		{path: "/as/64500"},
-		{path: "/prefix/192.0.2.0/24"},
-		{path: "/prefixlength/24"},
-		{path: "/prefixlength6/48"},
-		{path: "/status.json", wantJSONBody: true},
-		{path: "/ip/192.0.2.1", wantJSONBody: true},
-		{path: "/api/v1/stats", wantJSONBody: true},
-		{path: "/api/v1/ip/192.0.2.1", wantJSONBody: true},
-		{path: "/api/v1/as/64500", wantJSONBody: true},
-		{path: "/api/v1/prefix/192.0.2.0/24", wantJSONBody: true},
-	}
-
-	for _, tt := range tests {
-		ctx, cancel := context.WithTimeout(context.Background(), shortRequestDeadline)
-		rec := httptest.NewRecorder()
-		s.router.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, tt.path, nil).WithContext(ctx))
-		cancel()
-
-		if rec.Code != http.StatusGatewayTimeout {
-			t.Errorf("%s: status %d, want %d; body %s", tt.path, rec.Code, http.StatusGatewayTimeout, rec.Body)
-		}
-		if tt.wantJSONBody {
-			checkJSONErrorCode(t, tt.path, rec, http.StatusGatewayTimeout)
-		}
-	}
-}
-
 // checkJSONErrorCode checks that rec holds the JSON error body with the given
 // code.
 func checkJSONErrorCode(t *testing.T, name string, rec *httptest.ResponseRecorder, want int) {

internal/server/middleware.go

@@ -113,13 +113,6 @@ func JSONResponseMiddleware(next http.Handler) http.Handler {
 // requestTimeoutMessage is the error message sent with 504 Gateway Timeout.
 const requestTimeoutMessage = "Request timeout"
 
-// deadlinePassed reports whether ctx ended because its deadline passed. When
-// a handler's database read or other lookup fails, it uses this to tell a
-// request cut off by its time limit, which answers 504, from other failures.
-func deadlinePassed(ctx context.Context) bool {
-	return errors.Is(ctx.Err(), context.DeadlineExceeded)
-}
-
 // JSONValidationMiddleware is an HTTP middleware that validates JSON API responses.
 // It ensures that responses with Content-Type "application/json" contain valid JSON.
 //
@@ -176,7 +169,7 @@ func JSONValidationMiddleware(next http.Handler) http.Handler {
 		if statusCode == http.StatusOK {
 			statusCode = http.StatusInternalServerError
 		}
-		if deadlinePassed(r.Context()) {
+		if errors.Is(r.Context().Err(), context.DeadlineExceeded) {
 			statusCode = http.StatusGatewayTimeout
 		}
 		w.WriteHeader(statusCode)