sentry-sdk 2.30.0__py2.py3-none-any.whl → 3.0.0a2__py2.py3-none-any.whl

sentry_sdk/integrations/django/signals_handlers.py

@@ -50,6 +50,7 @@ def patch_signals():
 
     old_live_receivers = Signal._live_receivers
 
+    @wraps(old_live_receivers)
     def _sentry_live_receivers(self, sender):
         # type: (Signal, Any) -> Union[tuple[list[Callable[..., Any]], list[Callable[..., Any]]], list[Callable[..., Any]]]
         if DJANGO_VERSION >= (5, 0):
@@ -68,8 +69,9 @@ def patch_signals():
                     op=OP.EVENT_DJANGO,
                     name=signal_name,
                     origin=DjangoIntegration.origin,
+                    only_if_parent=True,
                 ) as span:
-                    span.set_data("signal", signal_name)
+                    span.set_attribute("signal", signal_name)
                     return receiver(*args, **kwargs)
 
             return wrapper

sentry_sdk/integrations/django/templates.py

@@ -1,8 +1,8 @@
 import functools
 
 from django.template import TemplateSyntaxError
+from django.template.base import Origin
 from django.utils.safestring import mark_safe
-from django import VERSION as DJANGO_VERSION
 
 import sentry_sdk
 from sentry_sdk.consts import OP
@@ -17,13 +17,6 @@ if TYPE_CHECKING:
     from typing import Iterator
     from typing import Tuple
 
-try:
-    # support Django 1.9
-    from django.template.base import Origin
-except ImportError:
-    # backward compatibility
-    from django.template.loader import LoaderOrigin as Origin
-
 
 def get_template_frame_from_exception(exc_value):
     # type: (Optional[BaseException]) -> Optional[Dict[str, Any]]
@@ -72,14 +65,15 @@ def patch_templates():
             op=OP.TEMPLATE_RENDER,
             name=_get_template_name_description(self.template_name),
             origin=DjangoIntegration.origin,
+            only_if_parent=True,
         ) as span:
-            span.set_data("context", self.context_data)
+            if isinstance(self.context_data, dict):
+                for k, v in self.context_data.items():
+                    span.set_attribute(f"context.{k}", v)
             return real_rendered_content.fget(self)
 
     SimpleTemplateResponse.rendered_content = rendered_content
 
-    if DJANGO_VERSION < (1, 7):
-        return
     import django.shortcuts
 
     real_render = django.shortcuts.render
@@ -100,8 +94,10 @@ def patch_templates():
             op=OP.TEMPLATE_RENDER,
             name=_get_template_name_description(template_name),
             origin=DjangoIntegration.origin,
+            only_if_parent=True,
         ) as span:
-            span.set_data("context", context)
+            for k, v in context.items():
+                span.set_attribute(f"context.{k}", v)
             return real_render(request, template_name, context, *args, **kwargs)
 
     django.shortcuts.render = render

sentry_sdk/integrations/django/transactions.py

@@ -19,12 +19,7 @@ if TYPE_CHECKING:
     from typing import Union
     from re import Pattern
 
-from django import VERSION as DJANGO_VERSION
-
-if DJANGO_VERSION >= (2, 0):
-    from django.urls.resolvers import RoutePattern
-else:
-    RoutePattern = None
+from django.urls.resolvers import RoutePattern
 
 try:
     from django.urls import get_resolver

sentry_sdk/integrations/django/views.py

@@ -31,12 +31,14 @@ def patch_views():
     old_make_view_atomic = BaseHandler.make_view_atomic
     old_render = SimpleTemplateResponse.render
 
+    @functools.wraps(old_render)
     def sentry_patched_render(self):
         # type: (SimpleTemplateResponse) -> Any
         with sentry_sdk.start_span(
             op=OP.VIEW_RESPONSE_RENDER,
             name="serialize response",
             origin=DjangoIntegration.origin,
+            only_if_parent=True,
         ):
             return old_render(self)
 
@@ -77,8 +79,8 @@ def _wrap_sync_view(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()
+        if current_scope.root_span is not None:
+            current_scope.root_span.update_active_thread()
 
         sentry_scope = sentry_sdk.get_isolation_scope()
         # set the active thread id to the handler thread for sync views
@@ -90,6 +92,7 @@ def _wrap_sync_view(callback):
             op=OP.VIEW_RENDER,
             name=request.resolver_match.view_name,
             origin=DjangoIntegration.origin,
+            only_if_parent=True,
         ):
             return callback(request, *args, **kwargs)
 

sentry_sdk/integrations/falcon.py

@@ -1,8 +1,8 @@
 import sentry_sdk
+from sentry_sdk.consts import SOURCE_FOR_STYLE
 from sentry_sdk.integrations import _check_minimum_version, Integration, DidNotEnable
 from sentry_sdk.integrations._wsgi_common import RequestExtractor
 from sentry_sdk.integrations.wsgi import SentryWsgiMiddleware
-from sentry_sdk.tracing import SOURCE_FOR_STYLE
 from sentry_sdk.utils import (
     capture_internal_exceptions,
     ensure_integration_enabled,
@@ -19,8 +19,6 @@ if TYPE_CHECKING:
 
     from sentry_sdk._types import Event, EventProcessor
 
-# In Falcon 3.0 `falcon.api_helpers` is renamed to `falcon.app_helpers`
-# and `falcon.API` to `falcon.App`
 
 try:
     import falcon  # type: ignore
@@ -29,24 +27,15 @@ try:
 except ImportError:
     raise DidNotEnable("Falcon not installed")
 
-try:
-    import falcon.app_helpers  # type: ignore
-
-    falcon_helpers = falcon.app_helpers
-    falcon_app_class = falcon.App
-    FALCON3 = True
-except ImportError:
-    import falcon.api_helpers  # type: ignore
+import falcon.app_helpers  # type: ignore
 
-    falcon_helpers = falcon.api_helpers
-    falcon_app_class = falcon.API
-    FALCON3 = False
+falcon_helpers = falcon.app_helpers
+falcon_app_class = falcon.App
 
 
 _FALCON_UNSET = None  # type: Optional[object]
-if FALCON3:  # falcon.request._UNSET is only available in Falcon 3.0+
-    with capture_internal_exceptions():
-        from falcon.request import _UNSET as _FALCON_UNSET  # type: ignore[import-not-found, no-redef]
+with capture_internal_exceptions():
+    from falcon.request import _UNSET as _FALCON_UNSET  # type: ignore[import-not-found, no-redef]
 
 
 class FalconRequestExtractor(RequestExtractor):
@@ -232,14 +221,7 @@ def _exception_leads_to_http_5xx(ex, response):
         ex, (falcon.HTTPError, falcon.http_status.HTTPStatus)
     )
 
-    # We only check the HTTP status on Falcon 3 because in Falcon 2, the status on the response
-    # at the stage where we capture it is listed as 200, even though we would expect to see a 500
-    # status. Since at the time of this change, Falcon 2 is ca. 4 years old, we have decided to
-    # only perform this check on Falcon 3+, despite the risk that some handled errors might be
-    # reported to Sentry as unhandled on Falcon 2.
-    return (is_server_error or is_unhandled_error) and (
-        not FALCON3 or _has_http_5xx_status(response)
-    )
+    return (is_server_error or is_unhandled_error) and _has_http_5xx_status(response)
 
 
 def _has_http_5xx_status(response):

sentry_sdk/integrations/fastapi.py

@@ -3,9 +3,9 @@ from copy import deepcopy
 from functools import wraps
 
 import sentry_sdk
+from sentry_sdk.consts import SOURCE_FOR_STYLE, TransactionSource
 from sentry_sdk.integrations import DidNotEnable
 from sentry_sdk.scope import should_send_default_pii
