Merge branch 'issue_539' of github.com:zqumei0/opentelemetry-python-contrib into 539

Author: nhtgl

CHANGELOG.md

@@ -537,6 +537,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- Added `exclude urls` feature to HTTPX instrumentation
+  ([#1900](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/1900))
 - `opentelemetry-resource-detector-azure` Add resource detectors for Azure App Service and VM
   ([#1901](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/1901))
 - `opentelemetry-instrumentation-flask` Add support for Flask 3.0.0

instrumentation/opentelemetry-instrumentation-httpx/pyproject.toml

@@ -37,6 +37,12 @@ dependencies = [
 instruments = [
   "httpx >= 0.18.0",
 ]
+test = [
+  "opentelemetry-instrumentation-httpx[instruments]",
+  "opentelemetry-sdk ~= 1.12",
+  "opentelemetry-test-utils == 0.42b0.dev",
+  "httpretty ~= 1.0",
+]
 
 [project.entry-points.opentelemetry_instrumentor]
 httpx = "opentelemetry.instrumentation.httpx:HTTPXClientInstrumentor"

instrumentation/opentelemetry-instrumentation-httpx/src/opentelemetry/instrumentation/httpx/__init__.py

@@ -234,7 +234,13 @@ async def async_response_hook(span, request, response):
 from opentelemetry.trace.span import Span
 from opentelemetry.trace.status import StatusCode
 from opentelemetry.util.http import remove_url_credentials, sanitize_method
+from opentelemetry.utils.http import (
+    ExcludeList,
+    get_excluded_urls,
+    parse_excluded_urls,
+)
 
+_excluded_urls_from_env = get_excluded_urls("HTTPX")
 _logger = logging.getLogger(__name__)
 
 RequestHook = typing.Callable[[Span, "RequestInfo"], None]
@@ -411,6 +417,7 @@ class SyncOpenTelemetryTransport(httpx.BaseTransport):
             right after the span is created
         response_hook: A hook that receives the span, request, and response
             that is called right before the span ends
+        excluded_urls: List of urls that should be excluded from tracing
     """
 
     def __init__(
@@ -419,6 +426,7 @@ def __init__(
         tracer_provider: TracerProvider | None = None,
         request_hook: RequestHook | None = None,
         response_hook: ResponseHook | None = None,
+        excluded_urls: ExcludeList | None = None,
     ):
         _OpenTelemetrySemanticConventionStability._initialize()
         self._sem_conv_opt_in_mode = _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
@@ -434,6 +442,7 @@ def __init__(
         )
         self._request_hook = request_hook
         self._response_hook = response_hook
+        self._excluded_urls = excluded_urls
 
     def __enter__(self) -> SyncOpenTelemetryTransport:
         self._transport.__enter__()
@@ -459,10 +468,13 @@ def handle_request(
         """Add request info to span."""
         if not is_http_instrumentation_enabled():
             return self._transport.handle_request(*args, **kwargs)
-
         method, url, headers, stream, extensions = _extract_parameters(
             args, kwargs
         )
+        
+        if self._excluded_urls and self._excluded_urls.url_disabled(url):
+            return self._transport.handle_request(*args, **kwargs)
+
         method_original = method.decode()
         span_name = _get_default_span_name(method_original)
         span_attributes = {}
@@ -536,6 +548,7 @@ class AsyncOpenTelemetryTransport(httpx.AsyncBaseTransport):
             right after the span is created
         response_hook: A hook that receives the span, request, and response
             that is called right before the span ends
+        excluded_urls: List of urls that should be excluded from tracing
     """
 
     def __init__(
@@ -544,6 +557,7 @@ def __init__(
         tracer_provider: TracerProvider | None = None,
         request_hook: AsyncRequestHook | None = None,
         response_hook: AsyncResponseHook | None = None,
+        excluded_urls: ExcludeList | None = None,
     ):
         _OpenTelemetrySemanticConventionStability._initialize()
         self._sem_conv_opt_in_mode = _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
@@ -559,6 +573,7 @@ def __init__(
         )
         self._request_hook = request_hook
         self._response_hook = response_hook
+        self._excluded_urls = excluded_urls
 
     async def __aenter__(self) -> "AsyncOpenTelemetryTransport":
         await self._transport.__aenter__()
@@ -586,6 +601,13 @@ async def handle_async_request(
         method, url, headers, stream, extensions = _extract_parameters(
             args, kwargs
         )
+        
+        if self._excluded_urls and self._excluded_urls.url_disabled(url):
+            return await self._transport.handle_async_request(*args, **kwargs)
+        
+        if context.get_value("suppress_instrumentation"):
+            return await self._transport.handle_async_request(*args, **kwargs)
+
         method_original = method.decode()
         span_name = _get_default_span_name(method_original)
         span_attributes = {}
@@ -674,6 +696,8 @@ def _instrument(self, **kwargs: typing.Any):
                     and response that is called right before the span ends
                 ``async_request_hook``: Async ``request_hook`` for ``httpx.AsyncClient``
                 ``async_response_hook``: Async``response_hook`` for ``httpx.AsyncClient``
+                ``excluded_urls``: A string containing a comma-delimited
+                    list of regexes used to exclude URLs from tracking
         """
         tracer_provider = kwargs.get("tracer_provider")
         request_hook = kwargs.get("request_hook")
@@ -690,6 +714,12 @@ def _instrument(self, **kwargs: typing.Any):
             if iscoroutinefunction(async_response_hook)
             else None
         )
+        
+        excluded_urls = kwargs.get("excluded_urls")
+        if  excluded_urls is None:
+            excluded_urls = _excluded_urls_from_env
+        else:
+            excluded_urls = parse_excluded_urls(excluded_urls)
 
         _OpenTelemetrySemanticConventionStability._initialize()
         sem_conv_opt_in_mode = _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
@@ -711,6 +741,7 @@ def _instrument(self, **kwargs: typing.Any):
                 sem_conv_opt_in_mode=sem_conv_opt_in_mode,
                 request_hook=request_hook,
                 response_hook=response_hook,
+                excluded_urls=excluded_urls,
             ),
         )
         wrap_function_wrapper(
@@ -722,6 +753,7 @@ def _instrument(self, **kwargs: typing.Any):
                 sem_conv_opt_in_mode=sem_conv_opt_in_mode,
                 async_request_hook=async_request_hook,
                 async_response_hook=async_response_hook,
+                excluded_urls=excluded_urls,
             ),
         )
 
@@ -739,13 +771,18 @@ def _handle_request_wrapper(  # pylint: disable=too-many-locals
         sem_conv_opt_in_mode: _StabilityMode,
         request_hook: RequestHook,
         response_hook: ResponseHook,
+        excluded_urls: ExcludeList | None = None,
     ):
         if not is_http_instrumentation_enabled():
             return wrapped(*args, **kwargs)
 
         method, url, headers, stream, extensions = _extract_parameters(
             args, kwargs
         )
+
+        if excluded_urls and excluded_urls.url_disabled(url):
+            return wrapeed(*args, **kwargs)
+
         method_original = method.decode()
         span_name = _get_default_span_name(method_original)
         span_attributes = {}
@@ -813,13 +850,18 @@ async def _handle_async_request_wrapper(  # pylint: disable=too-many-locals
         sem_conv_opt_in_mode: _StabilityMode,
         async_request_hook: AsyncRequestHook,
         async_response_hook: AsyncResponseHook,
+        excluded_urls: ExcludeList | None = None,
     ):
         if not is_http_instrumentation_enabled():
             return await wrapped(*args, **kwargs)
 
         method, url, headers, stream, extensions = _extract_parameters(
             args, kwargs
         )
+        
+        if excluded_urls and excluded_urls.url_disabled(url):
+            return await wrapeed(*args, **kwargs)
+        
         method_original = method.decode()
         span_name = _get_default_span_name(method_original)
         span_attributes = {}

instrumentation/opentelemetry-instrumentation-httpx/tests/test_httpx_integration.py

@@ -19,6 +19,7 @@
 import typing
 from unittest import mock
 
+import httpretty
 import httpx
 import respx
 from wrapt import ObjectProxy
@@ -67,10 +68,10 @@
         ResponseHook,
         ResponseInfo,
     )
-    from opentelemetry.sdk.trace.export import SpanExporter
-    from opentelemetry.trace import TracerProvider
-    from opentelemetry.trace.span import Span
-
+from opentelemetry.sdk.trace.export import SpanExporter
+from opentelemetry.trace import TracerProvider
+from opentelemetry.trace.span import Span
+from opentelemetry.util.http import get_excluded_urls
 
 HTTP_RESPONSE_BODY = "http.response.body"
 
@@ -747,8 +748,22 @@ def get_transport_handler(self, transport):
 
         def setUp(self):
             super().setUp()
+            self.env_patch = mock.patch.dict(
+                "os.environ",
+                {
+                    "OTEL_PYTHON_HTTPX_EXCLUDED_URLS": "http://localhost/env_excluded_arg/123,env_excluded_noarg"
+                },
+            )
+            self.env_patch.start()
+
+            self.exclude_patch = mock.patch(
+                "opentelemetry.instrumentation.httpx._excluded_urls_from_env",
+                get_excluded_urls("HTTPX"),
+            )
+            self.exclude_patch.start()
             self.client = self.create_client()
             HTTPXClientInstrumentor().instrument_client(self.client)
+            self.env_patch.stop()
 
         def tearDown(self):
             HTTPXClientInstrumentor().uninstrument()
@@ -955,6 +970,36 @@ def test_uninstrument(self):
             self.assertEqual(result_no_client.text, "Hello!")
             self.assert_span(num_spans=0)
 
+        def test_excluded_urls_explicit(self):
+            url_404 = "http://mock/status/404"
+            httpretty.register_uri(
+                httpretty.GET,
+                url_404,
+                status=404,
+            )
+
+            HTTPXClientInstrumentor().instrument(excluded_urls=".*/404")
+            client = self.create_client()
+            self.perform_request(self.URL)
+            self.perform_request(url_404)
+
+            self.assert_span(num_spans=1)
+
+        def test_excluded_urls_from_env(self):
+            url = "http://localhost/env_excluded_arg/123"
+            httpretty.register_uri(
+                httpretty.GET,
+                url,
+                status=200,
+            )
+
+            HTTPXClientInstrumentor().instrument()
+            client = self.create_client()
+            self.perform_request(self.URL)
+            self.perform_request(url)
+
+            self.assert_span(num_spans=1)
+
         def test_uninstrument_client(self):
             HTTPXClientInstrumentor().uninstrument_client(self.client)