corehttp 1.0.0b5__py3-none-any.whl → 1.0.0b7__py3-none-any.whl

corehttp/instrumentation/tracing/opentelemetry.py

@@ -0,0 +1,277 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+from __future__ import annotations
+from contextlib import contextmanager
+from contextvars import Token
+from typing import Any, Optional, Dict, Sequence, cast, Callable, Iterator, TYPE_CHECKING
+
+from opentelemetry import context as otel_context_module, trace
+from opentelemetry.trace import (
+    Span,
+    SpanKind as OpenTelemetrySpanKind,
+    Link as OpenTelemetryLink,
+    StatusCode,
+)
+from opentelemetry.trace.propagation import get_current_span as get_current_span_otel
+from opentelemetry.propagate import extract, inject
+
+try:
+    from opentelemetry.context import _SUPPRESS_HTTP_INSTRUMENTATION_KEY  # type: ignore[attr-defined]
+except ImportError:
+    _SUPPRESS_HTTP_INSTRUMENTATION_KEY = "suppress_http_instrumentation"
+
+from ..._version import VERSION
+from ._models import (
+    Attributes,
+    SpanKind as _SpanKind,
+    Link as _Link,
+)
+
+if TYPE_CHECKING:
+    from corehttp.instrumentation.tracing import Link, SpanKind
+
+
+_DEFAULT_SCHEMA_URL = "https://opentelemetry.io/schemas/1.23.1"
+_DEFAULT_MODULE_NAME = "corehttp"
+
+_KIND_MAPPINGS = {
+    _SpanKind.CLIENT: OpenTelemetrySpanKind.CLIENT,
+    _SpanKind.CONSUMER: OpenTelemetrySpanKind.CONSUMER,
+    _SpanKind.PRODUCER: OpenTelemetrySpanKind.PRODUCER,
+    _SpanKind.SERVER: OpenTelemetrySpanKind.SERVER,
+    _SpanKind.INTERNAL: OpenTelemetrySpanKind.INTERNAL,
+    _SpanKind.UNSPECIFIED: OpenTelemetrySpanKind.INTERNAL,
+}
+
+
+class OpenTelemetryTracer:
+    """A tracer that uses OpenTelemetry to trace operations.
+
+    :keyword library_name: The name of the library to use in the tracer.
+    :paramtype library_name: str
+    :keyword library_version: The version of the library to use in the tracer.
+    :paramtype library_version: str
+    :keyword schema_url: Specifies the Schema URL of the emitted spans. Defaults to
+        "https://opentelemetry.io/schemas/1.23.1".
+    :paramtype schema_url: str
+    :keyword attributes: Attributes to add to the emitted spans.
+    """
+
+    def __init__(
+        self,
+        *,
+        library_name: Optional[str] = None,
+        library_version: Optional[str] = None,
+        schema_url: Optional[str] = None,
+        attributes: Optional[Attributes] = None,
+    ) -> None:
+        self._tracer = trace.get_tracer(
+            instrumenting_module_name=library_name or _DEFAULT_MODULE_NAME,
+            instrumenting_library_version=library_version or VERSION,
+            schema_url=schema_url or _DEFAULT_SCHEMA_URL,
+            attributes=attributes,
+        )
+
+    def start_span(
+        self,
+        name: str,
+        *,
+        kind: SpanKind = _SpanKind.INTERNAL,
+        attributes: Optional[Attributes] = None,
+        links: Optional[Sequence[Link]] = None,
+        start_time: Optional[int] = None,
+        context: Optional[Dict[str, Any]] = None,
+    ) -> Span:
+        """Starts a span without setting it as the current span in the context.
+
+        :param name: The name of the span
+        :type name: str
+        :keyword kind: The kind of the span. INTERNAL by default.
+        :paramtype kind: ~corehttp.instrumentation.tracing.SpanKind
+        :keyword attributes: Attributes to add to the span.
+        :paramtype attributes: Mapping[str, AttributeValue]
+        :keyword links: Links to add to the span.
+        :paramtype links: list[~corehttp.instrumentation.tracing.Link]
+        :keyword start_time: The start time of the span in nanoseconds since the epoch.
+        :paramtype start_time: Optional[int]
+        :keyword context: A dictionary of context values corresponding to the parent span. If not provided,
+          the current global context will be used.
+        :paramtype context: Optional[Dict[str, any]]
+        :return: The span that was started
+        :rtype: ~opentelemetry.trace.Span
+        """
+        otel_kind = _KIND_MAPPINGS.get(kind, OpenTelemetrySpanKind.INTERNAL)
+        otel_links = self._parse_links(links)
+
+        otel_context = None
+        if context:
+            otel_context = extract(context)
+
+        otel_span = self._tracer.start_span(
+            name,
+            context=otel_context,
+            kind=otel_kind,
+            attributes=attributes,
+            links=otel_links,
+            start_time=start_time,
+            record_exception=False,
+        )
+
+        return otel_span
+
+    @contextmanager
+    def start_as_current_span(
+        self,
+        name: str,
+        *,
+        kind: SpanKind = _SpanKind.INTERNAL,
+        attributes: Optional[Attributes] = None,
+        links: Optional[Sequence[Link]] = None,
+        start_time: Optional[int] = None,
+        context: Optional[Dict[str, Any]] = None,
+        end_on_exit: bool = True,
+    ) -> Iterator[Span]:
+        """Context manager that starts a span and sets it as the current span in the context.
+
+        .. code:: python
+
+            with tracer.start_as_current_span("span_name") as span:
+                # Do something with the span
+                span.set_attribute("key", "value")
+
+        :param name: The name of the span
+        :type name: str
+        :keyword kind: The kind of the span. INTERNAL by default.
+        :paramtype kind: ~corehttp.instrumentation.tracing.SpanKind
+        :keyword attributes: Attributes to add to the span.
+        :paramtype attributes: Optional[Attributes]
+        :keyword links: Links to add to the span.
+        :paramtype links: Optional[Sequence[Link]]
+        :keyword start_time: The start time of the span in nanoseconds since the epoch.
+        :paramtype start_time: Optional[int]
+        :keyword context: A dictionary of context values corresponding to the parent span. If not provided,
+          the current global context will be used.
+        :paramtype context: Optional[Dict[str, any]]
+        :keyword end_on_exit: Whether to end the span when exiting the context manager. Defaults to True.
+        :paramtype end_on_exit: bool
+        :return: The span that was started
+        :rtype: Iterator[~opentelemetry.trace.Span]
+        """
+        span = self.start_span(
+            name, kind=kind, attributes=attributes, links=links, start_time=start_time, context=context
+        )
+        with trace.use_span(  # pylint: disable=not-context-manager
+            span, record_exception=False, end_on_exit=end_on_exit
+        ) as span:
+            yield span
+
+    @classmethod
+    @contextmanager
+    def use_span(cls, span: Span, *, end_on_exit: bool = True) -> Iterator[Span]:
+        """Context manager that takes a non-active span and activates it in the current context.
+
+        :param span: The span to set as the current span
+        :type span: ~opentelemetry.trace.Span
+        :keyword end_on_exit: Whether to end the span when exiting the context manager. Defaults to True.
+        :paramtype end_on_exit: bool
+        :return: The span that was activated.
+        :rtype: Iterator[~opentelemetry.trace.Span]
+        """
+        with trace.use_span(  # pylint: disable=not-context-manager
+            span, record_exception=False, end_on_exit=end_on_exit
+        ) as active_span:
+            yield active_span
+
+    @staticmethod
+    def set_span_error_status(span: Span, description: Optional[str] = None) -> None:
+        """Set the status of a span to ERROR with the provided description, if any.
+
+        :param span: The span to set the ERROR status on.
+        :type span: ~opentelemetry.trace.Span
+        :param description: An optional description of the error.
+        :type description: str
+        """
+        span.set_status(StatusCode.ERROR, description=description)
+
+    def _parse_links(self, links: Optional[Sequence[Link]]) -> Optional[Sequence[OpenTelemetryLink]]:
+        if not links:
+            return None
+
+        try:
+            otel_links = []
+            for link in links:
+                ctx = extract(link.headers)
+                span_ctx = get_current_span_otel(ctx).get_span_context()
+                otel_links.append(OpenTelemetryLink(span_ctx, link.attributes))
+            return otel_links
+        except AttributeError:
+            # We will just send the links as is if it's not ~corehttp.instrumentation.tracing.Link without
+            # any validation assuming the user knows what they are doing.
+            return cast(Sequence[OpenTelemetryLink], links)
+
+    @classmethod
+    def get_current_span(cls) -> Span:
+        """Returns the current span in the context.
+
+        :return: The current span
+        :rtype: ~opentelemetry.trace.Span
+        """
+        return get_current_span_otel()
+
+    @classmethod
+    def with_current_context(cls, func: Callable) -> Callable:
+        """Passes the current spans to the new context the function will be run in.
+
+        :param func: The function that will be run in the new context
+        :type func: callable
+        :return: The wrapped function
+        :rtype: callable
+        """
+        current_context = otel_context_module.get_current()
+
+        def call_with_current_context(*args, **kwargs):
+            token = None
+            try:
+                token = otel_context_module.attach(current_context)
+                return func(*args, **kwargs)
+            finally:
+                if token is not None:
+                    otel_context_module.detach(token)
+
+        return call_with_current_context
+
+    @classmethod
+    def get_trace_context(cls) -> Dict[str, str]:
+        """Returns the Trace Context header values associated with the current span.
+
+        These are generally the W3C Trace Context headers (i.e. "traceparent" and "tracestate").
+        :return: A key value pair dictionary
+        :rtype: dict[str, str]
+        """
+        trace_context: Dict[str, str] = {}
+        inject(trace_context)
+        return trace_context
+
+    @classmethod
+    def _suppress_auto_http_instrumentation(cls) -> Token:
+        """Enabled automatic HTTP instrumentation suppression.
+
+        Since corehttp already instruments HTTP calls, we need to suppress any automatic HTTP
+        instrumentation provided by other libraries to prevent duplicate spans. This has no effect if no
+        automatic HTTP instrumentation libraries are being used.
+
+        :return: A token that can be used to detach the suppression key from the context
+        :rtype: ~contextvars.Token
+        """
+        return otel_context_module.attach(otel_context_module.set_value(_SUPPRESS_HTTP_INSTRUMENTATION_KEY, True))
+
+    @classmethod
+    def _detach_from_context(cls, token: Token) -> None:
+        """Detach a token from the context.
+
+        :param token: The token to detach
+        :type token: ~contextvars.Token
+        """
+        otel_context_module.detach(token)

