Reconnect when RIS Live ends or stalls the stream (closes #53)

Only Stop now ends the reconnect loop. A stream that ends any other way,
with or without an error, marks the feed disconnected and reconnects with
the existing backoff. Before, a response RIS Live ended normally stopped
the loop for good while the health check kept reporting ok.

The streamer also drops the connection when no line arrives for 60
seconds; each line starts that limit over, and it also bounds the wait
for RIS Live to answer. The idle limit and the first backoff delay are
fields so the tests, against a local server, run in well under a second.
The README's Reconnection note describes this behaviour.

Model: opus-5-5

README.md

@@ -141,12 +141,14 @@ routewatch/
 - **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
+- **Reconnection**: Any end of the stream other than shutdown, including RIS Live
+  ending the response normally, marks the feed disconnected and reconnects with
+  exponential backoff (5s-320s). The backoff resets after a stream that lasted
+  more than 30s. A stream with no line for 60s is dropped and reconnected.
 - **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
-  text form Go's `net/netip` prints. Routes shorter than /8 for IPv4 or /16
-  for IPv6, such as a default route, are not used.
+  (at most 33 lookups for IPv4, 129 for IPv6); prefixes are stored in the
+  text form Go's `net/netip` prints
 
 ### 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
-// minLookupMaskLengthV4 or minLookupMaskLengthV6 it looks up the address's
-// network prefix at that length, and the first length with a live route wins.
-// That is at most 25 or 113 indexed lookups, however many routes are live. The
-// prefix is looked up in the text form net/netip prints, which is the form the
-// prefix handler stores.
+// the prefix index: for each mask length from the longest (32 or 128) down to 0
+// it looks up the address's network prefix at that length, and the first length
+// with a live route wins. That is at most 33 or 129 indexed lookups, however
+// many routes are live. The prefix is looked up in the text form net/netip
+// prints, which is the form the 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/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
-	// 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()
-		}
-	}
-
+	// Process announcements
 	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.
