merge master

alexander-alderman-webb · alexander-alderman-webb · commit 470bbbbb323b · 2025-12-01T17:26:17.000+01:00
diff --git a/.github/release.yml b/.github/release.yml
@@ -1,8 +1,3 @@
-# This configuration is used by Craft to categorize changelog entries based on
-# PR labels. To avoid some manual work, there is a PR labeling GitHub action in
-# .github/workflows/pr-labeler.yml that adds a changelog label to PRs based on
-# the title.
-
 changelog:
   exclude:
     labels:
@@ -16,19 +11,29 @@ changelog:
         - Feature
         - Improvement
         - New Integration
+      commit_patterns:
+        - "^feat(\([a-zA-Z0-9_-]+\))?:"
     - title: Bug Fixes 🐛
       labels:
         - "Changelog: Bugfix"
         - Bug
+      commit_patterns:
+        - "^(fix|bugfix)(\([a-zA-Z0-9_-]+\))?:"
     - title: Deprecations 🏗️
       labels:
         - "Changelog: Deprecation"
+      commit_patterns:
+        - "deprecat"  # deprecation, deprecated
     - title: Documentation 📚
       labels:
         - "Changelog: Docs"
         - Docs
         - "Component: Docs"
+      commit_patterns:
+        - "^docs(\([a-zA-Z0-9_-]+\))?:"
     - title: Internal Changes 🔧
       labels:
         - "Changelog: Internal"
         - Quality Improvement
+      commit_patterns:
+        - "^(build|ref|chore|ci|tests|test)(\([a-zA-Z0-9_-]+\))?:"
diff --git a/.github/workflows/pr-labeler.yml b/.github/workflows/pr-labeler.yml
diff --git a/.github/workflows/test-integrations-tasks.yml b/.github/workflows/test-integrations-tasks.yml
@@ -45,7 +45,7 @@ jobs:
           python-version: ${{ matrix.python-version }}
           allow-prereleases: true
       - name: Start Redis
-        uses: supercharge/redis-github-action@1.8.1
+        uses: supercharge/redis-github-action@v2
       - name: Install Java
         uses: actions/setup-java@v5
         with:
diff --git a/.github/workflows/update-tox.yml b/.github/workflows/update-tox.yml
@@ -54,7 +54,7 @@ jobs:
           echo "date=$DATE" >> $GITHUB_OUTPUT
 
       - name: Create pull request
-        uses: actions/github-script@v8.0.0
+        uses: actions/github-script@v8
         with:
           script: |
             const branchName = '${{ steps.create-branch.outputs.branch_name }}';
diff --git a/scripts/split_tox_gh_actions/templates/test_group.jinja b/scripts/split_tox_gh_actions/templates/test_group.jinja
@@ -56,7 +56,7 @@
 
       {% if needs_redis %}
       - name: Start Redis
-        uses: supercharge/redis-github-action@1.8.1
+        uses: supercharge/redis-github-action@2
       {% endif %}
 
       {% if needs_java %}
