Merge branch 'potel-base' into antonpirker/potel/anthropic

Author: antonpirker

.github/workflows/codeql-analysis.yml

@@ -17,13 +17,15 @@ on:
       - master
       - sentry-sdk-2.0
   pull_request:
-    # The branches below must be a subset of the branches above
-    branches:
-      - master
-      - sentry-sdk-2.0
   schedule:
     - cron: '18 18 * * 3'
 
+# Cancel in progress workflows on pull_requests.
+# https://docs.github.com/en/actions/using-jobs/using-concurrency#example-using-a-fallback-value
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
 permissions:
   contents: read
 

.github/workflows/enforce-license-compliance.yml

@@ -8,10 +8,11 @@ on:
       - release/*
       - sentry-sdk-2.0
   pull_request:
-    branches:
-      - master
-      - main
-      - sentry-sdk-2.0
+
+# Cancel in progress workflows on pull_requests.
+# https://docs.github.com/en/actions/using-jobs/using-concurrency#example-using-a-fallback-value
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
 
 jobs:
   enforce-license-compliance:

MIGRATION_GUIDE.md

@@ -1,6 +1,5 @@
 # Sentry SDK Migration Guide
 
-
 ## Upgrading to 3.0
 
 Looking to upgrade from Sentry SDK 2.x to 3.x? Here's a comprehensive list of what's changed. Looking for a more digestible summary? See the [guide in the docs](https://docs.sentry.io/platforms/python/migration/2.x-to-3.x) with the most common migration patterns.
@@ -19,11 +18,14 @@ Looking to upgrade from Sentry SDK 2.x to 3.x? Here's a comprehensive list of wh
 - `sentry_sdk.continue_trace` no longer returns a `Transaction` and is now a context manager.
 - Redis integration: In Redis pipeline spans there is no `span["data"]["redis.commands"]` that contains a dict `{"count": 3, "first_ten": ["cmd1", "cmd2", ...]}` but instead `span["data"]["redis.commands.count"]` (containing `3`) and `span["data"]["redis.commands.first_ten"]` (containing `["cmd1", "cmd2", ...]`).
 - clickhouse-driver integration: The query is now available under the `db.query.text` span attribute (only if `send_default_pii` is `True`).
+- `sentry_sdk.init` now returns `None` instead of a context manager.
 
 ### Removed
 
 - Spans no longer have a `description`. Use `name` instead.
 - Dropped support for Python 3.6.
+- The PyMongo integration no longer sets tags. The data is still accessible via span attributes.
+- The PyMongo integration doesn't set `operation_ids` anymore. The individual IDs (`operation_id`, `request_id`, `session_id`) are now accessible as separate span attributes.
 - `sentry_sdk.metrics` and associated metrics APIs have been removed as Sentry no longer accepts metrics data in this form. See https://sentry.zendesk.com/hc/en-us/articles/26369339769883-Upcoming-API-Changes-to-Metrics
 - The experimental options `enable_metrics`, `before_emit_metric` and `metric_code_locations` have been removed.
 - When setting span status, the HTTP status code is no longer automatically added as a tag.
@@ -38,7 +40,6 @@ Looking to upgrade from Sentry SDK 2.x to 3.x? Here's a comprehensive list of wh
 - `continue_from_headers`, `continue_from_environ` and `from_traceparent` have been removed, please use top-level API `sentry_sdk.continue_trace` instead.
 - `PropagationContext` constructor no longer takes a `dynamic_sampling_context` but takes a `baggage` object instead.
 
-
 ### Deprecated
 
 - `sentry_sdk.start_transaction` is deprecated. Use `sentry_sdk.start_span` instead.

requirements-devenv.txt

@@ -1,5 +1,5 @@
 -r requirements-linting.txt
 -r requirements-testing.txt
 mockupdb # required by `pymongo` tests that are enabled by `pymongo` from linter requirements
-pytest<7.0.0 # https://github.com/pytest-dev/pytest/issues/9621; see tox.ini
+pytest
 pytest-asyncio

sentry_sdk/_init_implementation.py

@@ -3,27 +3,11 @@
 import sentry_sdk
 
 if TYPE_CHECKING:
-    from typing import Any, ContextManager, Optional
+    from typing import Any, Optional
 
     import sentry_sdk.consts
 
 
-class _InitGuard:
-    def __init__(self, client):
-        # type: (sentry_sdk.Client) -> None
-        self._client = client
-
-    def __enter__(self):
-        # type: () -> _InitGuard
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        # type: (Any, Any, Any) -> None
-        c = self._client
-        if c is not None:
-            c.close()
-
-
 def _check_python_deprecations():
     # type: () -> None
     # Since we're likely to deprecate Python versions in the future, I'm keeping
@@ -33,16 +17,14 @@ def _check_python_deprecations():
 
 
 def _init(*args, **kwargs):
-    # type: (*Optional[str], **Any) -> ContextManager[Any]
+    # type: (*Optional[str], **Any) -> None
     """Initializes the SDK and optionally integrations.
 
     This takes the same arguments as the client constructor.
     """
     client = sentry_sdk.Client(*args, **kwargs)
     sentry_sdk.get_global_scope().set_client(client)
     _check_python_deprecations()
-    rv = _InitGuard(client)
-    return rv
 
 
 if TYPE_CHECKING:
@@ -52,7 +34,7 @@ def _init(*args, **kwargs):
     # Use `ClientConstructor` to define the argument types of `init` and
     # `ContextManager[Any]` to tell static analyzers about the return type.
 
-    class init(sentry_sdk.consts.ClientConstructor, _InitGuard):  # noqa: N801
+    class init(sentry_sdk.consts.ClientConstructor):  # noqa: N801
         pass
 
 else:

sentry_sdk/integrations/aiohttp.py

@@ -229,11 +229,17 @@ async def on_request_start(session, trace_config_ctx, params):
             % (method, parsed_url.url if parsed_url else SENSITIVE_DATA_SUBSTITUTE),
             origin=AioHttpIntegration.origin,
         )
-        span.set_data(SPANDATA.HTTP_METHOD, method)
+
+        data = {
+            SPANDATA.HTTP_METHOD: method,
+        }
         if parsed_url is not None:
-            span.set_data("url", parsed_url.url)
-            span.set_data(SPANDATA.HTTP_QUERY, parsed_url.query)
-            span.set_data(SPANDATA.HTTP_FRAGMENT, parsed_url.fragment)
+            data["url"] = parsed_url.url
+            data[SPANDATA.HTTP_QUERY] = parsed_url.query
+            data[SPANDATA.HTTP_FRAGMENT] = parsed_url.fragment
+
+        for key, value in data.items():
+            span.set_data(key, value)
 
         client = sentry_sdk.get_client()
 
@@ -258,12 +264,23 @@ async def on_request_start(session, trace_config_ctx, params):
                     params.headers[key] = value
 
         trace_config_ctx.span = span
+        trace_config_ctx.span_data = data
 
     async def on_request_end(session, trace_config_ctx, params):
         # type: (ClientSession, SimpleNamespace, TraceRequestEndParams) -> None
         if trace_config_ctx.span is None:
             return
 
+        span_data = trace_config_ctx.span_data or {}
+        span_data[SPANDATA.HTTP_STATUS_CODE] = int(params.response.status)
+        span_data["reason"] = params.response.reason
+
+        sentry_sdk.add_breadcrumb(
+            type="http",
+            category="httplib",
+            data=span_data,
+        )
+
         span = trace_config_ctx.span
         span.set_http_status(int(params.response.status))
         span.set_data("reason", params.response.reason)

sentry_sdk/integrations/asyncpg.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 import contextlib
-from typing import Any, TypeVar, Callable, Awaitable, Iterator
+from typing import Any, TypeVar, Callable, Awaitable, Iterator, Optional
 
 import sentry_sdk
 from sentry_sdk.consts import OP, SPANDATA
@@ -21,6 +21,7 @@
 except ImportError:
     raise DidNotEnable("asyncpg not installed.")
 
+
 # asyncpg.__version__ is a string containing the semantic version in the form of "<major>.<minor>.<patch>"
 asyncpg_version = parse_version(asyncpg.__version__)
 
@@ -123,10 +124,13 @@ def _wrap_connection_method(
     async def _inner(*args: Any, **kwargs: Any) -> T:
         if sentry_sdk.get_client().get_integration(AsyncPGIntegration) is None:
             return await f(*args, **kwargs)
+
         query = args[1]
         params_list = args[2] if len(args) > 2 else None
+
         with _record(None, query, params_list, executemany=executemany) as span:
-            _set_db_data(span, args[0])
+            data = _get_db_data(conn=args[0])
+            _set_on_span(span, data)
             res = await f(*args, **kwargs)
 
         return res
@@ -146,7 +150,8 @@ def _inner(*args: Any, **kwargs: Any) -> T:  # noqa: N807
             params_list,
             executemany=False,
         ) as span:
-            _set_db_data(span, args[0])
+            data = _get_db_data(conn=args[0])
+            _set_on_span(span, data)
             res = f(*args, **kwargs)
             span.set_attribute("db.cursor", _serialize_span_attribute(res))
 
@@ -160,41 +165,19 @@ async def _inner(*args: Any, **kwargs: Any) -> T:
         if sentry_sdk.get_client().get_integration(AsyncPGIntegration) is None:
             return await f(*args, **kwargs)
 
-        user = kwargs["params"].user
-        database = kwargs["params"].database
-
         with sentry_sdk.start_span(
             op=OP.DB,
             name="connect",
             origin=AsyncPGIntegration.origin,
         ) as span:
-            span.set_attribute(SPANDATA.DB_SYSTEM, "postgresql")
-            addr = kwargs.get("addr")
-            if addr:
-                try:
-                    span.set_attribute(SPANDATA.SERVER_ADDRESS, addr[0])
-                    span.set_attribute(SPANDATA.SERVER_PORT, addr[1])
-                except IndexError:
-                    pass
-
-            span.set_attribute(SPANDATA.DB_NAME, database)
-            span.set_attribute(SPANDATA.DB_USER, user)
+            data = _get_db_data(
+                addr=kwargs.get("addr"),
+                database=kwargs["params"].database,
+                user=kwargs["params"].user,
+            )
+            _set_on_span(span, data)
 
             with capture_internal_exceptions():
-                data = {}
-                for attr in (
-                    "db.cursor",
-                    "db.params",
-                    "db.paramstyle",
-                    SPANDATA.DB_NAME,
-                    SPANDATA.DB_SYSTEM,
-                    SPANDATA.DB_USER,
-                    SPANDATA.SERVER_ADDRESS,
-                    SPANDATA.SERVER_PORT,
-                ):
-                    if span.get_attribute(attr):
-                        data[attr] = span.get_attribute(attr)
-
                 sentry_sdk.add_breadcrumb(
                     message="connect", category="query", data=data
                 )
@@ -206,21 +189,37 @@ async def _inner(*args: Any, **kwargs: Any) -> T:
     return _inner
 
 
-def _set_db_data(span: Span, conn: Any) -> None:
-    span.set_attribute(SPANDATA.DB_SYSTEM, "postgresql")
+def _get_db_data(
+    conn: Any = None,
+    addr: Optional[tuple[str]] = None,
+    database: Optional[str] = None,
+    user: Optional[str] = None,
+) -> dict[str, str]:
+    if conn is not None:
+        addr = conn._addr
+        database = conn._params.database
+        user = conn._params.user
+
+    data = {
+        SPANDATA.DB_SYSTEM: "postgresql",
+    }
 
-    addr = conn._addr
     if addr:
         try:
-            span.set_attribute(SPANDATA.SERVER_ADDRESS, addr[0])
-            span.set_attribute(SPANDATA.SERVER_PORT, addr[1])
+            data[SPANDATA.SERVER_ADDRESS] = addr[0]
+            data[SPANDATA.SERVER_PORT] = addr[1]
         except IndexError:
             pass
 
-    database = conn._params.database
     if database:
-        span.set_attribute(SPANDATA.DB_NAME, database)
+        data[SPANDATA.DB_NAME] = database
 
-    user = conn._params.user
     if user:
-        span.set_attribute(SPANDATA.DB_USER, user)
+        data[SPANDATA.DB_USER] = user
+
+    return data
+
+
+def _set_on_span(span: Span, data: dict[str, Any]):
+    for key, value in data.items():
+        span.set_attribute(key, value)

sentry_sdk/integrations/boto3.py

@@ -74,15 +74,20 @@ def _sentry_request_created(service_id, request, operation_name, **kwargs):
         origin=Boto3Integration.origin,
     )
 
+    data = {
+        SPANDATA.HTTP_METHOD: request.method,
+    }
     with capture_internal_exceptions():
         parsed_url = parse_url(request.url, sanitize=False)
-        span.set_data("aws.request.url", parsed_url.url)
-        span.set_data(SPANDATA.HTTP_QUERY, parsed_url.query)
-        span.set_data(SPANDATA.HTTP_FRAGMENT, parsed_url.fragment)
+        data["aws.request.url"] = parsed_url.url
+        data[SPANDATA.HTTP_QUERY] = parsed_url.query
+        data[SPANDATA.HTTP_FRAGMENT] = parsed_url.fragment
+
+    for key, value in data.items():
+        span.set_data(key, value)
 
     span.set_tag("aws.service_id", service_id)
     span.set_tag("aws.operation_name", operation_name)
-    span.set_data(SPANDATA.HTTP_METHOD, request.method)
 
     # We do it in order for subsequent http calls/retries be
     # attached to this span.
@@ -91,6 +96,7 @@ def _sentry_request_created(service_id, request, operation_name, **kwargs):
     # request.context is an open-ended data-structure
     # where we can add anything useful in request life cycle.
     request.context["_sentrysdk_span"] = span
+    request.context["_sentrysdk_span_data"] = data
 
 
 def _sentry_after_call(context, parsed, **kwargs):
@@ -100,6 +106,15 @@ def _sentry_after_call(context, parsed, **kwargs):
     # Span could be absent if the integration is disabled.
     if span is None:
         return
+
+    span_data = context.pop("_sentrysdk_span_data", {})
+
+    sentry_sdk.add_breadcrumb(
+        type="http",
+        category="httplib",
+        data=span_data,
+    )
+
     span.__exit__(None, None, None)
 
     body = parsed.get("Body")
@@ -143,4 +158,13 @@ def _sentry_after_call_error(context, exception, **kwargs):
     # Span could be absent if the integration is disabled.
     if span is None:
         return
+
+    span_data = context.pop("_sentrysdk_span_data", {})
+
+    sentry_sdk.add_breadcrumb(
+        type="http",
+        category="httplib",
+        data=span_data,
+    )
+
     span.__exit__(type(exception), exception, None)

sentry_sdk/integrations/django/asgi.py

@@ -172,6 +172,10 @@ def wrap_async_view(callback):
     @functools.wraps(callback)
     async def sentry_wrapped_callback(request, *args, **kwargs):
         # type: (Any, *Any, **Any) -> Any
+        current_scope = sentry_sdk.get_current_scope()
+        if current_scope.transaction is not None:
+            current_scope.transaction.update_active_thread()
+
         sentry_scope = sentry_sdk.get_isolation_scope()
         if sentry_scope.profile is not None:
             sentry_scope.profile.update_active_thread_id()

sentry_sdk/integrations/django/views.py

@@ -76,6 +76,10 @@ def _wrap_sync_view(callback):
     @functools.wraps(callback)
     def sentry_wrapped_callback(request, *args, **kwargs):
         # type: (Any, *Any, **Any) -> Any
+        current_scope = sentry_sdk.get_current_scope()
+        if current_scope.transaction is not None:
+            current_scope.transaction.update_active_thread()
+
         sentry_scope = sentry_sdk.get_isolation_scope()
         # set the active thread id to the handler thread for sync views
         # this isn't necessary for async views since that runs on main