-	// Updates from different peers for the same prefix are all kept. Arrival
-	// order decides, not the timestamp: timestamps are whole seconds, so
-	// updates within one second carry the same one.
-	type prefixAndPeer struct{ prefix, peer string }
-	lastUpdates := make(map[prefixAndPeer]prefixUpdate)
+	// Group updates by prefix to deduplicate
+	// For each prefix, keep the latest update
+	prefixMap := make(map[string]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"
@@ -201,16 +200,12 @@ func (s *Server) handleStatusJSON() http.HandlerFunc {
 		select {
 		case <-ctx.Done():
 			s.logger.Error("Database stats timeout in status.json")
-			writeJSONError(w, http.StatusGatewayTimeout, requestTimeoutMessage)
+			writeJSONError(w, http.StatusRequestTimeout, "Database timeout")
 
 			return
 		case err := <-errChan:
 			s.logger.Error("Failed to get database stats", "error", err)
-			if deadlinePassed(ctx) {
-				writeJSONError(w, http.StatusGatewayTimeout, requestTimeoutMessage)
-			} else {
-				writeJSONError(w, http.StatusInternalServerError, err.Error())
-			}
+			writeJSONError(w, http.StatusInternalServerError, err.Error())
 
 			return
 		case dbStats = <-statsChan:
@@ -390,7 +385,7 @@ func (s *Server) handleStats() http.HandlerFunc {
 		// Check if context is already cancelled
 		select {
 		case <-ctx.Done():
-			writeJSONError(w, http.StatusGatewayTimeout, requestTimeoutMessage)
+			http.Error(w, "Request timeout", http.StatusRequestTimeout)
 
 			return
 		default:
@@ -419,16 +414,11 @@ func (s *Server) handleStats() http.HandlerFunc {
 		select {
 		case <-ctx.Done():
 			s.logger.Error("Database stats timeout")
-			writeJSONError(w, http.StatusGatewayTimeout, requestTimeoutMessage)
-
+			// Don't write response here - timeout middleware already handles it
 			return
 		case err := <-errChan:
 			s.logger.Error("Failed to get database stats", "error", err)
-			if deadlinePassed(ctx) {
-				writeJSONError(w, http.StatusGatewayTimeout, requestTimeoutMessage)
-			} else {
-				writeJSONError(w, http.StatusInternalServerError, err.Error())
-			}
+			writeJSONError(w, http.StatusInternalServerError, err.Error())
 
 			return
 		case dbStats = <-statsChan:
@@ -631,13 +621,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 +663,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 +702,9 @@ func (s *Server) handleASDetailJSON() http.HandlerFunc {
 
 		asInfo, prefixes, err := s.db.GetASDetailsContext(r.Context(), asn)
 		if err != nil {
-			switch {
-			case errors.Is(err, database.ErrNoRoute):
+			if errors.Is(err, database.ErrNoRoute) {
 				writeJSONError(w, http.StatusNotFound, err.Error())
-			case deadlinePassed(r.Context()):
-				writeJSONError(w, http.StatusGatewayTimeout, requestTimeoutMessage)
-			default:
+			} else {
 				writeJSONError(w, http.StatusInternalServerError, err.Error())
 			}
 
@@ -775,24 +748,14 @@ func (s *Server) handlePrefixDetailJSON() http.HandlerFunc {
 			return
 		}
 
-		// Look the prefix up in the text form net/netip prints, the form the
-		// tables store, so that any valid way of writing it finds the route.
-		parsed, err := netip.ParsePrefix(prefixParam + "/" + lenParam)
-		if err != nil {
-			writeJSONError(w, http.StatusBadRequest, err.Error())
-
-			return
-		}
-		prefix := parsed.Masked().String()
+		// Combine prefix and length into CIDR notation
+		prefix := prefixParam + "/" + lenParam
 
 		routes, err := s.db.GetPrefixDetailsContext(r.Context(), prefix)
 		if err != nil {
-			switch {
-			case errors.Is(err, database.ErrNoRoute):
+			if errors.Is(err, database.ErrNoRoute) {
 				writeJSONError(w, http.StatusNotFound, err.Error())
-			case deadlinePassed(r.Context()):
-				writeJSONError(w, http.StatusGatewayTimeout, requestTimeoutMessage)
-			default:
+			} else {
 				writeJSONError(w, http.StatusInternalServerError, err.Error())
 			}
 
@@ -832,12 +795,9 @@ func (s *Server) handleASDetail() http.HandlerFunc {
 
 		asInfo, prefixes, err := s.db.GetASDetailsContext(r.Context(), asn)
 		if err != nil {
-			switch {
-			case errors.Is(err, database.ErrNoRoute):
+			if errors.Is(err, database.ErrNoRoute) {
 				http.Error(w, "AS not found", http.StatusNotFound)
-			case deadlinePassed(r.Context()):
-				http.Error(w, requestTimeoutMessage, http.StatusGatewayTimeout)
-			default:
+			} else {
 				s.logger.Error("Failed to get AS details", "error", err)
 				http.Error(w, "Internal server error", http.StatusInternalServerError)
 			}
@@ -952,24 +912,14 @@ func (s *Server) handlePrefixDetail() http.HandlerFunc {
 			return
 		}
 
-		// Look the prefix up in the text form net/netip prints, the form the
-		// tables store, so that any valid way of writing it finds the route.
-		parsed, err := netip.ParsePrefix(prefixParam + "/" + lenParam)
-		if err != nil {
-			http.Error(w, "Invalid prefix", http.StatusBadRequest)
-
-			return
-		}
-		prefix := parsed.Masked().String()
+		// Combine prefix and length into CIDR notation
+		prefix := prefixParam + "/" + lenParam
 
 		routes, err := s.db.GetPrefixDetailsContext(r.Context(), prefix)
 		if err != nil {
-			switch {
-			case errors.Is(err, database.ErrNoRoute):
+			if errors.Is(err, database.ErrNoRoute) {
 				http.Error(w, "Prefix not found", http.StatusNotFound)
-			case deadlinePassed(r.Context()):
-				http.Error(w, requestTimeoutMessage, http.StatusGatewayTimeout)
-			default:
+			} else {
 				s.logger.Error("Failed to get prefix details", "error", err)
 				http.Error(w, "Internal server error", http.StatusInternalServerError)
 			}
@@ -1123,12 +1073,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()) {
-				http.Error(w, requestTimeoutMessage, http.StatusGatewayTimeout)
-			} else {
-				s.logger.Error("Failed to get prefixes by length", "error", err)
-				http.Error(w, "Internal server error", http.StatusInternalServerError)
-			}
+			s.logger.Error("Failed to get prefixes by length", "error", err)
+			http.Error(w, "Internal server error", http.StatusInternalServerError)
 
 			return
 		}
@@ -1218,12 +1164,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()) {
-				http.Error(w, requestTimeoutMessage, http.StatusGatewayTimeout)
-			} else {
-				s.logger.Error("Failed to get prefixes by length", "error", err)
-				http.Error(w, "Internal server error", http.StatusInternalServerError)
-			}
+			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,231 +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.
-const shortRequestDeadline = 50 * time.Millisecond
-
-// TestRequestPastTimeLimitAnswers504 sends a request through the server's
-// router to a page and to a JSON route whose handlers wait for the time limit
-// to pass and return without answering. The page answers 504; the JSON route
-// answers 504 with the JSON error body. Before the fix both answered 408,
-// written by the time limit middleware from its own goroutine while the
-// handler could still be writing.
-func TestRequestPastTimeLimitAnswers504(t *testing.T) {
-	s := New(nil, streamer.New(logger.New(), metrics.New()), logger.New(), &config.Config{})
-
-	waitForTimeLimit := func(_ http.ResponseWriter, r *http.Request) {
-		<-r.Context().Done()
-	}
-	// Registered the way setupRoutes registers pages and JSON routes.
-	s.router.Get("/slow-page", waitForTimeLimit)
-	s.router.Get("/slow.json", JSONValidationMiddleware(http.HandlerFunc(waitForTimeLimit)).ServeHTTP)
-
-	tests := []struct {
-		path         string
-		wantJSONBody bool
-	}{
-		{path: "/slow-page"},
-		{path: "/slow.json", 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)
-		}
-	}
-}
-
-// TestStatsHandlersAnswer504WhenDatabaseReadRunsOut calls each stats handler
-// with a store that does not answer before the handler's 4-second limit runs
-// out, and checks that the handler itself answers 504 with the JSON error
-// body. Before the fix status.json answered 408, and /api/v1/stats wrote
-// nothing, which the JSON check on its route turned into 500.
-func TestStatsHandlersAnswer504WhenDatabaseReadRunsOut(t *testing.T) {
-	release := make(chan struct{})
-	defer close(release)
-	db := blockingStatsDB{release: release}
-	s := New(db, streamer.New(logger.New(), metrics.New()), logger.New(), &config.Config{})
-
-	handlers := map[string]http.HandlerFunc{
-		"status.json": s.handleStatusJSON(),
-		"stats":       s.handleStats(),
-	}
-
-	for name, handler := range handlers {
-		ctx, cancel := context.WithTimeout(context.Background(), shortRequestDeadline)
-		rec := httptest.NewRecorder()
-		handler(rec, httptest.NewRequest(http.MethodGet, "/", nil).WithContext(ctx))
-		cancel()
-
-		if rec.Code != http.StatusGatewayTimeout {
-			t.Errorf("%s: status %d, want %d; body %s", name, rec.Code, http.StatusGatewayTimeout, rec.Body)
-		}
-		checkJSONErrorCode(t, name, rec, http.StatusGatewayTimeout)
-	}
-}
-
-// 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) {
-	t.Helper()
-
-	var body struct {
-		Status string `json:"status"`
-		Error  struct {
-			Code int `json:"code"`
-		} `json:"error"`
-	}
-	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
-		t.Errorf("%s: decoding the answer %q: %v", name, rec.Body, err)
-
-		return
-	}
-	if body.Status != "error" || body.Error.Code != want {
-		t.Errorf("%s: answer %s, want status \"error\" and error code %d", name, rec.Body, want)
-	}
-}
-
 // settledGoroutineCount lets transient goroutines finish, then reports the
 // current count.
 func settledGoroutineCount() int {

internal/server/middleware.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"log/slog"
 	"net/http"
@@ -110,24 +109,142 @@ func JSONResponseMiddleware(next http.Handler) http.Handler {
 	})
 }
 
-// requestTimeoutMessage is the error message sent with 504 Gateway Timeout.
-const requestTimeoutMessage = "Request timeout"
+// timeoutWriter wraps ResponseWriter to prevent concurrent writes after timeout
+type timeoutWriter struct {
+	http.ResponseWriter
+	mu      sync.Mutex
+	written bool
+	header  http.Header // cached header to prevent concurrent access
+}
 
-// 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)
+func (tw *timeoutWriter) Write(b []byte) (int, error) {
+	tw.mu.Lock()
+	defer tw.mu.Unlock()
+
+	if tw.written {
+		return 0, nil // Discard writes after timeout
+	}
+
+	return tw.ResponseWriter.Write(b)
+}
+
+func (tw *timeoutWriter) WriteHeader(statusCode int) {
+	tw.mu.Lock()
+	defer tw.mu.Unlock()
+
+	if tw.written {
+		return // Discard writes after timeout
+	}
+
+	tw.ResponseWriter.WriteHeader(statusCode)
+}
+
+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()
+}
+
+func (tw *timeoutWriter) markWritten() {
+	tw.mu.Lock()
+	defer tw.mu.Unlock()
+	tw.written = true
+}
+
+// TimeoutMiddleware creates an HTTP middleware that enforces a request timeout.
+// 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()
+
+			ctx, cancel := context.WithTimeout(r.Context(), timeout)
+			defer cancel()
+
+			tw := &timeoutWriter{
+				ResponseWriter: w,
+				header:         make(http.Header),
+			}
+
+			done := make(chan struct{})
+			panicChan := make(chan interface{}, 1)
+
+			go func() {
+				defer func() {
+					if p := recover(); p != nil {
+						panicChan <- p
+					}
+				}()
+
+				next.ServeHTTP(tw, r.WithContext(ctx))
+				close(done)
+			}()
+
+			select {
+			case p := <-panicChan:
+				panic(p)
+			case <-done:
+				return
+			case <-ctx.Done():
+				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",
+					"error": map[string]interface{}{
+						"msg":  "Request timeout",
+						"code": http.StatusRequestTimeout,
+					},
+					"@meta": map[string]interface{}{
+						"time_zone":      "UTC",
+						"api_version":    1,
+						"execution_time": fmt.Sprintf("%d ms", execTime.Milliseconds()),
+					},
+				}
+
+				_ = json.NewEncoder(w).Encode(response)
+			}
+		})
+	}
 }
 
 // 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. If the request's time limit
-// has passed, it answers 504 with the error message "Request timeout". For other
-// errors, it returns "Internal server error" with status 500 if the original
-// status was 200.
+// 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 {
@@ -176,14 +293,11 @@ func JSONValidationMiddleware(next http.Handler) http.Handler {
 		if statusCode == http.StatusOK {
 			statusCode = http.StatusInternalServerError
 		}
-		if deadlinePassed(r.Context()) {
-			statusCode = http.StatusGatewayTimeout
-		}
 		w.WriteHeader(statusCode)
 
 		errorMsg := "Internal server error"
-		if statusCode == http.StatusGatewayTimeout {
-			errorMsg = requestTimeoutMessage
+		if statusCode == http.StatusRequestTimeout {
+			errorMsg = "Request timeout"
 		}
 
 		response := map[string]interface{}{

internal/server/routes.go

@@ -16,12 +16,9 @@ func (s *Server) setupRoutes() {
 	r.Use(middleware.RealIP)
 	r.Use(RequestLoggerMiddleware(s.logger.Logger)) // Structured request logging
 	r.Use(middleware.Recoverer)
-	r.Use(JSONResponseMiddleware)
-	// Timeout must come after JSONResponseMiddleware, which sends its answer
-	// when the handler returns and would send a 200 ahead of Timeout's 504 for
-	// a handler that wrote nothing.
 	const requestTimeout = 30 * time.Second // Increased from 8s for slow queries
-	r.Use(middleware.Timeout(requestTimeout))
+	r.Use(TimeoutMiddleware(requestTimeout, s.logger.Logger))
+	r.Use(JSONResponseMiddleware)
 
 	// Routes
 	r.Get("/", s.handleIndex())

internal/streamer/streamer.go

@@ -7,6 +7,7 @@ import (
 	"compress/gzip"
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"math"
@@ -48,6 +49,7 @@ const (
 	metricsUpdateRate     = time.Second
 	minBackoffDelay       = 5 * time.Second
 	maxBackoffDelay       = 320 * time.Second
+	streamIdleTimeout     = 60 * time.Second // Reconnect when no line arrives for this long
 	metricsLogInterval    = 10 * time.Second
 	bytesPerKB            = 1024
 	bytesPerMB            = 1024 * 1024
@@ -58,6 +60,9 @@ const (
 	backpressureSlope     = 2.0 // Slope for linear drop probability increase
 )
 
+// errStreamEnded is returned by stream when RIS Live ends the response.
+var errStreamEnded = errors.New("RIS Live ended the stream")
+
 // 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.
@@ -107,6 +112,8 @@ type Streamer struct {
 	logger       *logger.Logger
 	client       *http.Client
 	url          string
+	idleTimeout  time.Duration // Drop the connection when no line arrives for this long
+	minBackoff   time.Duration // First wait before reconnecting; doubles up to maxBackoffDelay
 	handlers     []*handlerInfo
 	rawHandler   RawMessageHandler
 	mu           sync.RWMutex
@@ -124,8 +131,10 @@ type Streamer struct {
 // 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,
-		url:    risLiveURL,
+		logger:      logger,
+		url:         risLiveURL,
+		idleTimeout: streamIdleTimeout,
+		minBackoff:  minBackoffDelay,
 		client: &http.Client{
 			Timeout: 0, // No timeout for streaming
 			Transport: &http.Transport{
@@ -405,7 +414,7 @@ func (s *Streamer) updateMetrics(messageBytes int) {
 
 // streamWithReconnect handles streaming with automatic reconnection and exponential backoff
 func (s *Streamer) streamWithReconnect(ctx context.Context) {
-	backoffDelay := minBackoffDelay
+	backoffDelay := s.minBackoff
 	consecutiveFailures := 0
 
 	for {
@@ -422,8 +431,9 @@ func (s *Streamer) streamWithReconnect(ctx context.Context) {
 		err := s.stream(ctx)
 		streamDuration := time.Since(startTime)
 
-		if err == nil {
-			// Clean exit (context cancelled)
+		// Only Stop ends the streamer. A stream that ends any other way,
+		// with or without an error, is a disconnect and is reconnected.
+		if ctx.Err() != nil {
 			return
 		}
 
@@ -434,17 +444,13 @@ func (s *Streamer) streamWithReconnect(ctx context.Context) {
 			"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
+		// A stream that lasted more than 30 seconds resets the backoff. That
+		// includes a stream dropped after streamIdleTimeout with no line, so
+		// a silent feed is retried after the first backoff delay every time.
 		if streamDuration > 30*time.Second {
 			s.logger.Info("Resetting backoff delay due to successful connection",
 				"stream_duration", streamDuration)
-			backoffDelay = minBackoffDelay
+			backoffDelay = s.minBackoff
 			consecutiveFailures = 0
 		} else {
 			// Increment consecutive failures
@@ -477,7 +483,13 @@ func (s *Streamer) stream(ctx context.Context) error {
 	connCtx, connCancel := context.WithCancel(ctx)
 	defer connCancel()
 
-	req, err := http.NewRequestWithContext(ctx, "GET", s.url, nil)
+	// The idle timer drops the connection, by cancelling connCtx, when no
+	// line arrives for s.idleTimeout. Each line read starts it over. It
+	// also covers the wait for the server to answer.
+	idleTimer := time.AfterFunc(s.idleTimeout, connCancel)
+	defer idleTimer.Stop()
+
+	req, err := http.NewRequestWithContext(connCtx, "GET", s.url, nil)
 	if err != nil {
 		return fmt.Errorf("failed to create request: %w", err)
 	}
@@ -559,6 +571,8 @@ func (s *Streamer) stream(ctx context.Context) error {
 	scanner := bufio.NewScanner(reader)
 
 	for scanner.Scan() {
+		idleTimer.Reset(s.idleTimeout)
+
 		select {
 		case <-ctx.Done():
 			s.logger.Info("Stream stopped by context")
@@ -707,11 +721,19 @@ func (s *Streamer) stream(ctx context.Context) error {
 		s.mu.RUnlock()
 	}
 
+	if ctx.Err() != nil {
+		return ctx.Err()
+	}
+
+	if connCtx.Err() != nil {
+		return fmt.Errorf("no line received for %s", s.idleTimeout)
+	}
+
 	if err := scanner.Err(); err != nil {
 		return fmt.Errorf("scanner error: %w", err)
 	}
 
-	return nil
+	return errStreamEnded
 }
 
 // shouldDropForBackpressure determines if a message should be dropped based on queue utilization

internal/streamer/streamer_test.go

@@ -7,6 +7,7 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"runtime"
+	"sync/atomic"
 	"testing"
 	"time"
 
@@ -39,6 +40,14 @@ func TestNewStreamer(t *testing.T) {
 	if s.metrics != metricsTracker {
 		t.Error("metrics tracker not set correctly")
 	}
+
+	if s.idleTimeout != streamIdleTimeout {
+		t.Errorf("idleTimeout = %s, want %s", s.idleTimeout, streamIdleTimeout)
+	}
+
+	if s.minBackoff != minBackoffDelay {
+		t.Errorf("minBackoff = %s, want %s", s.minBackoff, minBackoffDelay)
+	}
 }
 
 // TestStreamDoesNotLeakTickersAcrossReconnects drives many short-lived
@@ -57,8 +66,8 @@ func TestStreamDoesNotLeakTickersAcrossReconnects(t *testing.T) {
 
 	// One warm-up connection so any persistent HTTP transport goroutine exists
 	// before we take the baseline.
-	if err := s.stream(context.Background()); err != nil {
-		t.Fatalf("warm-up stream returned error: %v", err)
+	if err := s.stream(context.Background()); !errors.Is(err, errStreamEnded) {
+		t.Fatalf("warm-up stream returned %v, want %v", err, errStreamEnded)
 	}
 	s.client.CloseIdleConnections()
 
@@ -66,8 +75,8 @@ func TestStreamDoesNotLeakTickersAcrossReconnects(t *testing.T) {
 
 	const reconnects = 20
 	for range reconnects {
-		if err := s.stream(context.Background()); err != nil {
-			t.Fatalf("stream returned error: %v", err)
+		if err := s.stream(context.Background()); !errors.Is(err, errStreamEnded) {
+			t.Fatalf("stream returned %v, want %v", err, errStreamEnded)
 		}
 	}
 	s.client.CloseIdleConnections()
@@ -78,23 +87,35 @@ func TestStreamDoesNotLeakTickersAcrossReconnects(t *testing.T) {
 	}
 }
 
-// updateHandler wants UPDATE messages and does nothing with them.
-type updateHandler struct{}
+// updateLine is one UPDATE message as RIS Live sends it.
+const updateLine = `{"type":"ris_message","data":{"type":"UPDATE","peer":"192.0.2.1",` +
+	`"peer_asn":"64496","timestamp":1700000000}}` + "\n"
+
+// updateHandler wants UPDATE messages. For each one it handles it sends on
+// handled if there is room, and otherwise does nothing; a nil handled is
+// never sent on.
+type updateHandler struct {
+	handled chan struct{}
+}
 
 func (updateHandler) WantsMessage(messageType string) bool { return messageType == "UPDATE" }
-func (updateHandler) HandleMessage(*ristypes.RISMessage)   {}
 func (updateHandler) QueueCapacity() int                   { return 10 }
 
+func (h updateHandler) HandleMessage(*ristypes.RISMessage) {
+	select {
+	case h.handled <- struct{}{}:
+	default:
+	}
+}
+
 // TestStopBeforeMessageReachesQueues stops the streamer after the read loop
 // has checked for cancellation but before it hands the message to the handler
 // queues. That is the gap a stop from another goroutine can land in, and it
 // used to end in "send on closed channel". The raw handler runs in that gap on
 // the read loop itself, so calling Stop from it hits the gap every time.
 func TestStopBeforeMessageReachesQueues(t *testing.T) {
-	const line = `{"type":"ris_message","data":{"type":"UPDATE","peer":"192.0.2.1",` +
-		`"peer_asn":"64496","timestamp":1700000000}}` + "\n"
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		_, _ = io.WriteString(w, line)
+		_, _ = io.WriteString(w, updateLine)
 	}))
 	defer srv.Close()
 
@@ -117,6 +138,117 @@ func TestStopBeforeMessageReachesQueues(t *testing.T) {
 	s.Stop()
 }
 
+// TestReconnectWhenStreamEnds has the server end the first response
+// normally, as when RIS Live restarts. The streamer must treat that as a
+// disconnect and connect again.
+func TestReconnectWhenStreamEnds(t *testing.T) {
+	endResponse := func(http.ResponseWriter, *http.Request) {}
+	checkReconnect(t, endResponse, streamIdleTimeout)
+}
+
+// TestReconnectWhenStreamGoesIdle has the server hold the first response
+// open without sending anything. The streamer must drop it once the idle
+// timeout passes and connect again.
+func TestReconnectWhenStreamGoesIdle(t *testing.T) {
+	const idleTimeout = 50 * time.Millisecond
+	holdResponse := func(w http.ResponseWriter, r *http.Request) {
+		w.(http.Flusher).Flush()
+		<-r.Context().Done()
+	}
+	checkReconnect(t, holdResponse, idleTimeout)
+}
+
+// TestReconnectWhenServerNeverAnswers has the server accept the first
+// request and never answer it, not even with headers. The streamer must give
+// up on it once the idle timeout passes and connect again.
+func TestReconnectWhenServerNeverAnswers(t *testing.T) {
+	const idleTimeout = 50 * time.Millisecond
+	neverAnswer := func(_ http.ResponseWriter, r *http.Request) {
+		<-r.Context().Done()
+	}
+	checkReconnect(t, neverAnswer, idleTimeout)
+}
+
+// TestStreamNotDroppedWhileLinesArrive has the server send lines well within
+// the idle timeout for several times the timeout, then end the response. Each
+// line must start the idle timeout over, so the stream lasts until the server
+// ends it instead of being dropped as idle.
+func TestStreamNotDroppedWhileLinesArrive(t *testing.T) {
+	const (
+		idleTimeout  = 100 * time.Millisecond
+		lineInterval = idleTimeout / 10
+		sendFor      = 5 * idleTimeout
+	)
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		deadline := time.Now().Add(sendFor)
+		for time.Now().Before(deadline) {
+			_, _ = io.WriteString(w, updateLine)
+			w.(http.Flusher).Flush()
+			time.Sleep(lineInterval)
+		}
+	}))
+	defer srv.Close()
+
+	s := New(logger.New(), metrics.New())
+	s.url = srv.URL
+	s.idleTimeout = idleTimeout
+
+	if err := s.stream(context.Background()); !errors.Is(err, errStreamEnded) {
+		t.Fatalf("stream returned %v, want %v", err, errStreamEnded)
+	}
+}
+
+// checkReconnect runs a streamer against a fake RIS Live server. The first
+// response is served by firstResponse; every later one carries one UPDATE
+// line and then stays open. The streamer must come back for a second
+// response, must not be marked connected when it does, and must handle the
+// UPDATE in it.
+func checkReconnect(t *testing.T, firstResponse http.HandlerFunc, idleTimeout time.Duration) {
+	t.Helper()
+
+	const maxWait = 5 * time.Second
+
+	tracker := metrics.New()
+	connectedAtReconnect := make(chan bool, 1)
+	var requests atomic.Int32
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if requests.Add(1) == 1 {
+			firstResponse(w, r)
+
+			return
+		}
+		select {
+		case connectedAtReconnect <- tracker.IsConnected():
+		default:
+		}
+		_, _ = io.WriteString(w, updateLine)
+		w.(http.Flusher).Flush()
+		<-r.Context().Done()
+	}))
+	defer srv.Close()
+
+	s := New(logger.New(), tracker)
+	s.url = srv.URL
+	s.idleTimeout = idleTimeout
+	s.minBackoff = time.Millisecond
+	handler := updateHandler{handled: make(chan struct{}, 1)}
+	s.RegisterHandler(handler)
+	if err := s.Start(); err != nil {
+		t.Fatalf("Start returned error: %v", err)
+	}
+	defer s.Stop()
+
+	select {
+	case <-handler.handled:
+	case <-time.After(maxWait):
+		t.Fatalf("no message from a second response handled within %s", maxWait)
+	}
+
+	if <-connectedAtReconnect {
+		t.Error("streamer was still marked connected when it came back for a second response")
+	}
+}
+
 // settledGoroutineCount lets transient goroutines finish, then reports the
 // current count.
 func settledGoroutineCount() int {