Merge branch 'py-2071-get-driver-type-from-broker-url' of github.com:getsentry/sentry-python into py-2071-get-driver-type-from-broker-url

ericapisani · ericapisani · commit a0ffa8469faa · 2026-02-13T09:54:38.000-05:00
diff --git a/.craft.yml b/.craft.yml
@@ -1,4 +1,5 @@
-minVersion: 2.17.0
+minVersion: 2.21.1
+preReleaseCommand: bash scripts/bump-version.sh
 targets:
   - name: pypi
     includeNames: /^sentry[_\-]sdk.*$/
@@ -30,5 +31,12 @@ targets:
     license: MIT
   - name: sentry-pypi
     internalPypiRepo: getsentry/pypi
-changelog: CHANGELOG.md
-changelogPolicy: auto
+artifactProvider:
+  name: github
+  config:
+    artifacts:
+      CI:
+        - 'artifact-*'
+changelog:
+  filePath: CHANGELOG.md
+  policy: auto
diff --git a/.github/release.yml b/.github/release.yml
@@ -5,33 +5,37 @@ changelog:
     authors:
       - dependabot
   categories:
+    - title: Breaking Changes 🛠
+      commit_patterns:
+        - "^(?<type>\\w+(?:\\((?<scope>[^)]+)\\))?!:\\s*)"
+      semver: major
     - title: New Features ✨
       labels:
         - "Changelog: Feature"
       commit_patterns:
-        - "^feat\\b"
+        - "^(?<type>feat(?:\\((?<scope>[^)]+)\\))?!?:\\s*)"
       semver: minor
     - title: Bug Fixes 🐛
       labels:
         - "Changelog: Bugfix"
       commit_patterns:
-        - "^(fix|bugfix)\\b"
+        - "^(?<type>(?:fix|bugfix)(?:\\((?<scope>[^)]+)\\))?!?:\\s*)"
       semver: patch
     - title: Deprecations 🏗️
       labels:
         - "Changelog: Deprecation"
       commit_patterns:
-        - "deprecat"  # deprecation, deprecated
+        - "^(?<type>deprecat(?:ion|ed|e)(?:\\((?<scope>[^)]+)\\))?!?:?\\s*)"
       semver: patch
     - title: Documentation 📚
       labels:
         - "Changelog: Docs"
       commit_patterns:
-        - "^docs?\\b"
+        - "^(?<type>docs?(?:\\((?<scope>[^)]+)\\))?!?:\\s*)"
       semver: patch
     - title: Internal Changes 🔧
       labels:
         - "Changelog: Internal"
       commit_patterns:
-        - "^(build|ref|chore|ci|tests?)\\b"
+        - "^(?<type>(?:build|refactor|meta|chore|ci|ref|perf|tests?)(?:\\((?<scope>[^)]+)\\))?!?:\\s*)"
       semver: patch
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -61,8 +61,6 @@ jobs:
           path: |
             dist/*
           if-no-files-found: 'error'
-          # since this artifact will be merged, compression is not necessary
-          compression-level: '0'
 
   docs:
     name: Build SDK API Doc
@@ -85,17 +83,3 @@ jobs:
           path: |
             docs/_build/gh-pages.zip
           if-no-files-found: 'error'
-          # since this artifact will be merged, compression is not necessary
-          compression-level: '0'
-
-  merge:
-    name: Create Release Artifact
-    runs-on: ubuntu-latest
-    needs: [build_lambda_layer, docs]
-    steps:
-      - uses: actions/upload-artifact/merge@v6
-        with:
-          # Craft expects release assets from github to be a single artifact named after the sha.
-          name: ${{ github.sha }}
-          pattern: artifact-*
-          delete-merged: true
diff --git a/.github/workflows/test-integrations-dbs.yml b/.github/workflows/test-integrations-dbs.yml
@@ -66,7 +66,7 @@ jobs:
           python-version: ${{ matrix.python-version }}
           allow-prereleases: true
       - name: "Setup ClickHouse Server"
-        uses: getsentry/action-clickhouse-in-ci@v1.6
+        uses: getsentry/action-clickhouse-in-ci@v1.7
       - name: Setup Test Env
         run: |
           pip install "coverage[toml]" tox
diff --git a/scripts/bump-version.sh b/scripts/bump-version.sh
@@ -9,18 +9,15 @@ fi
 SCRIPT_DIR="$( dirname "$0" )"
 cd $SCRIPT_DIR/..
 
-OLD_VERSION="${1}"
-NEW_VERSION="${2}"
-
-echo "Current version: $OLD_VERSION"
-echo "Bumping version: $NEW_VERSION"
+echo "Current version: $CRAFT_OLD_VERSION"
+echo "Bumping version: $CRAFT_NEW_VERSION"
 
 function replace() {
     ! grep "$2" $3
     perl -i -pe "s/$1/$2/g" $3
     grep "$2" $3  # verify that replacement was successful
 }
 
-replace "version=\"$OLD_VERSION\"" "version=\"$NEW_VERSION\"" ./setup.py
-replace "VERSION = \"$OLD_VERSION\"" "VERSION = \"$NEW_VERSION\"" ./sentry_sdk/consts.py
-replace "release = \"$OLD_VERSION\"" "release = \"$NEW_VERSION\"" ./docs/conf.py
+replace "version=\"$CRAFT_OLD_VERSION\"" "version=\"$CRAFT_NEW_VERSION\"" ./setup.py
+replace "VERSION = \"$CRAFT_OLD_VERSION\"" "VERSION = \"$CRAFT_NEW_VERSION\"" ./sentry_sdk/consts.py
+replace "release = \"$CRAFT_OLD_VERSION\"" "release = \"$CRAFT_NEW_VERSION\"" ./docs/conf.py
diff --git a/scripts/populate_tox/package_dependencies.jsonl b/scripts/populate_tox/package_dependencies.jsonl
diff --git a/scripts/populate_tox/releases.jsonl b/scripts/populate_tox/releases.jsonl
diff --git a/scripts/populate_tox/tox.jinja b/scripts/populate_tox/tox.jinja
@@ -112,7 +112,6 @@ deps =
 
     # AWS Lambda
     aws_lambda: aws-cdk-lib
-    aws_lambda: aws-sam-cli
     aws_lambda: boto3
     aws_lambda: fastapi
     aws_lambda: requests
diff --git a/scripts/split_tox_gh_actions/templates/test_group.jinja b/scripts/split_tox_gh_actions/templates/test_group.jinja
@@ -51,7 +51,7 @@
 
       {% if needs_clickhouse %}
       - name: "Setup ClickHouse Server"
-        uses: getsentry/action-clickhouse-in-ci@v1.6
+        uses: getsentry/action-clickhouse-in-ci@v1.7
       {% endif %}
 
       {% if needs_redis %}
diff --git a/sentry_sdk/integrations/openai_agents/__init__.py b/sentry_sdk/integrations/openai_agents/__init__.py
@@ -1,8 +1,11 @@
 from sentry_sdk.integrations import DidNotEnable, Integration
+from sentry_sdk.utils import parse_version
+
+from functools import wraps
 
 from .patches import (
     _create_get_model_wrapper,
-    _create_get_all_tools_wrapper,
+    _get_all_tools,
     _create_run_wrapper,
     _create_run_streamed_wrapper,
     _patch_agent_run,
@@ -17,11 +20,21 @@
     # after it, even if we don't use it.
     import agents
     from agents.run import DEFAULT_AGENT_RUNNER
+    from agents.run import AgentRunner
+    from agents.version import __version__ as OPENAI_AGENTS_VERSION
 
 except ImportError:
     raise DidNotEnable("OpenAI Agents not installed")
 
 
+try:
+    # AgentRunner methods moved in v0.8
+    # https://github.com/openai/openai-agents-python/commit/3ce7c24d349b77bb750062b7e0e856d9ff48a5d5#diff-7470b3a5c5cbe2fcbb2703dc24f326f45a5819d853be2b1f395d122d278cd911
+    from agents.run_internal import run_loop
+except ImportError:
+    run_loop = None
+
+
 def _patch_runner() -> None:
     # Create the root span for one full agent run (including eventual handoffs)
     # Note agents.run.DEFAULT_AGENT_RUNNER.run_sync is a wrapper around
@@ -45,18 +58,67 @@ def _patch_model() -> None:
     )
 
 
-def _patch_tools() -> None:
-    agents.run.AgentRunner._get_all_tools = classmethod(
-        _create_get_all_tools_wrapper(agents.run.AgentRunner._get_all_tools),
-    )
+class OpenAIAgentsIntegration(Integration):
+    """
+    NOTE: With version 0.8.0, the class methods below have been refactored to functions.
+    - `AgentRunner._get_model()` -> `agents.run_internal.turn_preparation.get_model()`
+    - `AgentRunner._get_all_tools()` -> `agents.run_internal.turn_preparation.get_all_tools()`
+    - `AgentRunner._run_single_turn()` -> `agents.run_internal.run_loop.run_single_turn()`
+    - `RunImpl.execute_handoffs()` -> `agents.run_internal.turn_resolution.execute_handoffs()`
+    - `RunImpl.execute_final_output()` -> `agents.run_internal.turn_resolution.execute_final_output()`
 
+    Typical interaction with the library:
+    1. The user creates an Agent instance with configuration, including system instructions sent to every Responses API call.
+    2. The user passes the agent instance to a Runner with `run()` and `run_streamed()` methods. The latter can be used to incrementally receive progress.
+        - `Runner.run()` and `Runner.run_streamed()` are thin wrappers for `DEFAULT_AGENT_RUNNER.run()` and `DEFAULT_AGENT_RUNNER.run_streamed()`.
+        - `DEFAULT_AGENT_RUNNER.run()` and `DEFAULT_AGENT_RUNNER.run_streamed()` are patched in `_patch_runner()` with `_create_run_wrapper()` and `_create_run_streamed_wrapper()`, respectively.
+    3. In a loop, the agent repeatedly calls the Responses API, maintaining a conversation history that includes previous messages and tool results, which is passed to each call.
+        - A Model instance is created at the start of the loop by calling the `Runner._get_model()`. We patch the Model instance using `_create_get_model_wrapper()` in `_patch_model()`.
+        - Available tools are also deteremined at the start of the loop, with `Runner._get_all_tools()`. We patch Tool instances by iterating through the returned tools in `patches._get_all_tools()`.
+        - In each loop iteration, `run_single_turn()` or `run_single_turn_streamed()` is responsible for calling the Responses API, patched with `patched_run_single_turn()` and `patched_run_single_turn_streamed()`.
+    4. On loop termination, `RunImpl.execute_final_output()` is called. The function is patched with `patched_execute_final_output()`.
+
+    Local tools are run based on the return value from the Responses API as a post-API call step in the above loop.
+    Hosted MCP Tools are run as part of the Responses API call, and involve OpenAI reaching out to an external MCP server.
+    An agent can handoff to another agent, also directed by the return value of the Responses API and run post-API call in the loop.
+    Handoffs are a way to switch agent-wide configuration.
+    - Handoffs are executed by calling `RunImpl.execute_handoffs()`. The method is patched in `patched_execute_handoffs()`
+    """
 
-class OpenAIAgentsIntegration(Integration):
     identifier = "openai_agents"
 
     @staticmethod
     def setup_once() -> None:
         _patch_error_tracing()
-        _patch_tools()
         _patch_model()
         _patch_runner()
+
+        library_version = parse_version(OPENAI_AGENTS_VERSION)
+        if library_version is not None and library_version >= (
+            0,
+            8,
+        ):
+
+            @wraps(run_loop.get_all_tools)
+            async def new_wrapped_get_all_tools(
+                agent: "agents.Agent",
+                context_wrapper: "agents.RunContextWrapper",
+            ) -> "list[agents.Tool]":
+                return await _get_all_tools(
+                    run_loop.get_all_tools, agent, context_wrapper
+                )
+
+            agents.run.get_all_tools = new_wrapped_get_all_tools
+            return
+
+        original_get_all_tools = AgentRunner._get_all_tools
+
+        @wraps(AgentRunner._get_all_tools.__func__)
+        async def old_wrapped_get_all_tools(
+            cls: "agents.Runner",
+            agent: "agents.Agent",
+            context_wrapper: "agents.RunContextWrapper",
+        ) -> "list[agents.Tool]":
+            return await _get_all_tools(original_get_all_tools, agent, context_wrapper)
+
+        agents.run.AgentRunner._get_all_tools = classmethod(old_wrapped_get_all_tools)
diff --git a/sentry_sdk/integrations/openai_agents/patches/__init__.py b/sentry_sdk/integrations/openai_agents/patches/__init__.py
@@ -1,5 +1,5 @@
 from .models import _create_get_model_wrapper  # noqa: F401
-from .tools import _create_get_all_tools_wrapper  # noqa: F401
+from .tools import _get_all_tools  # noqa: F401
 from .runner import _create_run_wrapper, _create_run_streamed_wrapper  # noqa: F401
 from .agent_run import _patch_agent_run  # noqa: F401
 from .error_tracing import _patch_error_tracing  # noqa: F401
diff --git a/sentry_sdk/integrations/openai_agents/patches/agent_run.py b/sentry_sdk/integrations/openai_agents/patches/agent_run.py
@@ -94,7 +94,11 @@ def _maybe_start_agent_span(
     async def patched_run_single_turn(
         cls: "agents.Runner", *args: "Any", **kwargs: "Any"
     ) -> "Any":
-        """Patched _run_single_turn that creates agent invocation spans"""
+        """
+        Patched _run_single_turn that
+        - creates agent invocation spans if there is no already active agent invocation span.
+        - ends the agent invocation span if and only if an exception is raised in `_run_single_turn()`.
+        """
         agent = kwargs.get("agent")
         context_wrapper = kwargs.get("context_wrapper")
         should_run_agent_start_hooks = kwargs.get("should_run_agent_start_hooks", False)
@@ -121,7 +125,12 @@ async def patched_run_single_turn(
     async def patched_execute_handoffs(
         cls: "agents.Runner", *args: "Any", **kwargs: "Any"
     ) -> "Any":
-        """Patched execute_handoffs that creates handoff spans and ends agent span for handoffs"""
+        """
+        Patched execute_handoffs that
+        - creates and manages handoff spans.
+        - ends the agent invocation span.
+        - ends the workflow span if the response is streamed and an exception is raised in `execute_handoffs()`.
+        """
 
         context_wrapper = kwargs.get("context_wrapper")
         run_handoffs = kwargs.get("run_handoffs")
@@ -156,7 +165,11 @@ async def patched_execute_handoffs(
     async def patched_execute_final_output(
         cls: "agents.Runner", *args: "Any", **kwargs: "Any"
     ) -> "Any":
-        """Patched execute_final_output that ends agent span for final outputs"""
+        """
+        Patched execute_final_output that
+        - ends the agent invocation span.
+        - ends the workflow span if the response is streamed.
+        """
 
         agent = kwargs.get("agent")
         context_wrapper = kwargs.get("context_wrapper")
@@ -185,7 +198,10 @@ async def patched_execute_final_output(
     async def patched_run_single_turn_streamed(
         cls: "agents.Runner", *args: "Any", **kwargs: "Any"
     ) -> "Any":
-        """Patched _run_single_turn_streamed that creates agent invocation spans for streaming.
+        """
+        Patched _run_single_turn_streamed that
+        - creates agent invocation spans for streaming if there is no already active agent invocation span.
+        - ends the agent invocation span if and only if `_run_single_turn_streamed()` raises an exception.
 
         Note: Unlike _run_single_turn which uses keyword-only arguments (*,),
         _run_single_turn_streamed uses positional arguments. The call signature is:
diff --git a/sentry_sdk/integrations/openai_agents/patches/models.py b/sentry_sdk/integrations/openai_agents/patches/models.py
@@ -71,6 +71,11 @@ def _create_get_model_wrapper(
 ) -> "Callable[..., Any]":
     """
     Wraps the agents.Runner._get_model method to wrap the get_response method of the model to create a AI client span.
+
+    Responsible for
+    - creating and managing AI client spans.
+    - adding trace propagation headers to tools with type HostedMCPTool.
+    - setting the response model on agent invocation spans.
     """
 
     @wraps(
diff --git a/sentry_sdk/integrations/openai_agents/patches/runner.py b/sentry_sdk/integrations/openai_agents/patches/runner.py
@@ -22,7 +22,9 @@
 
 def _create_run_wrapper(original_func: "Callable[..., Any]") -> "Callable[..., Any]":
     """
-    Wraps the agents.Runner.run methods to create a root span for the agent workflow runs.
+    Wraps the agents.Runner.run methods to
+    - create and manage a root span for the agent workflow runs.
+    - end the agent invocation span if an `AgentsException` is raised in `run()`.
 
     Note agents.Runner.run_sync() is a wrapper around agents.Runner.run(),
     so it does not need to be wrapped separately.
@@ -85,7 +87,9 @@ def _create_run_streamed_wrapper(
     original_func: "Callable[..., Any]",
 ) -> "Callable[..., Any]":
     """
-    Wraps the agents.Runner.run_streamed method to create a root span for streaming agent workflow runs.
+    Wraps the agents.Runner.run_streamed method to
+    - create a root span for streaming agent workflow runs.
+    - end the workflow span if and only if the response stream is consumed or cancelled.
 
     Unlike run(), run_streamed() returns immediately with a RunResultStreaming object
     while execution continues in a background task. The workflow span must stay open
diff --git a/sentry_sdk/integrations/openai_agents/patches/tools.py b/sentry_sdk/integrations/openai_agents/patches/tools.py
diff --git a/tox.ini b/tox.ini
