Merge branch 'main' into dependabot/pip/jinja2-3.1.6

Author: xrmx

CHANGELOG.md

@@ -15,7 +15,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - `opentelemetry-instrumentation-openai-v2` Update doc for OpenAI Instrumentation to support OpenAI Compatible Platforms
   ([#3279](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3279))
-- `opentelemetry-instrumentation-system-metrics` Add `process` metrics and deprecated `process.runtime` prefixed ones 
+- `opentelemetry-instrumentation-system-metrics` Add `process` metrics and deprecated `process.runtime` prefixed ones
   ([#3250](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3250))
 - `opentelemetry-instrumentation-botocore` Add support for GenAI user events and lazy initialize tracer
   ([#3258](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3258))
@@ -41,6 +41,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   ([#3247](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3247))
 - `opentelemetry-instrumentation-asyncpg` Fix fallback for empty queries.
   ([#3253](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3253))
+- `opentelemetry-instrumentation-requests` always record span status code in duration metric
+  ([#3323](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3323))
 
 ## Version 1.30.0/0.51b0 (2025-02-03)
 
@@ -100,7 +102,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Breaking changes
 
-- `opentelemetry-exporter-prometheus-remote-write` updated protobuf required version from 4.21 to 5.26 and regenerated protobufs 
+- `opentelemetry-exporter-prometheus-remote-write` updated protobuf required version from 4.21 to 5.26 and regenerated protobufs
  ([#3219](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3219))
 - `opentelemetry-instrumentation-sqlalchemy` including sqlcomment in `db.statement` span attribute value is now opt-in
   ([#3112](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3112))

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

@@ -386,6 +386,10 @@ def extract_tool_results(
     if not content:
         return
 
+    # langchain sends content as string with InvokeModel and Anthropic Claude
+    if isinstance(content, str):
+        return
+
     # Converse format
     tool_results = [
         item["toolResult"] for item in content if "toolResult" in item

instrumentation/opentelemetry-instrumentation-botocore/tests/cassettes/test_invoke_model_with_content_user_content_as_string.yaml

@@ -0,0 +1,74 @@
+interactions:
+- request:
+    body: |-
+      {
+        "messages": [
+          {
+            "role": "user",
+            "content": "say this is a test"
+          }
+        ],
+        "max_tokens": 10,
+        "anthropic_version": "bedrock-2023-05-31"
+      }
+    headers:
+      Content-Length:
+      - '126'
+      User-Agent:
+      - Boto3/1.35.56 md/Botocore#1.35.56 ua/2.0 os/linux#6.1.0-1034-oem md/arch#x86_64
+        lang/python#3.10.12 md/pyimpl#CPython cfg/retry-mode#legacy Botocore/1.35.56
+      X-Amz-Date:
+      - 20250306T091535Z
+      X-Amz-Security-Token:
+      - test_aws_security_token
+      X-Amzn-Trace-Id:
+      - Root=1-fcd0825a-03f328cca8cde3e741cd83b4;Parent=5a8eccf8d7b031e7;Sampled=1
+      amz-sdk-invocation-id:
+      - e8a6c9c5-8a45-4ad7-881b-0761d121abc7
+      amz-sdk-request:
+      - attempt=1
+      authorization:
+      - Bearer test_aws_authorization
+    method: POST
+    uri: https://bedrock-runtime.us-east-1.amazonaws.com/model/us.anthropic.claude-3-5-sonnet-20240620-v1%3A0/invoke
+  response:
+    body:
+      string: |-
+        {
+          "id": "msg_bdrk_01SjMAZgb8kNMweUzf3moSbU",
+          "type": "message",
+          "role": "assistant",
+          "model": "claude-3-5-sonnet-20240620",
+          "content": [
+            {
+              "type": "text",
+              "text": "This is a test."
+            }
+          ],
+          "stop_reason": "end_turn",
+          "stop_sequence": null,
+          "usage": {
+            "input_tokens": 12,
+            "output_tokens": 8
+          }
+        }
+    headers:
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Thu, 06 Mar 2025 09:15:36 GMT
+      Set-Cookie: test_set_cookie
+      X-Amzn-Bedrock-Input-Token-Count:
+      - '12'
+      X-Amzn-Bedrock-Invocation-Latency:
+      - '544'
+      X-Amzn-Bedrock-Output-Token-Count:
+      - '8'
+      x-amzn-RequestId:
+      - e97cb4f9-61fe-4a62-a29a-a582ddd17414
+    status:
+      code: 200
+      message: OK
+version: 1

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

@@ -1256,6 +1256,53 @@ def test_invoke_model_with_content(
     assert_message_in_logs(logs[1], "gen_ai.choice", choice_body, span)
 
 
+@pytest.mark.vcr()
+def test_invoke_model_with_content_user_content_as_string(
+    span_exporter,
+    log_exporter,
+    bedrock_runtime_client,
+    instrument_with_content,
+):
+    llm_model_value = "us.anthropic.claude-3-5-sonnet-20240620-v1:0"
+    max_tokens = 10
+    body = json.dumps(
+        {
+            "messages": [{"role": "user", "content": "say this is a test"}],
+            "max_tokens": max_tokens,
+            "anthropic_version": "bedrock-2023-05-31",
+        }
+    )
+    response = bedrock_runtime_client.invoke_model(
+        body=body,
+        modelId=llm_model_value,
+    )
+
+    (span,) = span_exporter.get_finished_spans()
+    assert_completion_attributes_from_streaming_body(
+        span,
+        llm_model_value,
+        response,
+        "chat",
+        request_max_tokens=max_tokens,
+    )
+
+    logs = log_exporter.get_finished_logs()
+    assert len(logs) == 2
+    user_content = {"content": "say this is a test"}
+    assert_message_in_logs(logs[0], "gen_ai.user.message", user_content, span)
+
+    message = {
+        "role": "assistant",
+        "content": [{"type": "text", "text": "This is a test."}],
+    }
+    choice_body = {
+        "index": 0,
+        "finish_reason": "end_turn",
+        "message": message,
+    }
+    assert_message_in_logs(logs[1], "gen_ai.choice", choice_body, span)
+
+
 @pytest.mark.parametrize(
     "model_family",
     ["amazon.nova", "anthropic.claude"],

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

@@ -41,20 +41,22 @@
 
 .. code:: python
 
+    import requests
+    from opentelemetry.instrumentation.requests import RequestsInstrumentor
+
     # `request_obj` is an instance of requests.PreparedRequest
     def request_hook(span, request_obj):
         pass
 
     # `request_obj` is an instance of requests.PreparedRequest
     # `response` is an instance of requests.Response
-    def response_hook(span, request_obj, response)
+    def response_hook(span, request_obj, response):
         pass
 
     RequestsInstrumentor().instrument(
-        request_hook=request_hook, response_hook=response_hook)
+        request_hook=request_hook, response_hook=response_hook
     )
 
-
 Exclude lists
 *************
 To exclude certain URLs from being tracked, set the environment variable ``OTEL_PYTHON_REQUESTS_EXCLUDED_URLS``
@@ -99,15 +101,14 @@ def response_hook(span, request_obj, response)
     _set_http_network_protocol_version,
     _set_http_peer_port_client,
     _set_http_scheme,
-    _set_http_status_code,
     _set_http_url,
+    _set_status,
     _StabilityMode,
 )
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.instrumentation.requests.package import _instruments
 from opentelemetry.instrumentation.requests.version import __version__
 from opentelemetry.instrumentation.utils import (
-    http_status_to_status_code,
     is_http_instrumentation_enabled,
     suppress_http_instrumentation,
 )
@@ -124,7 +125,6 @@ def response_hook(span, request_obj, response)
 )
 from opentelemetry.trace import SpanKind, Tracer, get_tracer
 from opentelemetry.trace.span import Span
-from opentelemetry.trace.status import StatusCode
 from opentelemetry.util.http import (
     ExcludeList,
     get_excluded_urls,
@@ -140,6 +140,32 @@ def response_hook(span, request_obj, response)
 _ResponseHookT = Optional[Callable[[Span, PreparedRequest, Response], None]]
 
 
+def _set_http_status_code_attribute(
+    span,
+    status_code,
+    metric_attributes=None,
+    sem_conv_opt_in_mode=_StabilityMode.DEFAULT,
+):
+    status_code_str = str(status_code)
+    try:
+        status_code = int(status_code)
+    except ValueError:
+        status_code = -1
+    if metric_attributes is None:
+        metric_attributes = {}
+    # When we have durations we should set metrics only once
+    # Also the decision to include status code on a histogram should
+    # not be dependent on tracing decisions.
+    _set_status(
+        span,
+        metric_attributes,
+        status_code,
+        status_code_str,
+        server_span=False,
+        sem_conv_opt_in_mode=sem_conv_opt_in_mode,
+    )
+
+
 # pylint: disable=unused-argument
 # pylint: disable=R0915
 def _instrument(
@@ -267,25 +293,12 @@ def get_or_create_headers():
 
             if isinstance(result, Response):
                 span_attributes = {}
-                if span.is_recording():
-                    _set_http_status_code(
-                        span_attributes,
-                        result.status_code,
-                        sem_conv_opt_in_mode,
-                    )
-                    _set_http_status_code(
-                        metric_labels, result.status_code, sem_conv_opt_in_mode
-                    )
-                    status_code = http_status_to_status_code(
-                        result.status_code
-                    )
-                    span.set_status(status_code)
-                    if (
-                        _report_new(sem_conv_opt_in_mode)
-                        and status_code is StatusCode.ERROR
-                    ):
-                        span_attributes[ERROR_TYPE] = str(result.status_code)
-                        metric_labels[ERROR_TYPE] = str(result.status_code)
+                _set_http_status_code_attribute(
+                    span,
+                    result.status_code,
+                    metric_labels,
+                    sem_conv_opt_in_mode,
+                )
 
                 if result.raw is not None:
                     version = getattr(result.raw, "version", None)

instrumentation/opentelemetry-instrumentation-requests/tests/test_requests_integration.py

@@ -832,3 +832,34 @@ def test_basic_metric_both_semconv(self):
                                 dict(data_point.attributes),
                             )
                         self.assertEqual(data_point.count, 1)
+
+    def test_basic_metric_non_recording_span(self):
+        expected_attributes = {
+            SpanAttributes.HTTP_STATUS_CODE: 200,
+            SpanAttributes.HTTP_HOST: "examplehost",
+            SpanAttributes.NET_PEER_PORT: 8000,
+            SpanAttributes.NET_PEER_NAME: "examplehost",
+            SpanAttributes.HTTP_METHOD: "GET",
+            SpanAttributes.HTTP_FLAVOR: "1.1",
+            SpanAttributes.HTTP_SCHEME: "http",
+        }
+
+        with mock.patch("opentelemetry.trace.INVALID_SPAN") as mock_span:
+            RequestsInstrumentor().uninstrument()
+            RequestsInstrumentor().instrument(
+                tracer_provider=trace.NoOpTracerProvider()
+            )
+            mock_span.is_recording.return_value = False
+            result = self.perform_request(self.URL)
+            self.assertEqual(result.text, "Hello!")
+            self.assertFalse(mock_span.is_recording())
+            self.assertTrue(mock_span.is_recording.called)
+            self.assertFalse(mock_span.set_attribute.called)
+            self.assertFalse(mock_span.set_status.called)
+            metrics = self.get_sorted_metrics()
+            self.assertEqual(len(metrics), 1)
+            duration_data_point = metrics[0].data.data_points[0]
+            self.assertDictEqual(
+                expected_attributes, dict(duration_data_point.attributes)
+            )
+            self.assertEqual(duration_data_point.count, 1)