diff --git a/sentry_sdk/consts.py b/sentry_sdk/consts.py
@@ -1024,6 +1024,7 @@ def __init__(
         enable_metrics=True,  # type: bool
         before_send_metric=None,  # type: Optional[Callable[[Metric, Hint], Optional[Metric]]]
         org_id=None,  # type: Optional[str]
+        strict_trace_continuation=False,  # type: bool
     ):
         # type: (...) -> None
         """Initialize the Sentry SDK with the given parameters. All parameters described here can be used in a call to `sentry_sdk.init()`.
@@ -1427,6 +1428,15 @@ def __init__(
             If `trace_ignore_status_codes` is not provided, requests with any status code
             may be traced.
 
+        :param strict_trace_continuation: If set to `True`, the SDK will only continue a trace if the `org_id` of the incoming trace found in the
+           `baggage` header matches the `org_id` of the current Sentry client and only if BOTH are present.
+
+            If set to `False`, consistency of `org_id` will only be enforced if both are present. If either are missing, the trace will be continued.
+
+            The client's organization ID is extracted from the DSN or can be set with the `org_id` option.
+            If the organization IDs do not match, the SDK will start a new trace instead of continuing the incoming one.
+            This is useful to prevent traces of unknown third-party services from being continued in your application.
+
         :param org_id: An optional organization ID. The SDK will try to extract if from the DSN in most cases
             but you can provide it explicitly for self-hosted and Relay setups. This value is used for
             trace propagation and for features like `strict_trace_continuation`.
diff --git a/sentry_sdk/integrations/openai_agents/spans/invoke_agent.py b/sentry_sdk/integrations/openai_agents/spans/invoke_agent.py
@@ -3,6 +3,7 @@
     get_start_span_function,
     set_data_normalized,
     normalize_message_roles,
+    truncate_and_annotate_messages,
 )
 from sentry_sdk.consts import OP, SPANDATA
 from sentry_sdk.scope import should_send_default_pii
@@ -61,12 +62,17 @@ def invoke_agent_span(context, agent, kwargs):
 
         if len(messages) > 0:
             normalized_messages = normalize_message_roles(messages)
-            set_data_normalized(
-                span,
-                SPANDATA.GEN_AI_REQUEST_MESSAGES,
-                normalized_messages,
-                unpack=False,
+            scope = sentry_sdk.get_current_scope()
+            messages_data = truncate_and_annotate_messages(
+                normalized_messages, span, scope
             )
+            if messages_data is not None:
+                set_data_normalized(
+                    span,
+                    SPANDATA.GEN_AI_REQUEST_MESSAGES,
+                    messages_data,
+                    unpack=False,
+                )
 
     _set_agent_data(span, agent)
 
diff --git a/sentry_sdk/integrations/openai_agents/utils.py b/sentry_sdk/integrations/openai_agents/utils.py
@@ -4,6 +4,7 @@
     normalize_message_roles,
     set_data_normalized,
     normalize_message_role,
+    truncate_and_annotate_messages,
 )
 from sentry_sdk.consts import SPANDATA, SPANSTATUS, OP
 from sentry_sdk.integrations import DidNotEnable
@@ -157,12 +158,16 @@ def _set_input_data(span, get_response_kwargs):
                     }
                 )
 
-    set_data_normalized(
-        span,
-        SPANDATA.GEN_AI_REQUEST_MESSAGES,
-        normalize_message_roles(request_messages),
-        unpack=False,
-    )
+    normalized_messages = normalize_message_roles(request_messages)
+    scope = sentry_sdk.get_current_scope()
+    messages_data = truncate_and_annotate_messages(normalized_messages, span, scope)
+    if messages_data is not None:
+        set_data_normalized(
+            span,
+            SPANDATA.GEN_AI_REQUEST_MESSAGES,
+            messages_data,
+            unpack=False,
+        )
 
 
 def _set_output_data(span, result):
diff --git a/sentry_sdk/tracing_utils.py b/sentry_sdk/tracing_utils.py
@@ -15,7 +15,6 @@
 from sentry_sdk.utils import (
     capture_internal_exceptions,
     filename_for_module,
-    Dsn,
     logger,
     match_regex_list,
     qualname_from_function,
@@ -453,15 +452,23 @@ def from_incoming_data(cls, incoming_data):
 
         sentry_trace_header = normalized_data.get(SENTRY_TRACE_HEADER_NAME)
         sentrytrace_data = extract_sentrytrace_data(sentry_trace_header)
+
+        # nothing to propagate if no sentry-trace
         if sentrytrace_data is None:
             return None
 
+        baggage_header = normalized_data.get(BAGGAGE_HEADER_NAME)
+        baggage = (
+            Baggage.from_incoming_header(baggage_header) if baggage_header else None
+        )
+
+        if not _should_continue_trace(baggage):
+            return None
+
         propagation_context = PropagationContext()
         propagation_context.update(sentrytrace_data)
-
-        baggage_header = normalized_data.get(BAGGAGE_HEADER_NAME)
-        if baggage_header:
-            propagation_context.baggage = Baggage.from_incoming_header(baggage_header)
+        if baggage:
+            propagation_context.baggage = baggage
 
         propagation_context._fill_sample_rand()
 
@@ -1230,6 +1237,41 @@ def _set_output_attributes(span, template, send_pii, result):
     span.update_data(_get_output_attributes(template, send_pii, result) or {})
 
 
+def _should_continue_trace(baggage):
+    # type: (Optional[Baggage]) -> bool
+    """
+    Check if we should continue the incoming trace according to the strict_trace_continuation spec.
+    https://develop.sentry.dev/sdk/telemetry/traces/#stricttracecontinuation
+    """
+
+    client = sentry_sdk.get_client()
+    parsed_dsn = client.parsed_dsn
+    client_org_id = parsed_dsn.org_id if parsed_dsn else None
+    baggage_org_id = baggage.sentry_items.get("org_id") if baggage else None
+
+    if (
+        client_org_id is not None
+        and baggage_org_id is not None
+        and client_org_id != baggage_org_id
+    ):
+        logger.debug(
+            f"Starting a new trace because org IDs don't match (incoming baggage org_id: {baggage_org_id}, SDK org_id: {client_org_id})"
+        )
+        return False
+
+    strict_trace_continuation = client.options.get("strict_trace_continuation", False)  # type: bool
+    if strict_trace_continuation:
+        if (baggage_org_id is not None and client_org_id is None) or (
+            baggage_org_id is None and client_org_id is not None
+        ):
+            logger.debug(
+                f"Starting a new trace because strict trace continuation is enabled and one org ID is missing (incoming baggage org_id: {baggage_org_id}, SDK org_id: {client_org_id})"
+            )
+            return False
+
+    return True
+
+
 # Circular imports
 from sentry_sdk.tracing import (
     BAGGAGE_HEADER_NAME,
diff --git a/tests/conftest.py b/tests/conftest.py
@@ -221,6 +221,19 @@ def capture_envelope(self, _: Envelope) -> None:
         pass
 
 
+class TestTransportWithOptions(Transport):
+    """TestTransport above does not pass in the options and for some tests we need them"""
+
+    __test__ = False
+
+    def __init__(self, options=None):
+        Transport.__init__(self, options)
+
+    def capture_envelope(self, _: Envelope) -> None:
+        """No-op capture_envelope for tests"""
+        pass
+
+
 @pytest.fixture
 def capture_events(monkeypatch):
     def inner():
diff --git a/tests/integrations/openai_agents/test_openai_agents.py b/tests/integrations/openai_agents/test_openai_agents.py
@@ -3,10 +3,13 @@
 import pytest
 from unittest.mock import MagicMock, patch
 import os
+import json
 
+import sentry_sdk
+from sentry_sdk import start_span
+from sentry_sdk.consts import SPANDATA
 from sentry_sdk.integrations.openai_agents import OpenAIAgentsIntegration
-from sentry_sdk.integrations.asyncio import AsyncioIntegration
-from sentry_sdk.integrations.openai_agents.utils import safe_serialize
+from sentry_sdk.integrations.openai_agents.utils import _set_input_data, safe_serialize
 from sentry_sdk.utils import parse_version
 
 import agents
@@ -1387,3 +1390,46 @@ def failing_tool(message: str) -> str:
     # The span should be marked as error because the tool execution failed
     assert execute_tool_span["status"] == "internal_error"
     assert execute_tool_span["tags"]["status"] == "internal_error"
+
+
+def test_openai_agents_message_truncation(sentry_init, capture_events):
+    """Test that large messages are truncated properly in OpenAI Agents integration."""
+
+    large_content = (
+        "This is a very long message that will exceed our size limits. " * 1000
+    )
+
+    sentry_init(
+        integrations=[OpenAIAgentsIntegration()],
+        traces_sample_rate=1.0,
+        send_default_pii=True,
+    )
+
+    test_messages = [
+        {"role": "system", "content": "small message 1"},
+        {"role": "user", "content": large_content},
+        {"role": "assistant", "content": large_content},
+        {"role": "user", "content": "small message 4"},
+        {"role": "assistant", "content": "small message 5"},
+    ]
+
+    get_response_kwargs = {"input": test_messages}
+
+    with start_span(op="gen_ai.chat") as span:
+        scope = sentry_sdk.get_current_scope()
+        _set_input_data(span, get_response_kwargs)
+        if hasattr(scope, "_gen_ai_original_message_count"):
+            truncated_count = scope._gen_ai_original_message_count.get(span.span_id)
+            assert truncated_count == 5, (
+                f"Expected 5 original messages, got {truncated_count}"
+            )
+
+        assert SPANDATA.GEN_AI_REQUEST_MESSAGES in span._data
+        messages_data = span._data[SPANDATA.GEN_AI_REQUEST_MESSAGES]
+        assert isinstance(messages_data, str)
+
+        parsed_messages = json.loads(messages_data)
+        assert isinstance(parsed_messages, list)
+        assert len(parsed_messages) == 2
+        assert "small message 4" in str(parsed_messages[0])
+        assert "small message 5" in str(parsed_messages[1])
diff --git a/tests/test_dsc.py b/tests/test_dsc.py
diff --git a/tests/test_tracing_utils.py b/tests/test_tracing_utils.py
diff --git a/tests/tracing/test_integration_tests.py b/tests/tracing/test_integration_tests.py
