@@ -0,0 +1 @@
+Retry wheel downloads in `ddev size` on dropped connections and gateway errors, fixing recurring failures in the disk-usage measurement CI job.
@@ -23,13 +23,15 @@
     WrongDependencyFormat,
     compress,
     convert_to_human_readable_size,
+    download_wheel,
     extract_version_from_about_py,
     get_valid_platforms,
     get_valid_versions,
     is_correct_dependency,
     is_valid_integration_file,
     print_table,
     request_wheel,
+    retry_wheel_request,
     save_csv,
     save_json,
     save_markdown,
@@ -588,14 +590,15 @@ def get_dependency_size(
         A CommitEntry with size and metadata for the given dependency and commit.
     """
     if compressed:
-        response = request_wheel(app, download_url, wheels_storage, head=True)
+        response = retry_wheel_request(
+            lambda: request_wheel(app, download_url, wheels_storage, head=True), download_url
+        )
         size_str = response.headers.get("Content-Length")
         if size_str is None:
             raise ValueError(f"Missing size for commit {commit}")
         size = int(size_str)
     else:
-        with request_wheel(app, download_url, wheels_storage) as response:
-            wheel_data = response.content
+        wheel_data = download_wheel(app, download_url, wheels_storage)
 
         with tempfile.TemporaryDirectory() as tmpdir:
             wheel_path = Path(tmpdir) / "package.whl"
 
@@ -12,6 +12,7 @@
 import tempfile
 import zipfile
 import zlib
+from collections.abc import Callable
 from datetime import date
 from types import TracebackType
 from typing import TYPE_CHECKING, Literal, Optional, Type, TypedDict, get_args
@@ -323,6 +324,13 @@ def wheel_url_candidates(url: str, wheels_storage: WheelsStorageTier) -> list[st
     return [resolve_wheel_url(url, tier) for tier in tiers]
 
 
+WHEEL_REQUEST_ATTEMPTS = 4
+WHEEL_REQUEST_RETRY_BACKOFF_SECONDS = 1.0
+WHEEL_REQUEST_TIMEOUT_SECONDS = 30
+
+WHEEL_REQUEST_RETRY_STATUSES = (502, 503, 504)
+
+
 def request_wheel(
     app: Application, url: str, wheels_storage: WheelsStorageTier, head: bool = False
 ) -> requests.Response:
@@ -331,14 +339,19 @@ def request_wheel(
 
     Both 404 and 403 are treated as "not found" and trigger a fallback to the next tier, since the
     dev/stable S3 buckets return 403 instead of 404 for a missing key when the caller can't list the
-    bucket. Any other error status aborts immediately instead of retrying. If every tier fails, the
-    raised error lists all tried tiers, since the URL alone wouldn't reveal that a fallback was
-    attempted.
+    bucket. Any other error status aborts immediately instead of falling back. If every tier fails,
+    the raised error lists all tried tiers, since the URL alone wouldn't reveal that a fallback was
+    attempted. This function makes a single pass over the tiers and never retries; wrap it in
+    `retry_wheel_request` to retry transient failures.
     """
     candidates = wheel_url_candidates(url, wheels_storage)
     tried: list[str] = []
     for index, candidate in enumerate(candidates):
-        response = requests.head(candidate) if head else requests.get(candidate, stream=True)
+        response = (
+            requests.head(candidate, timeout=WHEEL_REQUEST_TIMEOUT_SECONDS)
+            if head
+            else requests.get(candidate, stream=True, timeout=WHEEL_REQUEST_TIMEOUT_SECONDS)
+        )
         try:
             response.raise_for_status()
         except requests.HTTPError as e:
@@ -355,6 +368,50 @@ def request_wheel(
     raise RuntimeError(f"No wheels storage tier served {url}")
 
 
+def is_transient_wheel_error(error: Exception) -> bool:
+    """
+    Whether a failed wheel request or download is worth retrying: a dropped or timed-out connection,
+    a body cut short mid-download, or a gateway error. Every other error status aborts.
+    """
+    if isinstance(error, requests.HTTPError):
+        return error.response is not None and error.response.status_code in WHEEL_REQUEST_RETRY_STATUSES
+    return isinstance(error, (requests.ConnectionError, requests.Timeout, requests.exceptions.ChunkedEncodingError))
+
+
+def retry_wheel_request[T](operation: Callable[[], T], url: str) -> T:
+    """
+    Runs a wheel request or download, retrying it on transient errors with exponential backoff.
+
+    A single attempt budget covers the whole operation, so a failure while connecting, a gateway
+    error and a body cut short all count against the same `WHEEL_REQUEST_ATTEMPTS`.
+    """
+    # Imported here because this module loads on every `ddev` run and `stamina` is only needed for wheels.
+    import stamina
+
+    retrying = stamina.retry(
+        on=is_transient_wheel_error,
+        attempts=WHEEL_REQUEST_ATTEMPTS,
+        timeout=None,
+        wait_initial=WHEEL_REQUEST_RETRY_BACKOFF_SECONDS,
+    )
+    try:
+        return retrying(operation)()
+    except Exception as e:
+        if is_transient_wheel_error(e):
+            e.add_note(f"Wheel request for {url} failed after {WHEEL_REQUEST_ATTEMPTS} attempts")
+        raise
+
+
+def download_wheel(app: Application, url: str, wheels_storage: WheelsStorageTier) -> bytes:
+    """Downloads a wheel's content, retrying the request or the body read on transient errors."""
+
+    def fetch() -> bytes:
+        with request_wheel(app, url, wheels_storage) as response:
+            return response.content
+
+    return retry_wheel_request(fetch, url)
+
+
 def get_dependencies(
     app: Application,
     repo_path: str | Path,
@@ -429,8 +486,7 @@ def get_dependencies_sizes(
     """
     file_data: list[FileDataEntry] = []
     for dep, url, version in zip(deps, download_urls, versions, strict=False):
-        with request_wheel(app, url, wheels_storage) as response:
-            wheel_data = response.content
+        wheel_data = download_wheel(app, url, wheels_storage)
 
         with tempfile.TemporaryDirectory() as tmpdir:
             wheel_path = Path(tmpdir) / "package"
 
@@ -3,16 +3,21 @@
 import os
 import re
 import zipfile
-from unittest.mock import MagicMock, mock_open, patch
+from collections.abc import Iterator
+from unittest.mock import MagicMock, PropertyMock, mock_open, patch
 
 import pytest
 import requests
+import stamina
 
 from ddev.cli.size.utils.common_funcs import (
+    WHEEL_REQUEST_ATTEMPTS,
+    WHEEL_REQUEST_TIMEOUT_SECONDS,
     _matches_gitignore,
     check_python_version,
     compress,
     convert_to_human_readable_size,
+    download_wheel,
     export_format,
     extract_version_from_about_py,
     format_modules,
@@ -26,6 +31,7 @@
     is_correct_dependency,
     is_valid_integration_file,
     request_wheel,
+    retry_wheel_request,
     save_csv,
     save_json,
     save_markdown,
@@ -191,7 +197,11 @@ def test_get_dependencies_sizes():
         )
 
     # The storage tier placeholder must be resolved against the tier passed in, not left as-is.
-    mock_get.assert_called_once_with("https://example.com/dev/dependency1/dependency1-1.1.1-.whl", stream=True)
+    mock_get.assert_called_once_with(
+        "https://example.com/dev/dependency1/dependency1-1.1.1-.whl",
+        timeout=WHEEL_REQUEST_TIMEOUT_SECONDS,
+        stream=True,
+    )
 
     assert file_data == [
         {
@@ -746,4 +756,104 @@ def test_request_wheel_uses_head_when_requested():
     with patch("requests.head", return_value=found) as mock_head:
         assert request_wheel(MagicMock(), PLACEHOLDER_URL, "stable", head=True) is found
 
-    mock_head.assert_called_once_with("https://example.com/stable/built/dep1/dep1-1.1.1-.whl")
+    mock_head.assert_called_once_with(
+        "https://example.com/stable/built/dep1/dep1-1.1.1-.whl", timeout=WHEEL_REQUEST_TIMEOUT_SECONDS
+    )
+
+
+@pytest.fixture
+def instant_retries() -> Iterator[None]:
+    """Skips the backoff between wheel retries while keeping the configured number of attempts."""
+    with stamina.set_testing(True, attempts=100, cap=True):
+        yield
+
+
+def make_streamed_wheel_response(content):
+    response = make_wheel_response(200)
+    response.__enter__.return_value = response
+    type(response).content = PropertyMock(side_effect=[content])
+    return response
+
+
+@pytest.mark.parametrize(
+    "make_failure",
+    [
+        pytest.param(lambda: make_wheel_response(502), id="bad gateway"),
+        pytest.param(lambda: make_wheel_response(503), id="service unavailable"),
+        pytest.param(lambda: make_wheel_response(504), id="gateway timeout"),
+        pytest.param(lambda: requests.exceptions.ConnectionError("Connection reset"), id="connection reset"),
+        pytest.param(lambda: requests.exceptions.ReadTimeout("Read timed out"), id="read timeout"),
+        pytest.param(
+            lambda: make_streamed_wheel_response(requests.exceptions.ChunkedEncodingError("Connection broken")),
+            id="body cut short",
+        ),
+        pytest.param(
+            lambda: make_streamed_wheel_response(requests.exceptions.ConnectionError("Read timed out")),
+            id="body read timeout",
+        ),
+    ],
+)
+def test_download_wheel_retries_transient_errors(instant_retries, make_failure):
+    with patch("requests.get", side_effect=[make_failure(), make_streamed_wheel_response(b"wheel")]) as mock_get:
+        assert download_wheel(MagicMock(), PLACEHOLDER_URL, "dev") == b"wheel"
+
+    assert mock_get.call_count == 2
+
+
+@pytest.mark.parametrize(
+    "status_code, expected_requests",
+    [
+        pytest.param(500, 1, id="server error"),
+        pytest.param(429, 1, id="too many requests"),
+        pytest.param(404, 2, id="not found on every tier"),
+    ],
+)
+def test_download_wheel_does_not_retry_other_errors(instant_retries, status_code, expected_requests):
+    responses = [make_wheel_response(status_code) for _ in range(WHEEL_REQUEST_ATTEMPTS)]
+
+    with patch("requests.get", side_effect=responses) as mock_get:
+        with pytest.raises(requests.HTTPError, match=str(status_code)):
+            download_wheel(MagicMock(), PLACEHOLDER_URL, "dev")
+
+    assert mock_get.call_count == expected_requests
+
+
+def make_failing_responses(kinds):
+    return [
+        make_wheel_response(504)
+        if kind == "gateway error"
+        else make_streamed_wheel_response(requests.exceptions.ChunkedEncodingError("Connection broken"))
+        for kind in kinds
+    ]
+
+
+@pytest.mark.parametrize(
+    "kinds",
+    [
+        pytest.param(["gateway error"] * (WHEEL_REQUEST_ATTEMPTS + 2), id="gateway errors"),
+        pytest.param(["body cut short"] * (WHEEL_REQUEST_ATTEMPTS + 2), id="bodies cut short"),
+        pytest.param(
+            ["gateway error"] * (WHEEL_REQUEST_ATTEMPTS - 1) + ["body cut short"] * 3,
+            id="gateway errors then a body cut short",
+        ),
+    ],
+)
+def test_download_wheel_shares_one_attempt_budget_and_names_the_wheel(instant_retries, kinds):
+    with patch("requests.get", side_effect=make_failing_responses(kinds)) as mock_get:
+        with pytest.raises(requests.RequestException) as excinfo:
+            download_wheel(MagicMock(), PLACEHOLDER_URL, "dev")
+
+    assert mock_get.call_count == WHEEL_REQUEST_ATTEMPTS
+    assert any("dep1-1.1.1-.whl" in note for note in excinfo.value.__notes__)
+
+
+def test_retry_wheel_request_retries_a_head_request(instant_retries):
+    found = make_wheel_response(200)
+
+    with patch("requests.head", side_effect=[make_wheel_response(504), found]) as mock_head:
+        response = retry_wheel_request(
+            lambda: request_wheel(MagicMock(), PLACEHOLDER_URL, "stable", head=True), PLACEHOLDER_URL
+        )
+
+    assert response is found
+    assert mock_head.call_count == 2
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	+Retry wheel downloads in `ddev size` on dropped connections and gateway errors, fixing recurring failures in the disk-usage measurement CI job.