corehttp/instrumentation/tracing/utils.py

@@ -0,0 +1,31 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+"""Common tracing functionality for SDK libraries."""
+from typing import Any, Callable
+
+from ._tracer import get_tracer
+from ...settings import settings
+
+
+__all__ = [
+    "with_current_context",
+]
+
+
+def with_current_context(func: Callable) -> Any:
+    """Passes the current spans to the new context the function will be run in.
+
+    :param func: The function that will be run in the new context
+    :type func: callable
+    :return: The func wrapped with correct context
+    :rtype: callable
+    """
+    if not settings.tracing_enabled:
+        return func
+
+    tracer = get_tracer()
+    if not tracer:
+        return func
+    return tracer.with_current_context(func)

corehttp/paging.py

@@ -80,6 +80,13 @@ class PageIterator(Iterator[Iterator[ReturnType]]):
         return self
 
     def __next__(self) -> Iterator[ReturnType]:
+        """Get the next page in the iterator.
+
+        :returns: An iterator of objects in the next page.
+        :rtype: iterator[ReturnType]
+        :raises StopIteration: If there are no more pages to return.
+        :raises ~corehttp.exceptions.BaseError: If the request to get the next page fails.
+        """
         if self.continuation_token is None and self._did_a_call_already:
             raise StopIteration("End of paging")
         try:
@@ -129,6 +136,12 @@ class ItemPaged(Iterator[ReturnType]):
         return self
 
     def __next__(self) -> ReturnType:
+        """Get the next item in the iterator.
+
+        :returns: The next item in the iterator.
+        :rtype: ReturnType
+        :raises StopIteration: If there are no more items to return.
+        """
         if self._page_iterator is None:
             self._page_iterator = itertools.chain.from_iterable(self.by_page())
         return next(self._page_iterator)

corehttp/rest/_aiohttp.py

@@ -30,7 +30,7 @@ import logging
 from itertools import groupby
 from typing import Iterator, cast, TYPE_CHECKING
 from multidict import CIMultiDict
-import aiohttp.client_exceptions  # pylint: disable=all
+import aiohttp.client_exceptions  # pylint: disable=networking-import-outside-azure-core-transport
 
 from ._http_response_impl_async import AsyncHttpResponseImpl
 from ..exceptions import (
@@ -38,6 +38,7 @@ from ..exceptions import (
     ServiceRequestError,
     ServiceResponseError,
     IncompleteReadError,
+    ServiceResponseTimeoutError,
 )
 from ..runtime.pipeline import AsyncPipeline
 from ..transport._base_async import _ResponseStopIteration
@@ -224,7 +225,18 @@ class RestAioHttpTransportResponse(AsyncHttpResponseImpl):
         """
         if not self._content:
             self._stream_download_check()
-            self._content = await self._internal_response.read()
+            try:
+                self._content = await self._internal_response.read()
+            except aiohttp.client_exceptions.ClientPayloadError as err:
+                # This is the case that server closes connection before we finish the reading. aiohttp library
+                # raises ClientPayloadError.
+                raise IncompleteReadError(err, error=err) from err
+            except aiohttp.client_exceptions.ClientResponseError as err:
+                raise ServiceResponseError(err, error=err) from err
+            except asyncio.TimeoutError as err:
+                raise ServiceResponseTimeoutError(err, error=err) from err
+            except aiohttp.client_exceptions.ClientError as err:
+                raise ServiceRequestError(err, error=err) from err
         await self._set_read_checks()
         return _aiohttp_content_helper(self)
 
@@ -263,7 +275,7 @@ class AioHttpStreamDownloadGenerator(collections.abc.AsyncIterator):
         self.response = response
 
         # TODO: determine if block size should be public on RestAioHttpTransportResponse.
-        self.block_size = response._block_size  # pylint: disable=protected-access
+        self.block_size = response._block_size
         self._decompress = decompress
         self.content_length = int(response.headers.get("Content-Length", 0))
         self._decompressor = None
@@ -272,11 +284,11 @@ class AioHttpStreamDownloadGenerator(collections.abc.AsyncIterator):
         return self.content_length
 
     async def __anext__(self):
-        internal_response = self.response._internal_response  # pylint: disable=protected-access
+        internal_response = self.response._internal_response
         try:
             # TODO: Determine how chunks should be read.
             # chunk = await self.response.internal_response.content.read(self.block_size)
-            chunk = await internal_response.content.read(self.block_size)  # pylint: disable=protected-access
+            chunk = await internal_response.content.read(self.block_size)
             if not chunk:
                 raise _ResponseStopIteration()
             if not self._decompress:
@@ -300,16 +312,16 @@ class AioHttpStreamDownloadGenerator(collections.abc.AsyncIterator):
         except aiohttp.client_exceptions.ClientPayloadError as err:
             # This is the case that server closes connection before we finish the reading. aiohttp library
             # raises ClientPayloadError.
-            _LOGGER.warning("Incomplete download: %s", err)
+            _LOGGER.warning("Incomplete download.")
             internal_response.close()
             raise IncompleteReadError(err, error=err) from err
         except aiohttp.client_exceptions.ClientResponseError as err:
             raise ServiceResponseError(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
-        except Exception as err:
-            _LOGGER.warning("Unable to stream download: %s", err)
+        except Exception:
+            _LOGGER.warning("Unable to stream download.")
             internal_response.close()
             raise

corehttp/rest/_http_response_impl.py

@@ -54,7 +54,7 @@ class _HttpResponseBaseImpl(_HttpResponseBase):  # pylint: disable=too-many-inst
     :type request: ~corehttp.rest.HttpRequest
     :keyword any internal_response: The response we get directly from the transport. For example, for our requests
      transport, this will be a requests.Response.
-    :keyword optional[int] block_size: The block size we are using in our transport
+    :keyword Optional[int] block_size: The block size we are using in our transport
     :keyword int status_code: The status code of the response
     :keyword str reason: The HTTP reason
     :keyword str content_type: The content type of the response
@@ -136,7 +136,7 @@ class _HttpResponseBaseImpl(_HttpResponseBase):  # pylint: disable=too-many-inst
     def content_type(self) -> Optional[str]:
         """The content type of the response.
 
-        :rtype: optional[str]
+        :rtype: Optional[str]
         :return: The content type of the response.
         """
         return self._content_type
@@ -157,7 +157,7 @@ class _HttpResponseBaseImpl(_HttpResponseBase):  # pylint: disable=too-many-inst
         :return: The response encoding. We either return the encoding set by the user,
          or try extracting the encoding from the response's content type. If all fails,
          we return `None`.
-        :rtype: optional[str]
+        :rtype: Optional[str]
         """
         try:
             return self._encoding
@@ -166,10 +166,10 @@ class _HttpResponseBaseImpl(_HttpResponseBase):  # pylint: disable=too-many-inst
             return self._encoding
 
     @encoding.setter
-    def encoding(self, value: str) -> None:
+    def encoding(self, value: Optional[str]) -> None:
         """Sets the response encoding.
 
-        :param str value: Sets the response encoding.
+        :param Optional[str] value: Sets the response encoding.
         """
         self._encoding = value
         self._text = None  # clear text cache
@@ -178,7 +178,7 @@ class _HttpResponseBaseImpl(_HttpResponseBase):  # pylint: disable=too-many-inst
     def text(self, encoding: Optional[str] = None) -> str:
         """Returns the response body as a string
 
-        :param optional[str] encoding: The encoding you want to decode the text with. Can
+        :param Optional[str] encoding: The encoding you want to decode the text with. Can
          also be set independently through our encoding property
         :return: The response's content decoded as a string.
         :rtype: str
@@ -246,7 +246,7 @@ class HttpResponseImpl(_HttpResponseBaseImpl, _HttpResponse):
     :type request: ~corehttp.rest.HttpRequest
     :keyword any internal_response: The response we get directly from the transport. For example, for our requests
      transport, this will be a requests.Response.
-    :keyword optional[int] block_size: The block size we are using in our transport
+    :keyword Optional[int] block_size: The block size we are using in our transport
     :keyword int status_code: The status code of the response
     :keyword str reason: The HTTP reason
     :keyword str content_type: The content type of the response
@@ -292,12 +292,7 @@ class HttpResponseImpl(_HttpResponseBaseImpl, _HttpResponse):
                 yield self.content[i : i + chunk_size]
         else:
             self._stream_download_check()
-            for part in self._stream_download_generator(
-                response=self,
-                pipeline=None,
-                decompress=True,
-            ):
-                yield part
+            yield from self._stream_download_generator(response=self, pipeline=None, decompress=True)
         self.close()
 
     def iter_raw(self, **kwargs) -> Iterator[bytes]:
@@ -307,6 +302,5 @@ class HttpResponseImpl(_HttpResponseBaseImpl, _HttpResponse):
         :rtype: Iterator[str]
         """
         self._stream_download_check()
-        for part in self._stream_download_generator(response=self, pipeline=None, decompress=False):
-            yield part
+        yield from self._stream_download_generator(response=self, pipeline=None, decompress=False)
         self.close()

corehttp/rest/_http_response_impl_async.py

@@ -69,6 +69,7 @@ class AsyncHttpResponseImpl(_HttpResponseBaseImpl, _AsyncHttpResponse):
 
     async def iter_raw(self, **kwargs: Any) -> AsyncIterator[bytes]:
         """Asynchronously iterates over the response's bytes. Will not decompress in the process
+
         :return: An async iterator of bytes from the response
         :rtype: AsyncIterator[bytes]
         """
@@ -79,6 +80,7 @@ class AsyncHttpResponseImpl(_HttpResponseBaseImpl, _AsyncHttpResponse):
 
     async def iter_bytes(self, **kwargs: Any) -> AsyncIterator[bytes]:
         """Asynchronously iterates over the response's bytes. Will decompress in the process
+
         :return: An async iterator of bytes from the response
         :rtype: AsyncIterator[bytes]
         """

corehttp/rest/_httpx.py

@@ -96,10 +96,10 @@ class HttpXStreamDownloadGenerator:
         except httpx.RemoteProtocolError as ex:
             msg = ex.__str__()
             if "complete message" in msg:
-                _LOGGER.warning("Incomplete download: %s", ex)
+                _LOGGER.warning("Incomplete download.")
                 internal_response.close()
                 raise IncompleteReadError(ex, error=ex) from ex
-            _LOGGER.warning("Unable to stream download: %s", ex)
+            _LOGGER.warning("Unable to stream download.")
             internal_response.close()
             raise HttpResponseError(ex, error=ex) from ex
         except httpx.DecodingError as ex:
@@ -108,8 +108,8 @@ class HttpXStreamDownloadGenerator:
             raise DecodeError("Failed to decode.", error=ex) from ex
         except httpx.RequestError as err:
             raise ServiceRequestError(err, error=err) from err
-        except Exception as err:
-            _LOGGER.warning("Unable to stream download: %s", err)
+        except Exception:
+            _LOGGER.warning("Unable to stream download.")
             internal_response.close()
             raise
 
@@ -177,7 +177,7 @@ class AsyncHttpXStreamDownloadGenerator(AsyncIterator):
         return self
 
     async def __anext__(self):
-        internal_response = self.response._internal_response  # pylint: disable=protected-access
+        internal_response = self.response._internal_response
         try:
             return await self.iter_content_func.__anext__()
         except StopAsyncIteration:
@@ -186,10 +186,10 @@ class AsyncHttpXStreamDownloadGenerator(AsyncIterator):
         except httpx.RemoteProtocolError as ex:
             msg = ex.__str__()
             if "complete message" in msg:
-                _LOGGER.warning("Incomplete download: %s", ex)
+                _LOGGER.warning("Incomplete download.")
                 await internal_response.aclose()
                 raise IncompleteReadError(ex, error=ex) from ex
-            _LOGGER.warning("Unable to stream download: %s", ex)
+            _LOGGER.warning("Unable to stream download.")
             await internal_response.aclose()
             raise HttpResponseError(ex, error=ex) from ex
         except httpx.DecodingError as ex:
@@ -198,7 +198,7 @@ class AsyncHttpXStreamDownloadGenerator(AsyncIterator):
             raise DecodeError("Failed to decode.", error=ex) from ex
         except httpx.RequestError as err:
             raise ServiceRequestError(err, error=err) from err
-        except Exception as err:
-            _LOGGER.warning("Unable to stream download: %s", err)
+        except Exception:
+            _LOGGER.warning("Unable to stream download.")
             await internal_response.aclose()
             raise

corehttp/rest/_requests_basic.py

@@ -27,8 +27,8 @@ from __future__ import annotations
 import logging
 import collections.abc as collections
 from typing import TYPE_CHECKING, Any
-import requests  # pylint: disable=all
-from requests.structures import CaseInsensitiveDict  # pylint: disable=all
+import requests  # pylint: disable=networking-import-outside-azure-core-transport
+from requests.structures import CaseInsensitiveDict  # pylint: disable=networking-import-outside-azure-core-transport
 from urllib3.exceptions import (
     DecodeError as CoreDecodeError,
     ReadTimeoutError,
@@ -38,8 +38,8 @@ from urllib3.exceptions import (
 from ..runtime.pipeline import Pipeline
 from ._http_response_impl import _HttpResponseBaseImpl, HttpResponseImpl
 from ..exceptions import (
-    ServiceRequestError,
     ServiceResponseError,
+    ServiceResponseTimeoutError,
     IncompleteReadError,
     HttpResponseError,
     DecodeError,
@@ -122,7 +122,7 @@ class StreamDownloadGenerator:
         self.response = response
 
         # TODO: determine if block size should be public on RestTransportResponse.
-        self.block_size = response._block_size  # pylint: disable=protected-access
+        self.block_size = response._block_size
         decompress = kwargs.pop("decompress", True)
         if len(kwargs) > 0:
             raise TypeError("Got an unexpected keyword argument: {}".format(list(kwargs.keys())[0]))
@@ -156,14 +156,22 @@ class StreamDownloadGenerator:
         except requests.exceptions.ChunkedEncodingError as err:
             msg = err.__str__()
             if "IncompleteRead" in msg:
-                _LOGGER.warning("Incomplete download: %s", err)
+                _LOGGER.warning("Incomplete download.")
                 internal_response.close()
                 raise IncompleteReadError(err, error=err) from err
-            _LOGGER.warning("Unable to stream download: %s", err)
+            _LOGGER.warning("Unable to stream download.")
             internal_response.close()
             raise HttpResponseError(err, error=err) from err
+        except requests.ConnectionError as err:
+            internal_response.close()
+            if err.args and isinstance(err.args[0], ReadTimeoutError):
+                raise ServiceResponseTimeoutError(err, error=err) from err
+            raise ServiceResponseError(err, error=err) from err
+        except requests.RequestException as err:
+            internal_response.close()
+            raise ServiceResponseError(err, error=err) from err
         except Exception as err:
-            _LOGGER.warning("Unable to stream download: %s", err)
+            _LOGGER.warning("Unable to stream download.")
             internal_response.close()
             raise
 
@@ -172,14 +180,13 @@ def _read_raw_stream(response, chunk_size=1):
     # Special case for urllib3.
     if hasattr(response.raw, "stream"):
         try:
-            for chunk in response.raw.stream(chunk_size, decode_content=False):
-                yield chunk
+            yield from response.raw.stream(chunk_size, decode_content=False)
         except ProtocolError as e:
             raise ServiceResponseError(e, error=e) from e
         except CoreDecodeError as e:
             raise DecodeError(e, error=e) from e
         except ReadTimeoutError as e:
-            raise ServiceRequestError(e, error=e) from e
+            raise ServiceResponseTimeoutError(e, error=e) from e
     else:
         # Standard file-like object.
         while True: