py2docfx 0.1.16.dev2051338__py3-none-any.whl → 0.1.16.dev2064350__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/policies/_authentication.py

@@ -116,7 +116,7 @@ class BearerTokenCredentialPolicy(_BearerTokenCredentialPolicyBase, HTTPPolicy[H
     :param str scopes: Lets you specify the type of access needed.
     :keyword bool enable_cae: Indicates whether to enable Continuous Access Evaluation (CAE) on all requested
         tokens. Defaults to False.
-    :raises: :class:`~azure.core.exceptions.ServiceRequestError`
+    :raises ~azure.core.exceptions.ServiceRequestError: If the request fails.
     """
 
     def on_request(self, request: PipelineRequest[HTTPRequestType]) -> None:
@@ -194,7 +194,6 @@ class BearerTokenCredentialPolicy(_BearerTokenCredentialPolicyBase, HTTPPolicy[H
         :returns: a bool indicating whether the policy should send the request
         :rtype: bool
         """
-        # pylint:disable=unused-argument
         headers = response.http_response.headers
         error = get_challenge_parameter(headers, "Bearer", "error")
         if error == "insufficient_claims":
@@ -245,7 +244,8 @@ class AzureKeyCredentialPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseTyp
     :type credential: ~azure.core.credentials.AzureKeyCredential
     :param str name: The name of the key header used for the credential.
     :keyword str prefix: The name of the prefix for the header value if any.
-    :raises: ValueError or TypeError
+    :raises ValueError: if name is None or empty.
+    :raises TypeError: if name is not a string or if credential is not an instance of AzureKeyCredential.
     """
 
     def __init__(  # pylint: disable=unused-argument
@@ -276,7 +276,7 @@ class AzureSasCredentialPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseTyp
 
     :param credential: The credential used to authenticate requests.
     :type credential: ~azure.core.credentials.AzureSasCredential
-    :raises: ValueError or TypeError
+    :raises ValueError: if credential is None.
     """
 
     def __init__(

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/policies/_authentication_async.py

@@ -61,7 +61,7 @@ class AsyncBearerTokenCredentialPolicy(AsyncHTTPPolicy[HTTPRequestType, AsyncHTT
 
         :param request: The pipeline request object to be modified.
         :type request: ~azure.core.pipeline.PipelineRequest
-        :raises: :class:`~azure.core.exceptions.ServiceRequestError`
+        :raises ~azure.core.exceptions.ServiceRequestError: If the request fails.
         """
         _BearerTokenCredentialPolicyBase._enforce_https(request)  # pylint:disable=protected-access
 
@@ -139,7 +139,6 @@ class AsyncBearerTokenCredentialPolicy(AsyncHTTPPolicy[HTTPRequestType, AsyncHTT
         :returns: a bool indicating whether the policy should send the request
         :rtype: bool
         """
-        # pylint:disable=unused-argument
         headers = response.http_response.headers
         error = get_challenge_parameter(headers, "Bearer", "error")
         if error == "insufficient_claims":

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/policies/_distributed_tracing.py

@@ -27,7 +27,7 @@
 import logging
 import sys
 import urllib.parse
-from typing import TYPE_CHECKING, Optional, Tuple, TypeVar, Union, Any, Type
+from typing import TYPE_CHECKING, Optional, Tuple, TypeVar, Union, Any, Type, Mapping, Dict
 from types import TracebackType
 
 from azure.core.pipeline import PipelineRequest, PipelineResponse
@@ -39,11 +39,12 @@ from azure.core.pipeline.transport import (
 from azure.core.rest import HttpResponse, HttpRequest
 from azure.core.settings import settings
 from azure.core.tracing import SpanKind
+from azure.core.tracing.common import change_context
+from azure.core.instrumentation import get_tracer
+from azure.core.tracing._models import TracingOptions
 
 if TYPE_CHECKING:
-    from azure.core.tracing._abstract_span import (
-        AbstractSpan,
-    )
+    from opentelemetry.trace import Span
 
 HTTPResponseType = TypeVar("HTTPResponseType", HttpResponse, LegacyHttpResponse)
 HTTPRequestType = TypeVar("HTTPRequestType", HttpRequest, LegacyHttpRequest)
@@ -61,10 +62,7 @@ def _default_network_span_namer(http_request: HTTPRequestType) -> str:
     :returns: The string to use as network span name
     :rtype: str
     """
-    path = urllib.parse.urlparse(http_request.url).path
-    if not path:
-        path = "/"
-    return path
+    return http_request.method
 
 
 class DistributedTracingPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseType]):
@@ -74,37 +72,95 @@ class DistributedTracingPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseTyp
     :type network_span_namer: callable[[~azure.core.pipeline.transport.HttpRequest], str]
     :keyword tracing_attributes: Attributes to set on all created spans
     :type tracing_attributes: dict[str, str]
+    :keyword instrumentation_config: Configuration for the instrumentation providers
+    :type instrumentation_config: dict[str, Any]
     """
 
     TRACING_CONTEXT = "TRACING_CONTEXT"
+    _SUPPRESSION_TOKEN = "SUPPRESSION_TOKEN"
+
+    # Current stable HTTP semantic conventions
+    _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"
+
+    # Azure attributes
     _REQUEST_ID = "x-ms-client-request-id"
+    _REQUEST_ID_ATTR = "az.client_request_id"
     _RESPONSE_ID = "x-ms-request-id"
-    _HTTP_RESEND_COUNT = "http.request.resend_count"
+    _RESPONSE_ID_ATTR = "az.service_request_id"
 
-    def __init__(self, **kwargs: Any):
+    def __init__(self, *, instrumentation_config: Optional[Mapping[str, Any]] = None, **kwargs: Any):
         self._network_span_namer = kwargs.get("network_span_namer", _default_network_span_namer)
         self._tracing_attributes = kwargs.get("tracing_attributes", {})
+        self._instrumentation_config = instrumentation_config
 
     def on_request(self, request: PipelineRequest[HTTPRequestType]) -> None:
         ctxt = request.context.options
         try:
-            span_impl_type = settings.tracing_implementation()
-            if span_impl_type is None:
+            tracing_options: TracingOptions = ctxt.pop("tracing_options", {})
+            tracing_enabled = settings.tracing_enabled()
+
+            # 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 tracing_enabled and user_enabled is None:
                 return
 
+            span_impl_type = settings.tracing_implementation()
             namer = ctxt.pop("network_span_namer", self._network_span_namer)
             tracing_attributes = ctxt.pop("tracing_attributes", self._tracing_attributes)
             span_name = namer(request.http_request)
 
-            span = span_impl_type(name=span_name, kind=SpanKind.CLIENT)
-            for attr, value in tracing_attributes.items():
-                span.add_attribute(attr, value)
-            span.start()
+            span_attributes = {**tracing_attributes, **tracing_options.get("attributes", {})}
 
-            headers = span.to_header()
-            request.http_request.headers.update(headers)
+            if span_impl_type:
+                # If the plugin is enabled, prioritize it over the core tracing.
+                span = span_impl_type(name=span_name, kind=SpanKind.CLIENT)
+                for attr, value in span_attributes.items():
+                    span.add_attribute(attr, value)  # type: ignore
+
+                with change_context(span.span_instance):
+                    headers = span.to_header()
+                    request.http_request.headers.update(headers)
+                request.context[self.TRACING_CONTEXT] = span
+            else:
+                # Otherwise, use the core tracing.
+                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
+
+                otel_span = tracer.start_span(
+                    name=span_name,
+                    kind=SpanKind.CLIENT,
+                    attributes=span_attributes,
+                )
+
+                with tracer.use_span(otel_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] = otel_span
+                token = tracer._suppress_auto_http_instrumentation()  # pylint: disable=protected-access
+                request.context[self._SUPPRESSION_TOKEN] = token
 
-            request.context[self.TRACING_CONTEXT] = span
         except Exception as err:  # pylint: disable=broad-except
             _LOGGER.warning("Unable to start network span: %s", err)
 
@@ -126,21 +182,52 @@ class DistributedTracingPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseTyp
         if self.TRACING_CONTEXT not in request.context:
             return
 
-        span: "AbstractSpan" = request.context[self.TRACING_CONTEXT]
+        span = request.context[self.TRACING_CONTEXT]
+        if not span:
+            return
+
         http_request: Union[HttpRequest, LegacyHttpRequest] = request.http_request
-        if span is not None:
-            span.set_http_attributes(http_request, response=response)
-            if request.context.get("retry_count"):
-                span.add_attribute(self._HTTP_RESEND_COUNT, request.context["retry_count"])
-            request_id = http_request.headers.get(self._REQUEST_ID)
-            if request_id is not None:
-                span.add_attribute(self._REQUEST_ID, request_id)
-            if response and self._RESPONSE_ID in response.headers:
-                span.add_attribute(self._RESPONSE_ID, response.headers[self._RESPONSE_ID])
+
+        attributes: Dict[str, Any] = {}
+        if request.context.get("retry_count"):
+            attributes[self._HTTP_RESEND_COUNT] = request.context["retry_count"]
+        if http_request.headers.get(self._REQUEST_ID):
+            attributes[self._REQUEST_ID_ATTR] = http_request.headers[self._REQUEST_ID]
+        if response and self._RESPONSE_ID in response.headers:
+            attributes[self._RESPONSE_ID_ATTR] = response.headers[self._RESPONSE_ID]
+
+        # We'll determine if the span is from a plugin or the core tracing library based on the presence of the
+        # `set_http_attributes` method.
+        if hasattr(span, "set_http_attributes"):
+            # Plugin-based tracing
+            span.set_http_attributes(request=http_request, response=response)
+            for key, value in attributes.items():
+                span.add_attribute(key, value)
             if exc_info:
                 span.__exit__(*exc_info)
             else:
                 span.finish()
+        else:
+            # Native tracing
+            self._set_http_client_span_attributes(span, request=http_request, response=response)
+            span.set_attributes(attributes)
+            if exc_info:
+                # If there was an exception, set the error.type attribute.
+                exception_type = exc_info[0]
+                if exception_type:
+                    module = exception_type.__module__ if exception_type.__module__ != "builtins" else ""
+                    error_type = f"{module}.{exception_type.__qualname__}" if module else exception_type.__qualname__
+                    span.set_attribute(self._ERROR_TYPE, error_type)
+
+                span.__exit__(*exc_info)
+            else:
+                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 on_response(
         self,
@@ -151,3 +238,39 @@ class DistributedTracingPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseTyp
 
     def on_exception(self, request: PipelineRequest[HTTPRequestType]) -> None:
         self.end_span(request, exc_info=sys.exc_info())
+
+    def _set_http_client_span_attributes(
+        self,
+        span: "Span",
+        request: Union[HttpRequest, LegacyHttpRequest],
+        response: Optional[HTTPResponseType] = 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: ~azure.core.rest.HttpRequest
+        :param response: The response received from the server. Is None if no response received.
+        :type response: ~azure.core.rest.HTTPResponse or ~azure.core.pipeline.transport.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)

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/policies/_redirect.py

@@ -58,6 +58,7 @@ _LOGGER = logging.getLogger(__name__)
 
 def domain_changed(original_domain: Optional[str], url: str) -> bool:
     """Checks if the domain has changed.
+
     :param str original_domain: The original domain.
     :param str url: The new url.
     :rtype: bool
@@ -193,9 +194,9 @@ class RedirectPolicy(RedirectPolicyBase, HTTPPolicy[HTTPRequestType, HTTPRespons
 
         :param request: The PipelineRequest object
         :type request: ~azure.core.pipeline.PipelineRequest
-        :return: Returns the PipelineResponse or raises error if maximum redirects exceeded.
+        :return: The PipelineResponse.
         :rtype: ~azure.core.pipeline.PipelineResponse
-        :raises: ~azure.core.exceptions.TooManyRedirectsError if maximum redirects exceeded.
+        :raises ~azure.core.exceptions.TooManyRedirectsError: if maximum redirects exceeded.
         """
         retryable: bool = True
         redirect_settings = self.configure_redirects(request.context.options)

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/policies/_redirect_async.py

@@ -65,9 +65,9 @@ class AsyncRedirectPolicy(RedirectPolicyBase, AsyncHTTPPolicy[HTTPRequestType, A
 
         :param request: The PipelineRequest object
         :type request: ~azure.core.pipeline.PipelineRequest
-        :return: Returns the PipelineResponse or raises error if maximum redirects exceeded.
+        :return: the PipelineResponse.
         :rtype: ~azure.core.pipeline.PipelineResponse
-        :raises: ~azure.core.exceptions.TooManyRedirectsError if maximum redirects exceeded.
+        :raises ~azure.core.exceptions.TooManyRedirectsError: if maximum redirects exceeded.
         """
         redirects_remaining = True
         redirect_settings = self.configure_redirects(request.context.options)

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/policies/_retry.py

@@ -422,28 +422,21 @@ class RetryPolicy(RetryPolicyBase, HTTPPolicy[HTTPRequestType, HTTPResponseType]
 
     :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).
 
     .. admonition:: Example:
@@ -522,10 +515,10 @@ class RetryPolicy(RetryPolicyBase, HTTPPolicy[HTTPRequestType, HTTPResponseType]
 
         :param request: The PipelineRequest object
         :type request: ~azure.core.pipeline.PipelineRequest
-        :return: Returns the PipelineResponse or raises error if maximum retries exceeded.
+        :return: The PipelineResponse.
         :rtype: ~azure.core.pipeline.PipelineResponse
-        :raises: ~azure.core.exceptions.AzureError if maximum retries exceeded.
-        :raises: ~azure.core.exceptions.ClientAuthenticationError if authentication
+        :raises ~azure.core.exceptions.AzureError: if maximum retries exceeded.
+        :raises ~azure.core.exceptions.ClientAuthenticationError: if authentication fails.
         """
         retry_active = True
         response = None

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/policies/_retry_async.py

@@ -57,23 +57,18 @@ class AsyncRetryPolicy(RetryPolicyBase, AsyncHTTPPolicy[HTTPRequestType, AsyncHT
 
     :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).
 
     .. admonition:: Example:
@@ -154,10 +149,10 @@ class AsyncRetryPolicy(RetryPolicyBase, AsyncHTTPPolicy[HTTPRequestType, AsyncHT
 
         :param request: The PipelineRequest object
         :type request: ~azure.core.pipeline.PipelineRequest
-        :return: Returns the PipelineResponse or raises error if maximum retries exceeded.
+        :return: The PipelineResponse.
         :rtype: ~azure.core.pipeline.PipelineResponse
-        :raise: ~azure.core.exceptions.AzureError if maximum retries exceeded.
-        :raise: ~azure.core.exceptions.ClientAuthenticationError if authentication fails
+        :raise ~azure.core.exceptions.AzureError: if maximum retries exceeded.
+        :raise ~azure.core.exceptions.ClientAuthenticationError: if authentication fails
         """
         retry_active = True
         response = None

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/policies/_universal.py

@@ -234,6 +234,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)
@@ -441,6 +442,7 @@ class HttpLoggingPolicy(
         self, request: PipelineRequest[HTTPRequestType]
     ) -> None:
         """Logs HTTP method, url and headers.
+
         :param request: The PipelineRequest object.
         :type request: ~azure.core.pipeline.PipelineRequest
         """

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/transport/_aiohttp.py

@@ -85,7 +85,6 @@ class AioHttpTransport(AsyncHttpTransport):
     :keyword session: The client session.
     :paramtype session: ~aiohttp.ClientSession
     :keyword bool session_owner: Session owner. Defaults True.
-
     :keyword bool use_env_settings: Uses proxy settings from environment. Defaults to True.
 
     .. admonition:: Example:

py2docfx/venv/venv1/Lib/site-packages/azure/core/polling/base_polling.py

@@ -113,15 +113,15 @@ def _succeeded(status):
 
 
 class BadStatus(Exception):
-    pass
+    """Exception raised when status is invalid."""
 
 
 class BadResponse(Exception):
-    pass
+    """Exception raised when response is invalid."""
 
 
 class OperationFailed(Exception):
-    pass
+    """Exception raised when operation failed or canceled."""
 
 
 def _as_json(response: AllHttpResponseType) -> Dict[str, Any]:

py2docfx/venv/venv1/Lib/site-packages/azure/core/rest/_http_response_impl_async.py

@@ -46,6 +46,7 @@ class AsyncHttpResponseBackcompatMixin(_HttpResponseBackcompatMixinBase):
     def parts(self):
         """DEPRECATED: Assuming the content-type is multipart/mixed, will return the parts as an async iterator.
         This is deprecated and will be removed in a later release.
+
         :rtype: AsyncIterator
         :return: The parts of the response
         :raises ValueError: If the content is not multipart/mixed
@@ -95,6 +96,7 @@ class AsyncHttpResponseImpl(_HttpResponseBaseImpl, _AsyncHttpResponse, AsyncHttp
 
     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]
         """
@@ -105,6 +107,7 @@ class AsyncHttpResponseImpl(_HttpResponseBaseImpl, _AsyncHttpResponse, AsyncHttp
 
     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]
         """

py2docfx/venv/venv1/Lib/site-packages/azure/core/rest/_rest_py3.py

@@ -303,7 +303,7 @@ class _HttpResponseBase(abc.ABC):
 
         :return: The JSON deserialized response body
         :rtype: any
-        :raises json.decoder.JSONDecodeError or ValueError (in python 2.7) if object is not JSON decodable:
+        :raises json.decoder.JSONDecodeError: if the body is not valid JSON.
         """
 
     @abc.abstractmethod
@@ -312,7 +312,7 @@ class _HttpResponseBase(abc.ABC):
 
         If response is good, does nothing.
 
-        :raises ~azure.core.HttpResponseError if the object has an error status code.:
+        :raises ~azure.core.HttpResponseError: if the object has an error status code.
         """
 
 

py2docfx/venv/venv1/Lib/site-packages/azure/core/settings.py

@@ -30,7 +30,6 @@ from collections import namedtuple
 from enum import Enum
 import logging
 import os
-import sys
 from typing import (
     Type,
     Optional,
@@ -43,10 +42,13 @@ from typing import (
     Generic,
     Mapping,
     List,
+    TYPE_CHECKING,
 )
-from azure.core.tracing import AbstractSpan
 from ._azure_clouds import AzureClouds
 
+if TYPE_CHECKING:
+    from azure.core.tracing import AbstractSpan
+
 ValidInputType = TypeVar("ValidInputType")
 ValueType = TypeVar("ValueType")
 
@@ -88,6 +90,24 @@ def convert_bool(value: Union[str, bool]) -> bool:
     raise ValueError("Cannot convert {} to boolean value".format(value))
 
 
+def convert_tracing_enabled(value: Optional[Union[str, bool]]) -> bool:
+    """Convert tracing value to bool with regard to tracing implementation.
+
+    :param value: the value to convert
+    :type value: str or bool or None
+    :returns: A boolean value matching the intent of the input
+    :rtype: bool
+    :raises ValueError: If conversion to bool fails
+    """
+    if value is None:
+        # If tracing_enabled was not explicitly set to a boolean, determine tracing enablement
+        # based on tracing_implementation being set.
+        if settings.tracing_implementation():
+            return True
+        return False
+    return convert_bool(value)
+
+
 _levels = {
     "CRITICAL": logging.CRITICAL,
     "ERROR": logging.ERROR,
@@ -181,18 +201,6 @@ def _get_opentelemetry_span() -> Optional[Type[AbstractSpan]]:
         return None
 
 
-def _get_opencensus_span_if_opencensus_is_imported() -> Optional[Type[AbstractSpan]]:
-    if "opencensus" not in sys.modules:
-        return None
-    return _get_opencensus_span()
-
-
-def _get_opentelemetry_span_if_opentelemetry_is_imported() -> Optional[Type[AbstractSpan]]:
-    if "opentelemetry" not in sys.modules:
-        return None
-    return _get_opentelemetry_span()
-
-
 _tracing_implementation_dict: Dict[str, Callable[[], Optional[Type[AbstractSpan]]]] = {
     "opencensus": _get_opencensus_span,
     "opentelemetry": _get_opentelemetry_span,
@@ -215,9 +223,7 @@ def convert_tracing_impl(value: Optional[Union[str, Type[AbstractSpan]]]) -> Opt
 
     """
     if value is None:
-        return (
-            _get_opentelemetry_span_if_opentelemetry_is_imported() or _get_opencensus_span_if_opencensus_is_imported()
-        )
+        return None
 
     if not isinstance(value, str):
         return value
@@ -299,7 +305,7 @@ class PrioritizedSetting(Generic[ValidInputType, ValueType]):
         :type value: str or int or float or None
         :returns: the value of the setting
         :rtype: str or int or float
-        :raises: RuntimeError if no value can be determined
+        :raises RuntimeError: if no value can be determined
         """
 
         # 4. immediate values
@@ -501,11 +507,11 @@ class Settings:
         default=logging.INFO,
     )
 
-    tracing_enabled: PrioritizedSetting[Union[str, bool], bool] = PrioritizedSetting(
+    tracing_enabled: PrioritizedSetting[Optional[Union[str, bool]], bool] = PrioritizedSetting(
         "tracing_enabled",
         env_var="AZURE_TRACING_ENABLED",
-        convert=convert_bool,
-        default=False,
+        convert=convert_tracing_enabled,
+        default=None,
     )
 
     tracing_implementation: PrioritizedSetting[

py2docfx/venv/venv1/Lib/site-packages/azure/core/tracing/__init__.py

@@ -2,11 +2,7 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT License.
 # ------------------------------------
-from azure.core.tracing._abstract_span import (
-    AbstractSpan,
-    SpanKind,
-    HttpSpanMixin,
-    Link,
-)
+from ._abstract_span import AbstractSpan, HttpSpanMixin
+from ._models import Link, SpanKind, TracingOptions
 
-__all__ = ["AbstractSpan", "SpanKind", "HttpSpanMixin", "Link"]
+__all__ = ["AbstractSpan", "HttpSpanMixin", "Link", "SpanKind", "TracingOptions"]