Merge branch 'main' into fix-readme

Author: xrmx

CHANGELOG.md

@@ -11,6 +11,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+### Added 
+
+- `opentelemetry-instrumentation-aiohttp-client`: add support for url exclusions via `OTEL_PYTHON_EXCLUDED_URLS` / `OTEL_PYTHON_AIOHTTP_CLIENT_EXCLUDED_URLS`
+  ([#3850](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3850))
+- `opentelemetry-instrumentation-httpx`: add support for url exclusions via `OTEL_PYTHON_EXCLUDED_URLS` / `OTEL_PYTHON_HTTPX_EXCLUDED_URLS`
+  ([#3837](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3837))
+
+### Fixed
+
+- `opentelemetry-instrumentation-botocore`: Handle dict input in _decode_tool_use for Bedrock streaming
+  ([#3875](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3875))
+
 ## Version 1.38.0/0.59b0 (2025-10-16)
 
 ### Fixed

instrumentation/opentelemetry-instrumentation-aiohttp-client/src/opentelemetry/instrumentation/aiohttp_client/__init__.py

@@ -84,6 +84,20 @@ def response_hook(span: Span, params: typing.Union[
 
    AioHttpClientInstrumentor().instrument(request_hook=request_hook, response_hook=response_hook)
 
+Exclude lists
+*************
+To exclude certain URLs from tracking, set the environment variable ``OTEL_PYTHON_AIOHTTP_CLIENT_EXCLUDED_URLS``
+(or ``OTEL_PYTHON_EXCLUDED_URLS`` to cover all instrumentations) to a string of comma delimited regexes that match the
+URLs.
+
+For example,
+
+::
+
+    export OTEL_PYTHON_AIOHTTP_CLIENT_EXCLUDED_URLS="client/.*/info,healthcheck"
+
+will exclude requests such as ``https://site/client/123/info`` and ``https://site/xyz/healthcheck``.
+
 API
 ---
 """
@@ -135,7 +149,11 @@ def response_hook(span: Span, params: typing.Union[
 )
 from opentelemetry.trace import Span, SpanKind, TracerProvider, get_tracer
 from opentelemetry.trace.status import Status, StatusCode
-from opentelemetry.util.http import redact_url, sanitize_method
+from opentelemetry.util.http import (
+    get_excluded_urls,
+    redact_url,
+    sanitize_method,
+)
 
 _UrlFilterT = typing.Optional[typing.Callable[[yarl.URL], str]]
 _RequestHookT = typing.Optional[
@@ -271,6 +289,8 @@ def create_trace_config(
 
     metric_attributes = {}
 
+    excluded_urls = get_excluded_urls("AIOHTTP_CLIENT")
+
     def _end_trace(trace_config_ctx: types.SimpleNamespace):
         elapsed_time = max(default_timer() - trace_config_ctx.start_time, 0)
         if trace_config_ctx.token:
@@ -304,7 +324,10 @@ async def on_request_start(
         trace_config_ctx: types.SimpleNamespace,
         params: aiohttp.TraceRequestStartParams,
     ):
-        if not is_instrumentation_enabled():
+        if (
+            not is_instrumentation_enabled()
+            or trace_config_ctx.excluded_urls.url_disabled(str(params.url))
+        ):
             trace_config_ctx.span = None
             return
 
@@ -426,6 +449,7 @@ def _trace_config_ctx_factory(**kwargs):
             start_time=start_time,
             duration_histogram_old=duration_histogram_old,
             duration_histogram_new=duration_histogram_new,
+            excluded_urls=excluded_urls,
             **kwargs,
         )
 

instrumentation/opentelemetry-instrumentation-aiohttp-client/tests/test_aiohttp_client_integration.py

@@ -16,6 +16,7 @@
 
 import asyncio
 import contextlib
+import os
 import typing
 import unittest
 import urllib.parse
@@ -87,6 +88,7 @@ async def do_request():
     return loop.run_until_complete(do_request())
 
 
+# pylint: disable=too-many-public-methods
 class TestAioHttpIntegration(TestBase):
     _test_status_codes = (
         (HTTPStatus.OK, StatusCode.UNSET),
@@ -332,7 +334,7 @@ def test_schema_url(self):
 
             span = self.memory_exporter.get_finished_spans()[0]
             self.assertEqual(
-                span.instrumentation_info.schema_url,
+                span.instrumentation_scope.schema_url,
                 "https://opentelemetry.io/schemas/1.11.0",
             )
             self.memory_exporter.clear()
@@ -349,7 +351,7 @@ def test_schema_url_new_semconv(self):
 
             span = self.memory_exporter.get_finished_spans()[0]
             self.assertEqual(
-                span.instrumentation_info.schema_url,
+                span.instrumentation_scope.schema_url,
                 "https://opentelemetry.io/schemas/1.21.0",
             )
             self.memory_exporter.clear()
@@ -366,7 +368,7 @@ def test_schema_url_both_semconv(self):
 
             span = self.memory_exporter.get_finished_spans()[0]
             self.assertEqual(
-                span.instrumentation_info.schema_url,
+                span.instrumentation_scope.schema_url,
                 "https://opentelemetry.io/schemas/1.21.0",
             )
             self.memory_exporter.clear()
@@ -803,6 +805,29 @@ async def do_request(url):
         )
         self.memory_exporter.clear()
 
+    def test_ignores_excluded_urls(self):
+        async def request_handler(request):
+            assert "traceparent" not in request.headers
+            return aiohttp.web.Response(status=HTTPStatus.OK)
+
+        for env_var in (
+            "OTEL_PYTHON_AIOHTTP_CLIENT_EXCLUDED_URLS",
+            "OTEL_PYTHON_EXCLUDED_URLS",
+        ):
+            with self.subTest(env_var=env_var):
+                with mock.patch.dict(
+                    os.environ, {env_var: "/some/path"}, clear=True
+                ):
+                    self._http_request(
+                        trace_config=aiohttp_client.create_trace_config(),
+                        request_handler=request_handler,
+                        url="/some/path?query=param&other=param2",
+                        status_code=HTTPStatus.OK,
+                    )
+
+                    self._assert_spans([], 0)
+                    self._assert_metrics(0)
+
 
 class TestAioHttpClientInstrumentor(TestBase):
     URL = "/test-path"
@@ -1115,6 +1140,21 @@ def response_hook(
         self.assertIn("response_hook_attr", span.attributes)
         self.assertEqual(span.attributes["response_hook_attr"], "value")
 
+    @mock.patch.dict(
+        os.environ, {"OTEL_PYTHON_AIOHTTP_CLIENT_EXCLUDED_URLS": "/test-path"}
+    )
+    def test_ignores_excluded_urls(self):
+        # need the env var set at instrument time
+        AioHttpClientInstrumentor().uninstrument()
+        AioHttpClientInstrumentor().instrument()
+
+        url = "/test-path?query=params"
+        run_with_test_server(
+            self.get_default_request(url), url, self.default_handler
+        )
+        self._assert_spans(0)
+        self._assert_metrics(0)
+
 
 class TestLoadingAioHttpInstrumentor(unittest.TestCase):
     def test_loading_instrumentor(self):

instrumentation/opentelemetry-instrumentation-botocore/src/opentelemetry/instrumentation/botocore/extensions/bedrock_utils.py

@@ -36,16 +36,6 @@
 _StreamErrorCallableT = Callable[[Exception], None]
 
 
-def _decode_tool_use(tool_use):
-    # input get sent encoded in json
-    if "input" in tool_use:
-        try:
-            tool_use["input"] = json.loads(tool_use["input"])
-        except json.JSONDecodeError:
-            pass
-    return tool_use
-
-
 # pylint: disable=abstract-method
 class ConverseStreamWrapper(ObjectProxy):
     """Wrapper for botocore.eventstream.EventStream"""
@@ -368,10 +358,13 @@ def _process_anthropic_claude_chunk(self, chunk):
         if message_type == "content_block_stop":
             # {'type': 'content_block_stop', 'index': 0}
             if self._tool_json_input_buf:
-                self._content_block["input"] = self._tool_json_input_buf
-            self._message["content"].append(
-                _decode_tool_use(self._content_block)
-            )
+                try:
+                    self._content_block["input"] = json.loads(
+                        self._tool_json_input_buf
+                    )
+                except json.JSONDecodeError:
+                    self._content_block["input"] = self._tool_json_input_buf
+            self._message["content"].append(self._content_block)
             self._content_block = {}
             self._tool_json_input_buf = ""
             return

instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_bedrock.py

@@ -25,6 +25,9 @@
 from botocore.eventstream import EventStream, EventStreamError
 from botocore.response import StreamingBody
 
+from opentelemetry.instrumentation.botocore.extensions.bedrock_utils import (
+    InvokeModelWithResponseStreamWrapper,
+)
 from opentelemetry.semconv._incubating.attributes.error_attributes import (
     ERROR_TYPE,
 )
@@ -2975,6 +2978,79 @@ def test_invoke_model_with_response_stream_invalid_model(
     assert len(logs) == 0
 
 
+@pytest.mark.parametrize(
+    "input_value,expected_output",
+    [
+        ({"location": "Seattle"}, {"location": "Seattle"}),
+        ({}, {}),
+        (None, None),
+    ],
+)
+def test_anthropic_claude_chunk_tool_use_input_handling(
+    input_value, expected_output
+):
+    """Test that _process_anthropic_claude_chunk handles various tool_use input formats."""
+
+    def stream_done_callback(response, ended):
+        pass
+
+    def stream_error_callback(exc, ended):
+        pass
+
+    wrapper = InvokeModelWithResponseStreamWrapper(
+        stream=mock.MagicMock(),
+        stream_done_callback=stream_done_callback,
+        stream_error_callback=stream_error_callback,
+        model_id="anthropic.claude-3-5-sonnet-20240620-v1:0",
+    )
+
+    # Simulate message_start
+    wrapper._process_anthropic_claude_chunk(
+        {
+            "type": "message_start",
+            "message": {
+                "role": "assistant",
+                "content": [],
+            },
+        }
+    )
+
+    # Simulate content_block_start with specified input
+    content_block = {
+        "type": "tool_use",
+        "id": "test_id",
+        "name": "test_tool",
+    }
+    if input_value is not None:
+        content_block["input"] = input_value
+
+    wrapper._process_anthropic_claude_chunk(
+        {
+            "type": "content_block_start",
+            "index": 0,
+            "content_block": content_block,
+        }
+    )
+
+    # Simulate content_block_stop
+    wrapper._process_anthropic_claude_chunk(
+        {"type": "content_block_stop", "index": 0}
+    )
+
+    # Verify the message content
+    assert len(wrapper._message["content"]) == 1
+    tool_block = wrapper._message["content"][0]
+    assert tool_block["type"] == "tool_use"
+    assert tool_block["id"] == "test_id"
+    assert tool_block["name"] == "test_tool"
+
+    if expected_output is not None:
+        assert tool_block["input"] == expected_output
+        assert isinstance(tool_block["input"], dict)
+    else:
+        assert "input" not in tool_block
+
+
 def amazon_nova_messages():
     return [
         {"role": "user", "content": [{"text": "Say this is a test"}]},