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

corehttp/runtime/policies/_distributed_tracing.py

@@ -0,0 +1,169 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+from __future__ import annotations
+import logging
+import urllib.parse
+from typing import Any, Optional, Tuple, Union, Type, Mapping, Dict, TYPE_CHECKING
+from types import TracebackType
+
+from ...rest import HttpRequest
+from ...rest._rest_py3 import _HttpResponseBase as SansIOHttpResponse
+from ._base import SansIOHTTPPolicy
+from ...settings import settings
+from ...instrumentation.tracing._models import SpanKind, TracingOptions
+from ...instrumentation.tracing._tracer import get_tracer
+
+if TYPE_CHECKING:
+    from ..pipeline import PipelineRequest, PipelineResponse
+    from opentelemetry.trace import Span
+
+
+ExcInfo = Tuple[Type[BaseException], BaseException, TracebackType]
+OptExcInfo = Union[ExcInfo, Tuple[None, None, None]]
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class DistributedHttpTracingPolicy(SansIOHTTPPolicy[HttpRequest, SansIOHttpResponse]):
+    """The policy to create tracing spans for API calls.
+
+    :keyword instrumentation_config: Configuration for the instrumentation providers.
+    :type instrumentation_config: dict[str, Any]
+    """
+
+    TRACING_CONTEXT = "TRACING_CONTEXT"
+    _SUPPRESSION_TOKEN = "SUPPRESSION_TOKEN"
+
+    # Attribute names
+    _HTTP_RESEND_COUNT = "http.request.resend_count"
+    _USER_AGENT_ORIGINAL = "user_agent.original"
+    _HTTP_REQUEST_METHOD = "http.request.method"
+    _URL_FULL = "url.full"
+    _HTTP_RESPONSE_STATUS_CODE = "http.response.status_code"
+    _SERVER_ADDRESS = "server.address"
+    _SERVER_PORT = "server.port"
+    _ERROR_TYPE = "error.type"
+
+    def __init__(  # pylint: disable=unused-argument
+        self,
+        *,
+        instrumentation_config: Optional[Mapping[str, Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        self._instrumentation_config = instrumentation_config
+
+    def on_request(self, request: PipelineRequest[HttpRequest]) -> None:
+        """Starts a span for the network call.
+
+        :param request: The PipelineRequest object.
+        :type request: ~corehttp.runtime.pipeline.PipelineRequest
+        """
+        ctxt = request.context.options
+        try:
+            tracing_options: TracingOptions = ctxt.pop("tracing_options", {})
+
+            # User can explicitly disable tracing for this request.
+            user_enabled = tracing_options.get("enabled")
+            if user_enabled is False:
+                return
+
+            # If tracing is disabled globally and user didn't explicitly enable it, don't trace.
+            if not settings.tracing_enabled and user_enabled is None:
+                return
+
+            config = self._instrumentation_config or {}
+            tracer = get_tracer(
+                library_name=config.get("library_name"),
+                library_version=config.get("library_version"),
+                attributes=config.get("attributes"),
+            )
+            if not tracer:
+                _LOGGER.warning(
+                    "Tracing is enabled, but not able to get an OpenTelemetry tracer. "
+                    "Please ensure that `opentelemetry-api` is installed."
+                )
+                return
+
+            span_name = request.http_request.method
+            span = tracer.start_span(
+                name=span_name,
+                kind=SpanKind.CLIENT,
+                attributes=tracing_options.get("attributes"),
+            )
+
+            with tracer.use_span(span, end_on_exit=False):
+                trace_context_headers = tracer.get_trace_context()
+                request.http_request.headers.update(trace_context_headers)
+
+            request.context[self.TRACING_CONTEXT] = span
+            token = tracer._suppress_auto_http_instrumentation()  # pylint: disable=protected-access
+            request.context[self._SUPPRESSION_TOKEN] = token
+        except Exception as err:  # pylint: disable=broad-except
+            _LOGGER.warning("Unable to start HTTP span: %s", err)  # pylint: disable=do-not-log-exceptions-if-not-debug
+
+    def on_response(
+        self,
+        request: PipelineRequest[HttpRequest],
+        response: PipelineResponse[HttpRequest, SansIOHttpResponse],
+    ) -> None:
+        """Ends the span for the network call and updates its status.
+
+        :param request: The PipelineRequest object.
+        :type request: ~corehttp.runtime.pipeline.PipelineRequest
+        :param response: The PipelineResponse object.
+        :type response: ~corehttp.runtime.pipeline.PipelineResponse
+        """
+        if self.TRACING_CONTEXT not in request.context:
+            return
+
+        span: Optional["Span"] = request.context[self.TRACING_CONTEXT]
+        http_request = request.http_request
+        if span:
+            self._set_http_client_span_attributes(span, http_request, response=response.http_response)
+            if request.context.get("retry_count"):
+                span.set_attribute(self._HTTP_RESEND_COUNT, request.context["retry_count"])
+            span.end()
+
+        suppression_token = request.context.get(self._SUPPRESSION_TOKEN)
+        if suppression_token:
+            tracer = get_tracer()
+            if tracer:
+                tracer._detach_from_context(suppression_token)  # pylint: disable=protected-access
+
+    def _set_http_client_span_attributes(
+        self,
+        span: "Span",
+        request: HttpRequest,
+        response: Optional[SansIOHttpResponse] = None,
+    ) -> None:
+        """Add attributes to an HTTP client span.
+
+        :param span: The span to add attributes to.
+        :type span: ~opentelemetry.trace.Span
+        :param request: The request made
+        :type request: ~corehttp.rest.HttpRequest
+        :param response: The response received from the server. Is None if no response received.
+        :type response: ~corehttp.rest.HttpResponse
+        """
+        attributes: Dict[str, Any] = {
+            self._HTTP_REQUEST_METHOD: request.method,
+            self._URL_FULL: request.url,
+        }
+
+        parsed_url = urllib.parse.urlparse(request.url)
+        if parsed_url.hostname:
+            attributes[self._SERVER_ADDRESS] = parsed_url.hostname
+        if parsed_url.port:
+            attributes[self._SERVER_PORT] = parsed_url.port
+
+        user_agent = request.headers.get("User-Agent")
+        if user_agent:
+            attributes[self._USER_AGENT_ORIGINAL] = user_agent
+        if response and response.status_code:
+            attributes[self._HTTP_RESPONSE_STATUS_CODE] = response.status_code
+            if response.status_code >= 400:
+                attributes[self._ERROR_TYPE] = str(response.status_code)
+
+        span.set_attributes(attributes)

corehttp/runtime/policies/_retry.py

@@ -52,6 +52,8 @@ _LOGGER = logging.getLogger(__name__)
 
 
 class RetryMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    """Enum for retry modes."""
+
     # pylint: disable=enum-must-be-uppercase
     Exponential = "exponential"
     Fixed = "fixed"
@@ -104,7 +106,7 @@ class RetryPolicyBase:
             "read": options.pop("retry_read", self.read_retries),
             "status": options.pop("retry_status", self.status_retries),
             "backoff": options.pop("retry_backoff_factor", self.backoff_factor),
-            "max_backoff": options.pop("retry_backoff_max", self.BACKOFF_MAX),
+            "max_backoff": options.pop("retry_backoff_max", self.backoff_max),
             "methods": options.pop("retry_on_methods", self._method_whitelist),
             "timeout": options.pop("timeout", self.timeout),
             "history": [],
@@ -394,28 +396,21 @@ class RetryPolicy(RetryPolicyBase, HTTPPolicy[HttpRequest, HttpResponse]):
 
     :keyword int retry_total: Total number of retries to allow. Takes precedence over other counts.
      Default value is 10.
-
     :keyword int retry_connect: How many connection-related errors to retry on.
      These are errors raised before the request is sent to the remote server,
      which we assume has not triggered the server to process the request. Default value is 3.
-
     :keyword int retry_read: How many times to retry on read errors.
      These errors are raised after the request was sent to the server, so the
      request may have side-effects. Default value is 3.
-
     :keyword int retry_status: How many times to retry on bad status codes. Default value is 3.
-
     :keyword float retry_backoff_factor: A backoff factor to apply between attempts after the second try
      (most errors are resolved immediately by a second try without a delay).
      In fixed mode, retry policy will always sleep for {backoff factor}.
      In 'exponential' mode, retry policy will sleep for: `{backoff factor} * (2 ** ({number of total retries} - 1))`
      seconds. If the backoff_factor is 0.1, then the retry will sleep
      for [0.0s, 0.2s, 0.4s, ...] between retries. The default value is 0.8.
-
     :keyword int retry_backoff_max: The maximum back off time. Default value is 120 seconds (2 minutes).
-
     :keyword RetryMode retry_mode: Fixed or exponential delay between attemps, default is exponential.
-
     :keyword int timeout: Timeout setting for the operation in seconds, default is 604800s (7 days).
     """
 
@@ -481,10 +476,10 @@ class RetryPolicy(RetryPolicyBase, HTTPPolicy[HttpRequest, HttpResponse]):
 
         :param request: The PipelineRequest object
         :type request: ~corehttp.runtime.pipeline.PipelineRequest
-        :return: Returns the PipelineResponse or raises error if maximum retries exceeded.
+        :return: The PipelineResponse.
         :rtype: ~corehttp.runtime.pipeline.PipelineResponse
-        :raises: ~corehttp.exceptions.BaseError if maximum retries exceeded.
-        :raises: ~corehttp.exceptions.ClientAuthenticationError if authentication
+        :raises ~corehttp.exceptions.BaseError: if maximum retries exceeded.
+        :raises ~corehttp.exceptions.ClientAuthenticationError: if authentication fails.
         """
         retry_active = True
         response = None
@@ -505,6 +500,7 @@ class RetryPolicy(RetryPolicyBase, HTTPPolicy[HttpRequest, HttpResponse]):
             )
             try:
                 self._configure_timeout(request, absolute_timeout, is_response_error)
+                request.context["retry_count"] = len(retry_settings["history"])
                 response = self.next.send(request)
                 if self.is_retry(retry_settings, response):
                     retry_active = self.increment(retry_settings, response=response)

corehttp/runtime/policies/_retry_async.py

@@ -54,23 +54,18 @@ class AsyncRetryPolicy(RetryPolicyBase, AsyncHTTPPolicy[HttpRequest, AsyncHttpRe
 
     :keyword int retry_total: Total number of retries to allow. Takes precedence over other counts.
      Default value is 10.
-
     :keyword int retry_connect: How many connection-related errors to retry on.
      These are errors raised before the request is sent to the remote server,
      which we assume has not triggered the server to process the request. Default value is 3.
-
     :keyword int retry_read: How many times to retry on read errors.
      These errors are raised after the request was sent to the server, so the
      request may have side-effects. Default value is 3.
-
     :keyword int retry_status: How many times to retry on bad status codes. Default value is 3.
-
     :keyword float retry_backoff_factor: A backoff factor to apply between attempts after the second try
      (most errors are resolved immediately by a second try without a delay).
      Retry policy will sleep for: `{backoff factor} * (2 ** ({number of total retries} - 1))`
      seconds. If the backoff_factor is 0.1, then the retry will sleep
      for [0.0s, 0.2s, 0.4s, ...] between retries. The default value is 0.8.
-
     :keyword int retry_backoff_max: The maximum back off time. Default value is 120 seconds (2 minutes).
     """
 
@@ -138,10 +133,10 @@ class AsyncRetryPolicy(RetryPolicyBase, AsyncHTTPPolicy[HttpRequest, AsyncHttpRe
 
         :param request: The PipelineRequest object
         :type request: ~corehttp.runtime.pipeline.PipelineRequest
-        :return: Returns the PipelineResponse or raises error if maximum retries exceeded.
+        :return: The PipelineResponse.
         :rtype: ~corehttp.runtime.pipeline.PipelineResponse
-        :raise: ~corehttp.exceptions.BaseError if maximum retries exceeded.
-        :raise: ~corehttp.exceptions.ClientAuthenticationError if authentication fails
+        :raises ~corehttp.exceptions.BaseError: if maximum retries exceeded.
+        :raises ~corehttp.exceptions.ClientAuthenticationError: if authentication fails.
         """
         retry_active = True
         response = None
@@ -162,6 +157,7 @@ class AsyncRetryPolicy(RetryPolicyBase, AsyncHTTPPolicy[HttpRequest, AsyncHttpRe
             )
             try:
                 self._configure_timeout(request, absolute_timeout, is_response_error)
+                request.context["retry_count"] = len(retry_settings["history"])
                 response = await self.next.send(request)
                 if self.is_retry(retry_settings, response):
                     retry_active = self.increment(retry_settings, response=response)

corehttp/runtime/policies/_universal.py

@@ -143,6 +143,7 @@ class UserAgentPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseType]):
 
     def add_user_agent(self, value: str) -> None:
         """Add value to current user agent with a space.
+
         :param str value: value to add to user agent.
         """
         self._user_agent = "{} {}".format(self._user_agent, value)
@@ -401,6 +402,11 @@ class ContentDecodePolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseType]):
         return cls.deserialize_from_text(response.text(encoding), mime_type, response=response)
 
     def on_request(self, request: PipelineRequest[HTTPRequestType]) -> None:
+        """Set the response encoding in the request context.
+
+        :param request: The PipelineRequest object.
+        :type request: ~corehttp.runtime.pipeline.PipelineRequest
+        """
         options = request.context.options
         response_encoding = options.pop("response_encoding", self._response_encoding)
         if response_encoding:
@@ -452,6 +458,11 @@ class ProxyPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseType]):
         self.proxies = proxies
 
     def on_request(self, request: PipelineRequest[HTTPRequestType]) -> None:
