[Core] Update aiohttp transport timeout errors (#41227)

* Update aiohttp transport timeout errors

* Make backwards compatible

* Added tests

* Fix black

* Feedback

* Version bump + changelog

Author: annatisch

sdk/core/azure-core/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Release History
 
-## 1.34.1 (Unreleased)
+## 1.35.0 (Unreleased)
 
 ### Features Added
 
@@ -10,6 +10,9 @@
 
 ### Other Changes
 
+- A timeout error when using the `aiohttp` transport (the default for async SDKs) will now be raised as a `azure.core.exceptions.ServiceResponseTimeoutError`, a subtype of the previously raised `ServiceResponseError`.
+- When using with `aiohttp` 3.10 or later, a connection timeout error will now be raised as a `azure.core.exceptions.ServiceRequestTimeoutError`, which can be retried.
+
 ## 1.34.0 (2025-05-01)
 
 ### Features Added

sdk/core/azure-core/azure/core/_version.py

@@ -9,4 +9,4 @@
 # regenerated.
 # --------------------------------------------------------------------------
 
-VERSION = "1.34.1"
+VERSION = "1.35.0"

sdk/core/azure-core/azure/core/pipeline/transport/_aiohttp.py

@@ -49,7 +49,9 @@
 from azure.core.configuration import ConnectionConfiguration
 from azure.core.exceptions import (
     ServiceRequestError,
+    ServiceRequestTimeoutError,
     ServiceResponseError,
+    ServiceResponseTimeoutError,
     IncompleteReadError,
 )
 from azure.core.pipeline import AsyncPipeline
@@ -76,6 +78,15 @@
 CONTENT_CHUNK_SIZE = 10 * 1024
 _LOGGER = logging.getLogger(__name__)
 
+try:
+    # ConnectionTimeoutError was only introduced in aiohttp 3.10 so we want to keep this
+    # backwards compatible. If client is using aiohttp <3.10, the behaviour will safely
+    # fall back to treating a TimeoutError as a ServiceResponseError (that wont be retried).
+    from aiohttp.client_exceptions import ConnectionTimeoutError
+except ImportError:
+
+    class ConnectionTimeoutError(Exception): ...  # type: ignore[no-redef]
+
 
 class AioHttpTransport(AsyncHttpTransport):
     """AioHttp HTTP sender implementation.
@@ -344,8 +355,10 @@ async def send(
             raise
         except aiohttp.client_exceptions.ClientResponseError as err:
             raise ServiceResponseError(err, error=err) from err
+        except ConnectionTimeoutError as err:
+            raise ServiceRequestTimeoutError(err, error=err) from err
         except asyncio.TimeoutError as err:
-            raise ServiceResponseError(err, error=err) from err
+            raise ServiceResponseTimeoutError(err, error=err) from err
         except aiohttp.client_exceptions.ClientError as err:
             raise ServiceRequestError(err, error=err) from err
         return response

sdk/core/azure-core/tests/async_tests/test_basic_transport_async.py

@@ -14,10 +14,19 @@
 from azure.core.rest._http_response_impl_async import AsyncHttpResponseImpl as RestAsyncHttpResponse
 from azure.core.pipeline.policies import HeadersPolicy
 from azure.core.pipeline import AsyncPipeline
-from azure.core.exceptions import HttpResponseError, ServiceResponseError
+from azure.core.exceptions import (
+    HttpResponseError,
+    ServiceResponseError,
+    ServiceRequestError,
+    ServiceRequestTimeoutError,
+    ServiceResponseTimeoutError,
+)
 from utils import HTTP_REQUESTS, request_and_responses_product
 import pytest
 import sys
+import asyncio
+from unittest.mock import Mock
+from pkg_resources import parse_version
 import aiohttp
 
 
@@ -1038,3 +1047,49 @@ async def test_close_too_soon_works_fine(caplog, port, http_request):
     result = await transport.send(request)
 
     assert result  # No exception is good enough here
+
+
+@pytest.mark.skipif(
+    parse_version(aiohttp.__version__) >= parse_version("3.10"),
+    reason="aiohttp 3.10 introduced separate connection timeout",
+)
+@pytest.mark.parametrize("http_request", HTTP_REQUESTS)
+@pytest.mark.asyncio
+async def test_aiohttp_timeout_response(http_request):
+    async with AioHttpTransport() as transport:
+        transport.session._connector.connect = Mock(side_effect=asyncio.TimeoutError("Too slow!"))
+
+        request = http_request("GET", f"http://localhost:12345/basic/string")
+
+        with pytest.raises(ServiceResponseTimeoutError) as err:
+            await transport.send(request)
+
+        with pytest.raises(ServiceResponseError) as err:
+            await transport.send(request)
+
+        stream_request = http_request("GET", f"http://localhost:12345/streams/basic")
+        with pytest.raises(ServiceResponseTimeoutError) as err:
+            await transport.send(stream_request, stream=True)
+
+
+@pytest.mark.skipif(
+    parse_version(aiohttp.__version__) < parse_version("3.10"),
+    reason="aiohttp 3.10 introduced separate connection timeout",
+)
+@pytest.mark.parametrize("http_request", HTTP_REQUESTS)
+@pytest.mark.asyncio
+async def test_aiohttp_timeout_request(http_request):
+    async with AioHttpTransport() as transport:
+        transport.session._connector.connect = Mock(side_effect=asyncio.TimeoutError("Too slow!"))
+
+        request = http_request("GET", f"http://localhost:12345/basic/string")
+
+        with pytest.raises(ServiceRequestTimeoutError) as err:
+            await transport.send(request)
+
+        with pytest.raises(ServiceRequestError) as err:
+            await transport.send(request)
+
+        stream_request = http_request("GET", f"http://localhost:12345/streams/basic")
+        with pytest.raises(ServiceRequestTimeoutError) as err:
+            await transport.send(stream_request, stream=True)