-from sentry_sdk.tracing import SOURCE_FOR_STYLE, TransactionSource
 from sentry_sdk.utils import (
     transaction_from_function,
     logger,
@@ -89,8 +89,8 @@ def patch_get_request_handler():
             def _sentry_call(*args, **kwargs):
                 # type: (*Any, **Any) -> Any
                 current_scope = sentry_sdk.get_current_scope()
-                if current_scope.transaction is not None:
-                    current_scope.transaction.update_active_thread()
+                if current_scope.root_span is not None:
+                    current_scope.root_span.update_active_thread()
 
                 sentry_scope = sentry_sdk.get_isolation_scope()
                 if sentry_scope.profile is not None:

sentry_sdk/integrations/flask.py

@@ -1,4 +1,5 @@
 import sentry_sdk
+from sentry_sdk.consts import SOURCE_FOR_STYLE
 from sentry_sdk.integrations import _check_minimum_version, DidNotEnable, Integration
 from sentry_sdk.integrations._wsgi_common import (
     DEFAULT_HTTP_METHODS_TO_CAPTURE,
@@ -6,7 +7,6 @@ from sentry_sdk.integrations._wsgi_common import (
 )
 from sentry_sdk.integrations.wsgi import SentryWsgiMiddleware
 from sentry_sdk.scope import should_send_default_pii
-from sentry_sdk.tracing import SOURCE_FOR_STYLE
 from sentry_sdk.utils import (
     capture_internal_exceptions,
     ensure_integration_enabled,

sentry_sdk/integrations/gcp.py

@@ -5,10 +5,12 @@ from datetime import datetime, timedelta, timezone
 from os import environ
 
 import sentry_sdk
-from sentry_sdk.api import continue_trace
 from sentry_sdk.consts import OP
 from sentry_sdk.integrations import Integration
-from sentry_sdk.integrations._wsgi_common import _filter_headers
+from sentry_sdk.integrations._wsgi_common import (
+    _filter_headers,
+    _request_headers_to_span_attributes,
+)
 from sentry_sdk.scope import should_send_default_pii
 from sentry_sdk.tracing import TransactionSource
 from sentry_sdk.utils import (
@@ -84,42 +86,30 @@ def _wrap_func(func):
             if hasattr(gcp_event, "headers"):
                 headers = gcp_event.headers
 
-            transaction = continue_trace(
-                headers,
-                op=OP.FUNCTION_GCP,
-                name=environ.get("FUNCTION_NAME", ""),
-                source=TransactionSource.COMPONENT,
-                origin=GcpIntegration.origin,
-            )
-            sampling_context = {
-                "gcp_env": {
-                    "function_name": environ.get("FUNCTION_NAME"),
-                    "function_entry_point": environ.get("ENTRY_POINT"),
-                    "function_identity": environ.get("FUNCTION_IDENTITY"),
-                    "function_region": environ.get("FUNCTION_REGION"),
-                    "function_project": environ.get("GCP_PROJECT"),
-                },
-                "gcp_event": gcp_event,
-            }
-            with sentry_sdk.start_transaction(
-                transaction, custom_sampling_context=sampling_context
-            ):
-                try:
-                    return func(functionhandler, gcp_event, *args, **kwargs)
-                except Exception:
-                    exc_info = sys.exc_info()
-                    sentry_event, hint = event_from_exception(
-                        exc_info,
-                        client_options=client.options,
-                        mechanism={"type": "gcp", "handled": False},
-                    )
-                    sentry_sdk.capture_event(sentry_event, hint=hint)
-                    reraise(*exc_info)
-                finally:
-                    if timeout_thread:
-                        timeout_thread.stop()
-                    # Flush out the event queue
-                    client.flush()
+            with sentry_sdk.continue_trace(headers):
+                with sentry_sdk.start_span(
+                    op=OP.FUNCTION_GCP,
+                    name=environ.get("FUNCTION_NAME", ""),
+                    source=TransactionSource.COMPONENT,
+                    origin=GcpIntegration.origin,
+                    attributes=_prepopulate_attributes(gcp_event),
+                ):
+                    try:
+                        return func(functionhandler, gcp_event, *args, **kwargs)
+                    except Exception:
+                        exc_info = sys.exc_info()
+                        sentry_event, hint = event_from_exception(
+                            exc_info,
+                            client_options=client.options,
+                            mechanism={"type": "gcp", "handled": False},
+                        )
+                        sentry_sdk.capture_event(sentry_event, hint=hint)
+                        reraise(*exc_info)
+                    finally:
+                        if timeout_thread:
+                            timeout_thread.stop()
+                        # Flush out the event queue
+                        client.flush()
 
     return sentry_func  # type: ignore
 
@@ -232,3 +222,38 @@ def _get_google_cloud_logs_url(final_time):
     )
 
     return url
+
+
+ENV_TO_ATTRIBUTE = {
+    "FUNCTION_NAME": "faas.name",
+    "ENTRY_POINT": "gcp.function.entry_point",
+    "FUNCTION_IDENTITY": "gcp.function.identity",
+    "FUNCTION_REGION": "faas.region",
+    "GCP_PROJECT": "gcp.function.project",
+}
+
+EVENT_TO_ATTRIBUTE = {
+    "method": "http.request.method",
+    "query_string": "url.query",
+}
+
+
+def _prepopulate_attributes(gcp_event):
+    # type: (Any) -> dict[str, Any]
+    attributes = {
+        "cloud.provider": "gcp",
+    }
+
+    for key, attr in ENV_TO_ATTRIBUTE.items():
+        if environ.get(key):
+            attributes[attr] = environ[key]
+
+    for key, attr in EVENT_TO_ATTRIBUTE.items():
+        if getattr(gcp_event, key, None):
+            attributes[attr] = getattr(gcp_event, key)
+
+    if hasattr(gcp_event, "headers"):
+        headers = gcp_event.headers
+        attributes.update(_request_headers_to_span_attributes(headers))
+
+    return attributes

sentry_sdk/integrations/graphene.py

@@ -135,17 +135,10 @@ def graphql_span(schema, source, kwargs):
         },
     )
 
-    scope = sentry_sdk.get_current_scope()
-    if scope.span:
-        _graphql_span = scope.span.start_child(op=op, name=operation_name)
-    else:
-        _graphql_span = sentry_sdk.start_span(op=op, name=operation_name)
-
-    _graphql_span.set_data("graphql.document", source)
-    _graphql_span.set_data("graphql.operation.name", operation_name)
-    _graphql_span.set_data("graphql.operation.type", operation_type)
-
-    try:
+    with sentry_sdk.start_span(
+        op=op, name=operation_name, only_if_parent=True
+    ) as graphql_span:
+        graphql_span.set_attribute("graphql.document", source)
+        graphql_span.set_attribute("graphql.operation.name", operation_name)
+        graphql_span.set_attribute("graphql.operation.type", operation_type)
         yield
-    finally:
-        _graphql_span.finish()

sentry_sdk/integrations/grpc/aio/client.py

@@ -44,14 +44,17 @@ class SentryUnaryUnaryClientInterceptor(ClientInterceptor, UnaryUnaryClientInter
         request: Message,
     ) -> Union[UnaryUnaryCall, Message]:
         method = client_call_details.method
+        if isinstance(method, bytes):
+            method = method.decode()
 
         with sentry_sdk.start_span(
             op=OP.GRPC_CLIENT,
-            name="unary unary call to %s" % method.decode(),
+            name="unary unary call to %s" % method,
             origin=SPAN_ORIGIN,
+            only_if_parent=True,
         ) as span:
-            span.set_data("type", "unary unary")
-            span.set_data("method", method)
+            span.set_attribute("type", "unary unary")
+            span.set_attribute("method", method)
 
             client_call_details = self._update_client_call_details_metadata_from_scope(
                 client_call_details
@@ -59,7 +62,7 @@ class SentryUnaryUnaryClientInterceptor(ClientInterceptor, UnaryUnaryClientInter
 
             response = await continuation(client_call_details, request)
             status_code = await response.code()
-            span.set_data("code", status_code.name)
+            span.set_attribute("code", status_code.name)
 
             return response
 
@@ -74,14 +77,17 @@ class SentryUnaryStreamClientInterceptor(
         request: Message,
     ) -> Union[AsyncIterable[Any], UnaryStreamCall]:
         method = client_call_details.method
+        if isinstance(method, bytes):
+            method = method.decode()
 
         with sentry_sdk.start_span(
             op=OP.GRPC_CLIENT,
-            name="unary stream call to %s" % method.decode(),
+            name="unary stream call to %s" % method,
             origin=SPAN_ORIGIN,
+            only_if_parent=True,
         ) as span:
-            span.set_data("type", "unary stream")
-            span.set_data("method", method)
+            span.set_attribute("type", "unary stream")
+            span.set_attribute("method", method)
 
             client_call_details = self._update_client_call_details_metadata_from_scope(
                 client_call_details
@@ -89,6 +95,6 @@ class SentryUnaryStreamClientInterceptor(
 
             response = await continuation(client_call_details, request)
             # status_code = await response.code()
-            # span.set_data("code", status_code)
+            # span.set_attribute("code", status_code)
 
             return response

sentry_sdk/integrations/grpc/aio/server.py

@@ -2,7 +2,7 @@ import sentry_sdk
 from sentry_sdk.consts import OP
 from sentry_sdk.integrations import DidNotEnable
 from sentry_sdk.integrations.grpc.consts import SPAN_ORIGIN
-from sentry_sdk.tracing import Transaction, TransactionSource
+from sentry_sdk.tracing import TransactionSource
 from sentry_sdk.utils import event_from_exception
 
 from typing import TYPE_CHECKING
@@ -44,26 +44,24 @@ class ServerInterceptor(grpc.aio.ServerInterceptor):  # type: ignore
                     return await handler(request, context)
 
                 # What if the headers are empty?
-                transaction = Transaction.continue_from_headers(
-                    dict(context.invocation_metadata()),
-                    op=OP.GRPC_SERVER,
-                    name=name,
-                    source=TransactionSource.CUSTOM,
-                    origin=SPAN_ORIGIN,
-                )
-
-                with sentry_sdk.start_transaction(transaction=transaction):
-                    try:
-                        return await handler.unary_unary(request, context)
-                    except AbortError:
-                        raise
-                    except Exception as exc:
-                        event, hint = event_from_exception(
-                            exc,
-                            mechanism={"type": "grpc", "handled": False},
-                        )
-                        sentry_sdk.capture_event(event, hint=hint)
-                        raise
+                with sentry_sdk.continue_trace(dict(context.invocation_metadata())):
+                    with sentry_sdk.start_span(
+                        op=OP.GRPC_SERVER,
+                        name=name,
+                        source=TransactionSource.CUSTOM,
+                        origin=SPAN_ORIGIN,
+                    ):
+                        try:
+                            return await handler.unary_unary(request, context)
+                        except AbortError:
+                            raise
+                        except Exception as exc:
+                            event, hint = event_from_exception(
+                                exc,
+                                mechanism={"type": "grpc", "handled": False},
+                            )
+                            sentry_sdk.capture_event(event, hint=hint)
+                            raise
 
         elif not handler.request_streaming and handler.response_streaming:
             handler_factory = grpc.unary_stream_rpc_method_handler

sentry_sdk/integrations/grpc/client.py

@@ -31,16 +31,17 @@ class ClientInterceptor(
             op=OP.GRPC_CLIENT,
             name="unary unary call to %s" % method,
             origin=SPAN_ORIGIN,
+            only_if_parent=True,
         ) as span:
-            span.set_data("type", "unary unary")
-            span.set_data("method", method)
+            span.set_attribute("type", "unary unary")
+            span.set_attribute("method", method)
 
             client_call_details = self._update_client_call_details_metadata_from_scope(
                 client_call_details
             )
 
             response = continuation(client_call_details, request)
-            span.set_data("code", response.code().name)
+            span.set_attribute("code", response.code().name)
 
             return response
 
@@ -52,9 +53,10 @@ class ClientInterceptor(
             op=OP.GRPC_CLIENT,
             name="unary stream call to %s" % method,
             origin=SPAN_ORIGIN,
+            only_if_parent=True,
         ) as span:
-            span.set_data("type", "unary stream")
-            span.set_data("method", method)
+            span.set_attribute("type", "unary stream")
+            span.set_attribute("method", method)
 
             client_call_details = self._update_client_call_details_metadata_from_scope(
                 client_call_details
@@ -64,7 +66,7 @@ class ClientInterceptor(
                 client_call_details, request
             )  # type: UnaryStreamCall
             # Setting code on unary-stream leads to execution getting stuck
-            # span.set_data("code", response.code().name)
+            # span.set_attribute("code", response.code().name)
 
             return response
 

sentry_sdk/integrations/grpc/server.py

@@ -2,7 +2,7 @@ import sentry_sdk
 from sentry_sdk.consts import OP
 from sentry_sdk.integrations import DidNotEnable
 from sentry_sdk.integrations.grpc.consts import SPAN_ORIGIN
-from sentry_sdk.tracing import Transaction, TransactionSource
+from sentry_sdk.tracing import TransactionSource
 
 from typing import TYPE_CHECKING
 
@@ -38,19 +38,17 @@ class ServerInterceptor(grpc.ServerInterceptor):  # type: ignore
                 if name:
                     metadata = dict(context.invocation_metadata())
 
-                    transaction = Transaction.continue_from_headers(
-                        metadata,
-                        op=OP.GRPC_SERVER,
-                        name=name,
-                        source=TransactionSource.CUSTOM,
-                        origin=SPAN_ORIGIN,
-                    )
-
-                    with sentry_sdk.start_transaction(transaction=transaction):
-                        try:
-                            return handler.unary_unary(request, context)
-                        except BaseException as e:
-                            raise e
+                    with sentry_sdk.continue_trace(metadata):
+                        with sentry_sdk.start_span(
+                            op=OP.GRPC_SERVER,
+                            name=name,
+                            source=TransactionSource.CUSTOM,
+                            origin=SPAN_ORIGIN,
+                        ):
+                            try:
+                                return handler.unary_unary(request, context)
+                            except BaseException as e:
+                                raise e
                 else:
                     return handler.unary_unary(request, context)