+        """Adds the proxy information to the request context.
+
+        :param request: The PipelineRequest object.
+        :type request: ~corehttp.runtime.pipeline.PipelineRequest
+        """
         ctxt = request.context.options
         if self.proxies and "proxies" not in ctxt:
             ctxt["proxies"] = self.proxies

corehttp/serialization.py

@@ -4,14 +4,23 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+# pylint: disable=protected-access
 import base64
+from functools import partial
 from json import JSONEncoder
-from typing import Union, cast, Any
+from typing import Dict, List, Optional, Union, cast, Any, Type, Callable, Tuple
 from datetime import datetime, date, time, timedelta
 from datetime import timezone
 
 
-__all__ = ["NULL", "CoreJSONEncoder"]
+__all__ = [
+    "NULL",
+    "CoreJSONEncoder",
+    "is_generated_model",
+    "attribute_list",
+    "TypeHandlerRegistry",
+]
+TZ_UTC = timezone.utc
 
 
 class _Null:
@@ -111,10 +120,176 @@ def _datetime_as_isostr(dt: Union[datetime, date, time, timedelta]) -> str:
         return _timedelta_as_isostr(dt)
 
 
+class TypeHandlerRegistry:
+    """A registry for custom serializers and deserializers for specific types or conditions."""
+
+    def __init__(self) -> None:
+        self._serializer_types: Dict[Type, Callable] = {}
+        self._deserializer_types: Dict[Type, Callable] = {}
+        self._serializer_predicates: List[Tuple[Callable[[Any], bool], Callable]] = []
+        self._deserializer_predicates: List[Tuple[Callable[[Any], bool], Callable]] = []
+
+        self._serializer_cache: Dict[Type, Optional[Callable]] = {}
+        self._deserializer_cache: Dict[Type, Optional[Callable]] = {}
+
+    def register_serializer(
+        self, condition: Union[Type, Callable[[Any], bool]]
+    ) -> Callable[[Callable[[Any], Dict[str, Any]]], Callable[[Any], Dict[str, Any]]]:
+        """Decorator to register a serializer.
+
+        The handler function is expected to take a single argument, the object to serialize,
+        and return a dictionary representation of that object.
+
+        Examples:
+
+        .. code-block:: python
+
+            @registry.register_serializer(CustomModel)
+            def serialize_single_type(value: CustomModel) -> dict:
+                return value.to_dict()
+
+            @registry.register_serializer(lambda x: isinstance(x, BaseModel))
+            def serialize_with_condition(value: BaseModel) -> dict:
+                return value.to_dict()
+
+            # Called manually for a specific type
+            def custom_serializer(value: CustomModel) -> Dict[str, Any]:
+                return {"custom": value.custom}
+
+            registry.register_serializer(CustomModel)(custom_serializer)
+
+        :param condition: A type or a callable predicate function that takes an object and returns a bool.
+        :type condition: Union[Type, Callable[[Any], bool]]
+        :return: A decorator that registers the handler function.
+        :rtype: Callable[[Callable[[Any], Dict[str, Any]]], Callable[[Any], Dict[str, Any]]]
+        :raises TypeError: If the condition is neither a type nor a callable.
+        """
+
+        def decorator(handler_func: Callable[[Any], Dict[str, Any]]) -> Callable[[Any], Dict[str, Any]]:
+            if isinstance(condition, type):
+                self._serializer_types[condition] = handler_func
+            elif callable(condition):
+                self._serializer_predicates.append((condition, handler_func))
+            else:
+                raise TypeError("Condition must be a type or a callable predicate function.")
+
+            self._serializer_cache.clear()
+            return handler_func
+
+        return decorator
+
+    def register_deserializer(
+        self, condition: Union[Type, Callable[[Any], bool]]
+    ) -> Callable[[Callable[[Type, Dict[str, Any]], Any]], Callable[[Type, Dict[str, Any]], Any]]:
+        """Decorator to register a deserializer.
+
+        The handler function is expected to take two arguments: the target type and the data dictionary,
+        and return an instance of the target type.
+
+        Examples:
+
+        .. code-block:: python
+
+            @registry.register_deserializer(CustomModel)
+            def deserialize_single_type(cls: Type[CustomModel], data: dict) -> CustomModel:
+                return cls(**data)
+
+            @registry.register_deserializer(lambda t: issubclass(t, BaseModel))
+            def deserialize_with_condition(cls: Type[BaseModel], data: dict) -> BaseModel:
+                return cls(**data)
+
+            # Called manually for a specific type
+            def custom_deserializer(cls: Type[CustomModel], data: Dict[str, Any]) -> CustomModel:
+                return cls(custom=data["custom"])
+
+            registry.register_deserializer(CustomModel)(custom_deserializer)
+
+        :param condition: A type or a callable predicate function that takes an object and returns a bool.
+        :type condition: Union[Type, Callable[[Any], bool]]
+        :return: A decorator that registers the handler function.
+        :rtype: Callable[[Callable[[Type, Dict[str, Any]], Any]], Callable[[Type, Dict[str, Any]], Any]]
+        :raises TypeError: If the condition is neither a type nor a callable.
+        """
+
+        def decorator(handler_func: Callable[[Type, Dict[str, Any]], Any]) -> Callable[[Type, Dict[str, Any]], Any]:
+            if isinstance(condition, type):
+                self._deserializer_types[condition] = handler_func
+            elif callable(condition):
+                self._deserializer_predicates.append((condition, handler_func))
+            else:
+                raise TypeError("Condition must be a type or a callable predicate function.")
+
+            self._deserializer_cache.clear()
+            return handler_func
+
+        return decorator
+
+    def get_serializer(self, obj: Any) -> Optional[Callable[[Any], Dict[str, Any]]]:
+        """Gets the appropriate serializer for an object.
+
+        It first checks the type dictionary for a direct type match.
+        If no match is found, it iterates through the predicate list to find a match.
+
+        Results of the lookup are cached for performance based on the object's type.
+
+        :param obj: The object to serialize.
+        :type obj: any
+        :return: The serializer function if found, otherwise None.
+        :rtype: Optional[Callable[[Any], Dict[str, Any]]]
+        """
+        obj_type = type(obj)
+        if obj_type in self._serializer_cache:
+            return self._serializer_cache[obj_type]
+
+        handler = self._serializer_types.get(type(obj))
+        if not handler:
+            for predicate, pred_handler in self._serializer_predicates:
+                if predicate(obj):
+                    handler = pred_handler
+                    break
+
+        self._serializer_cache[obj_type] = handler
+        return handler
+
+    def get_deserializer(self, cls: Type) -> Optional[Callable[[Dict[str, Any]], Any]]:
+        """Gets the appropriate deserializer for a class.
+
+        It first checks the type dictionary for a direct type match.
+        If no match is found, it iterates through the predicate list to find a match.
+
+        Results of the lookup are cached for performance based on the class.
+
+        :param cls: The class to deserialize.
+        :type cls: type
+        :return: A deserializer function bound to the specified class that takes a dictionary and returns
+            an instance of that class, or None if no deserializer is found.
+        :rtype: Optional[Callable[[Dict[str, Any]], Any]]
+        """
+        if cls in self._deserializer_cache:
+            return self._deserializer_cache[cls]
+
+        handler = self._deserializer_types.get(cls)
+        if not handler:
+            for predicate, pred_handler in self._deserializer_predicates:
+                if predicate(cls):
+                    handler = pred_handler
+                    break
+
+        self._deserializer_cache[cls] = partial(handler, cls) if handler else None
+        return self._deserializer_cache[cls]
+
+
 class CoreJSONEncoder(JSONEncoder):
     """A JSON encoder that's capable of serializing datetime objects and bytes."""
 
     def default(self, o: Any) -> Any:
+        """Override the default method to handle datetime and bytes serialization.
+
+        :param o: The object to serialize.
+        :type o: Any
+        :return: A JSON-serializable representation of the object.
+        :rtype: Any
+        """
         if isinstance(o, (bytes, bytearray)):
             return base64.b64encode(o).decode()
         try:
@@ -122,3 +297,62 @@ class CoreJSONEncoder(JSONEncoder):
         except AttributeError:
             pass
         return super(CoreJSONEncoder, self).default(o)
+
+
+def is_generated_model(obj: Any) -> bool:
+    """Check if the object is a generated SDK model.
+
+    :param obj: The object to check.
+    :type obj: any
+    :return: True if the object is a generated SDK model, False otherwise.
+    :rtype: bool
+    """
+    return bool(getattr(obj, "_is_model", False) or hasattr(obj, "_attribute_map"))
+
+
+def _get_flattened_attribute(obj: Any) -> Optional[str]:
+    """Get the name of the flattened attribute in a generated TypeSpec model if one exists.
+
+    :param any obj: The object to check.
+    :return: The name of the flattened attribute if it exists, otherwise None.
+    :rtype: Optional[str]
+    """
+    flattened_items = None
+    try:
+        flattened_items = getattr(obj, next(a for a in dir(obj) if "__flattened_items" in a), None)
+    except StopIteration:
+        return None
+
+    if flattened_items is None:
+        return None
+
+    for k, v in obj._attr_to_rest_field.items():
+        try:
+            if set(v._class_type._attr_to_rest_field.keys()).intersection(set(flattened_items)):
+                return k
+        except AttributeError:
+            # if the attribute does not have _class_type, it is not a typespec generated model
+            continue
+    return None
+
+
+def attribute_list(obj: Any) -> List[str]:
+    """Get a list of attribute names for a generated SDK model.
+
+    :param obj: The object to get attributes from.
+    :type obj: any
+    :return: A list of attribute names.
+    :rtype: List[str]
+    """
+    if not is_generated_model(obj):
+        raise TypeError("Object is not a generated SDK model.")
+    if hasattr(obj, "_attribute_map"):
+        return list(obj._attribute_map.keys())
+    flattened_attribute = _get_flattened_attribute(obj)
+    retval: List[str] = []
+    for attr_name, rest_field in obj._attr_to_rest_field.items():
+        if flattened_attribute == attr_name:
+            retval.extend(attribute_list(rest_field._class_type))
+        else:
+            retval.append(attr_name)
+    return retval

