Redirect chains

Layered history. The site moved from http to https, then from apex to www, then restructured its paths. Each change added a rule, and no rule was ever collapsed into the others, so one old URL now hops three times.

Rules that fire in sequence. A trailing-slash rule, a lowercase rule and a locale rule each redirect independently. Any URL that triggers more than one takes a hop per rule.

Third-party layers. A CDN or a proxy adds its own redirect above the origin's, invisible in the application's configuration.

Every hop is a full request: DNS, connection, response. On a mobile connection three hops before the page starts loading is perceptible.

Crawlers follow a limited number of hops. Google documents that it follows up to a small number of redirects in one attempt and treats the chain as not followed beyond that, so a long chain can end with the destination never being reached.

Chains hide breakage. A chain whose final hop starts returning 404 still looks like a redirect at the first hop, so the failure surfaces only to whoever clicks.

A loop is a chain that returns to a URL it already visited: A redirects to B, B redirects back to A. Browsers stop after a number of attempts and show an error, so the page is simply unreachable.

The usual cause is two rules disagreeing — one forcing a trailing slash, another removing it — or a canonical-host rule and a locale rule each rewriting the other's output.

`curl -I -L <url>` follows redirects and prints the status and `Location` of every hop. The number of `HTTP/…` lines is the length of the chain.

Test the shapes that produce chains rather than random URLs: http instead of https, the other host, with and without a trailing slash, an old path you know was moved, and an uppercase path.

A chain of one is normal and correct. Two is worth flattening. Three or more is a configuration that has accumulated rather than been designed.

Redirect directly to the final destination. If `/old` eventually reaches `/new`, make `/old` point at `/new` in one hop, even though the intermediate rules stay in place for other URLs.

Order the rules so the most general runs first: force the protocol and the host in a single rule, then apply path rules to the already-normalised URL.

Update your own internal links to point at the final URL. A redirect exists for links you do not control; your own should not need it.

Use 301 for permanent moves and 302 only when the move really is temporary. A 302 left in place for years tells search engines to keep the old URL indexed.

`transport.redirect_chain` follows the redirects for the URLs the crawler encounters and reports the chains with each hop, so the shape is visible rather than only the length.

`transport.http_redirect` and `transport.canonical_host` check the two rules that cause most chains: whether http reaches https, and whether the host variants converge on one address.

`availability.redirect_loop` reports the loop case separately, because it is not a slow page — it is an unreachable one.

A chain is load-bearing more often than it looks, and collapsing it carelessly turns a slow URL into a dead one.

Change the entry point, not the exit. Point `/old` at the final destination and leave the intermediate rules alone — other URLs enter the chain partway along and still need them.

Work out which layer issues each hop before editing anything. A hop from a CDN page rule and a hop from a server rewrite look identical in `curl` output and live in different systems, and editing the wrong one produces no change at all — which is usually diagnosed as caching and waited out.

Do it in one direction at a time. Protocol first, then host, then path: three rules changed together produce a loop more often than not, and the loop is worse than the chain was.

Re-test the whole matrix afterwards, not the URL you were working on. Both protocols, both hosts, with and without trailing slash, a deep path and an old path. Chain fixes break neighbouring cases routinely.

And keep the intermediate redirects permanently. Deleting a redirect because its chain was flattened breaks every external link and bookmark still entering at that point, which converts a latency problem into a 404.