corehttp/settings.py

@@ -0,0 +1,59 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+import os
+from typing import Union
+
+
+def _convert_bool(value: Union[str, bool]) -> bool:
+    """Convert a string to True or False
+
+    If a boolean is passed in, it is returned as-is. Otherwise the function
+    maps the following strings, ignoring case:
+
+    * "yes", "1", "on" -> True
+    * "no", "0", "off" -> False
+
+    :param value: the value to convert
+    :type value: str or bool
+    :returns: A boolean value matching the intent of the input
+    :rtype: bool
+    :raises ValueError: If conversion to bool fails
+
+    """
+    if isinstance(value, bool):
+        return value
+    val = value.lower()
+    if val in ["yes", "1", "on", "true", "True"]:
+        return True
+    if val in ["no", "0", "off", "false", "False"]:
+        return False
+    raise ValueError("Cannot convert {} to boolean value".format(value))
+
+
+class Settings:
+    """Global settings for the SDK."""
+
+    def __init__(self) -> None:
+        self._tracing_enabled: bool = _convert_bool(os.environ.get("SDK_TRACING_ENABLED", False))
+
+    @property
+    def tracing_enabled(self) -> bool:
+        """Whether tracing for SDKs is enabled.
+
+        :return: True if tracing is enabled, False otherwise.
+        :rtype: bool
+        """
+        return self._tracing_enabled
+
+    @tracing_enabled.setter
+    def tracing_enabled(self, value: bool):
+        self._tracing_enabled = _convert_bool(value)
+
+
+settings: Settings = Settings()
+"""The settings global instance.
+
+:type settings: Settings
+"""

corehttp/transport/_base.py

@@ -80,10 +80,8 @@ def _handle_non_stream_rest_response(response: HttpResponse) -> None:
     """
     try:
         response.read()
+    finally:
         response.close()
-    except Exception as exc:
-        response.close()
-        raise exc
 
 
 class HttpTransport(ContextManager["HttpTransport"], abc.ABC, Generic[HTTPRequestType, HTTPResponseType]):

corehttp/transport/_base_async.py

@@ -46,10 +46,8 @@ async def _handle_non_stream_rest_response(response: AsyncHttpResponse) -> None:
     """
     try:
         await response.read()
+    finally:
         await response.close()
-    except Exception as exc:
-        await response.close()
-        raise exc
 
 
 class _ResponseStopIteration(Exception):