sentry-sdk 3.0.0a1__py2.py3-none-any.whl → 3.0.0a3__py2.py3-none-any.whl

sentry_sdk/integrations/flask.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sentry_sdk
 from sentry_sdk.consts import SOURCE_FOR_STYLE
 from sentry_sdk.integrations import _check_minimum_version, DidNotEnable, Integration
@@ -57,10 +58,9 @@ class FlaskIntegration(Integration):
 
     def __init__(
         self,
-        transaction_style="endpoint",  # type: str
-        http_methods_to_capture=DEFAULT_HTTP_METHODS_TO_CAPTURE,  # type: tuple[str, ...]
-    ):
-        # type: (...) -> None
+        transaction_style: str = "endpoint",
+        http_methods_to_capture: tuple[str, ...] = DEFAULT_HTTP_METHODS_TO_CAPTURE,
+    ) -> None:
         if transaction_style not in TRANSACTION_STYLE_VALUES:
             raise ValueError(
                 "Invalid value for transaction_style: %s (must be in %s)"
@@ -70,8 +70,7 @@ class FlaskIntegration(Integration):
         self.http_methods_to_capture = tuple(map(str.upper, http_methods_to_capture))
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         try:
             from quart import Quart  # type: ignore
 
@@ -93,8 +92,9 @@ class FlaskIntegration(Integration):
 
         old_app = Flask.__call__
 
-        def sentry_patched_wsgi_app(self, environ, start_response):
-            # type: (Any, Dict[str, str], Callable[..., Any]) -> _ScopedResponse
+        def sentry_patched_wsgi_app(
+            self: Any, environ: Dict[str, str], start_response: Callable[..., Any]
+        ) -> _ScopedResponse:
             if sentry_sdk.get_client().get_integration(FlaskIntegration) is None:
                 return old_app(self, environ, start_response)
 
@@ -114,8 +114,9 @@ class FlaskIntegration(Integration):
         Flask.__call__ = sentry_patched_wsgi_app
 
 
-def _add_sentry_trace(sender, template, context, **extra):
-    # type: (Flask, Any, Dict[str, Any], **Any) -> None
+def _add_sentry_trace(
+    sender: Flask, template: Any, context: Dict[str, Any], **extra: Any
+) -> None:
     if "sentry_trace" in context:
         return
 
@@ -125,8 +126,9 @@ def _add_sentry_trace(sender, template, context, **extra):
     context["sentry_trace_meta"] = trace_meta
 
 
-def _set_transaction_name_and_source(scope, transaction_style, request):
-    # type: (sentry_sdk.Scope, str, Request) -> None
+def _set_transaction_name_and_source(
+    scope: sentry_sdk.Scope, transaction_style: str, request: Request
+) -> None:
     try:
         name_for_style = {
             "url": request.url_rule.rule,
@@ -140,8 +142,7 @@ def _set_transaction_name_and_source(scope, transaction_style, request):
         pass
 
 
-def _request_started(app, **kwargs):
-    # type: (Flask, **Any) -> None
+def _request_started(app: Flask, **kwargs: Any) -> None:
     integration = sentry_sdk.get_client().get_integration(FlaskIntegration)
     if integration is None:
         return
@@ -160,47 +161,39 @@ def _request_started(app, **kwargs):
 
 
 class FlaskRequestExtractor(RequestExtractor):
-    def env(self):
-        # type: () -> Dict[str, str]
+    def env(self) -> Dict[str, str]:
         return self.request.environ
 
-    def cookies(self):
-        # type: () -> Dict[Any, Any]
+    def cookies(self) -> Dict[Any, Any]:
         return {
             k: v[0] if isinstance(v, list) and len(v) == 1 else v
             for k, v in self.request.cookies.items()
         }
 
-    def raw_data(self):
-        # type: () -> bytes
+    def raw_data(self) -> bytes:
         return self.request.get_data()
 
-    def form(self):
-        # type: () -> ImmutableMultiDict[str, Any]
+    def form(self) -> ImmutableMultiDict[str, Any]:
         return self.request.form
 
-    def files(self):
-        # type: () -> ImmutableMultiDict[str, Any]
+    def files(self) -> ImmutableMultiDict[str, Any]:
         return self.request.files
 
-    def is_json(self):
-        # type: () -> bool
+    def is_json(self) -> bool:
         return self.request.is_json
 
-    def json(self):
-        # type: () -> Any
+    def json(self) -> Any:
         return self.request.get_json(silent=True)
 
-    def size_of_file(self, file):
-        # type: (FileStorage) -> int
+    def size_of_file(self, file: FileStorage) -> int:
         return file.content_length
 
 
-def _make_request_event_processor(app, request, integration):
-    # type: (Flask, Callable[[], Request], FlaskIntegration) -> EventProcessor
+def _make_request_event_processor(
+    app: Flask, request: Callable[[], Request], integration: FlaskIntegration
+) -> EventProcessor:
 
-    def inner(event, hint):
-        # type: (Event, dict[str, Any]) -> Event
+    def inner(event: Event, hint: dict[str, Any]) -> Event:
 
         # if the request is gone we are fine not logging the data from
         # it.  This might happen if the processor is pushed away to
@@ -221,8 +214,9 @@ def _make_request_event_processor(app, request, integration):
 
 
 @ensure_integration_enabled(FlaskIntegration)
-def _capture_exception(sender, exception, **kwargs):
-    # type: (Flask, Union[ValueError, BaseException], **Any) -> None
+def _capture_exception(
+    sender: Flask, exception: Union[ValueError, BaseException], **kwargs: Any
+) -> None:
     event, hint = event_from_exception(
         exception,
         client_options=sentry_sdk.get_client().options,
@@ -232,8 +226,7 @@ def _capture_exception(sender, exception, **kwargs):
     sentry_sdk.capture_event(event, hint=hint)
 
 
-def _add_user_to_event(event):
-    # type: (Event) -> None
+def _add_user_to_event(event: Event) -> None:
     if flask_login is None:
         return
 

sentry_sdk/integrations/gcp.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import functools
 import sys
 from copy import deepcopy
@@ -39,11 +40,11 @@ if TYPE_CHECKING:
     F = TypeVar("F", bound=Callable[..., Any])
 
 
-def _wrap_func(func):
-    # type: (F) -> F
+def _wrap_func(func: F) -> F:
     @functools.wraps(func)
-    def sentry_func(functionhandler, gcp_event, *args, **kwargs):
-        # type: (Any, Any, *Any, **Any) -> Any
+    def sentry_func(
+        functionhandler: Any, gcp_event: Any, *args: Any, **kwargs: Any
+    ) -> Any:
         client = sentry_sdk.get_client()
 
         integration = client.get_integration(GcpIntegration)
@@ -118,13 +119,11 @@ class GcpIntegration(Integration):
     identifier = "gcp"
     origin = f"auto.function.{identifier}"
 
-    def __init__(self, timeout_warning=False):
-        # type: (bool) -> None
+    def __init__(self, timeout_warning: bool = False) -> None:
         self.timeout_warning = timeout_warning
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         import __main__ as gcp_functions
 
         if not hasattr(gcp_functions, "worker_v1"):
@@ -140,11 +139,11 @@ class GcpIntegration(Integration):
         )
 
 
-def _make_request_event_processor(gcp_event, configured_timeout, initial_time):
-    # type: (Any, Any, Any) -> EventProcessor
+def _make_request_event_processor(
+    gcp_event: Any, configured_timeout: Any, initial_time: Any
+) -> EventProcessor:
 
-    def event_processor(event, hint):
-        # type: (Event, Hint) -> Optional[Event]
+    def event_processor(event: Event, hint: Hint) -> Optional[Event]:
 
         final_time = datetime.now(timezone.utc)
         time_diff = final_time - initial_time
@@ -195,8 +194,7 @@ def _make_request_event_processor(gcp_event, configured_timeout, initial_time):
     return event_processor
 
 
-def _get_google_cloud_logs_url(final_time):
-    # type: (datetime) -> str
+def _get_google_cloud_logs_url(final_time: datetime) -> str:
     """
     Generates a Google Cloud Logs console URL based on the environment variables
     Arguments:
@@ -238,8 +236,7 @@ EVENT_TO_ATTRIBUTE = {
 }
 
 
-def _prepopulate_attributes(gcp_event):
-    # type: (Any) -> dict[str, Any]
+def _prepopulate_attributes(gcp_event: Any) -> dict[str, Any]:
     attributes = {
         "cloud.provider": "gcp",
     }

sentry_sdk/integrations/gnu_backtrace.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import re
 
 import sentry_sdk
@@ -38,17 +39,14 @@ class GnuBacktraceIntegration(Integration):
     identifier = "gnu_backtrace"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         @add_global_event_processor
-        def process_gnu_backtrace(event, hint):
-            # type: (Event, dict[str, Any]) -> Event
+        def process_gnu_backtrace(event: Event, hint: dict[str, Any]) -> Event:
             with capture_internal_exceptions():
                 return _process_gnu_backtrace(event, hint)
 
 
-def _process_gnu_backtrace(event, hint):
-    # type: (Event, dict[str, Any]) -> Event
+def _process_gnu_backtrace(event: Event, hint: dict[str, Any]) -> Event:
     if sentry_sdk.get_client().get_integration(GnuBacktraceIntegration) is None:
         return event
 

sentry_sdk/integrations/gql.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sentry_sdk
 from sentry_sdk.utils import (
     event_from_exception,
@@ -34,19 +35,17 @@ class GQLIntegration(Integration):
     identifier = "gql"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         gql_version = parse_version(gql.__version__)
         _check_minimum_version(GQLIntegration, gql_version)
 
         _patch_execute()
 
 
-def _data_from_document(document):
-    # type: (DocumentNode) -> EventDataType
+def _data_from_document(document: DocumentNode) -> EventDataType:
     try:
         operation_ast = get_operation_ast(document)
-        data = {"query": print_ast(document)}  # type: EventDataType
+        data: EventDataType = {"query": print_ast(document)}
 
         if operation_ast is not None:
             data["variables"] = operation_ast.variable_definitions
@@ -58,8 +57,7 @@ def _data_from_document(document):
         return dict()
 
 
-def _transport_method(transport):
-    # type: (Union[Transport, AsyncTransport]) -> str
+def _transport_method(transport: Union[Transport, AsyncTransport]) -> str:
     """
     The RequestsHTTPTransport allows defining the HTTP method; all
     other transports use POST.
@@ -70,8 +68,9 @@ def _transport_method(transport):
         return "POST"
 
 
-def _request_info_from_transport(transport):
-    # type: (Union[Transport, AsyncTransport, None]) -> Dict[str, str]
+def _request_info_from_transport(
+    transport: Union[Transport, AsyncTransport, None],
+) -> Dict[str, str]:
     if transport is None:
         return {}
 
@@ -87,13 +86,13 @@ def _request_info_from_transport(transport):
     return request_info
 
 
-def _patch_execute():
-    # type: () -> None
+def _patch_execute() -> None:
     real_execute = gql.Client.execute
 
     @ensure_integration_enabled(GQLIntegration, real_execute)
-    def sentry_patched_execute(self, document, *args, **kwargs):
-        # type: (gql.Client, DocumentNode, Any, Any) -> Any
+    def sentry_patched_execute(
+        self: gql.Client, document: DocumentNode, *args: Any, **kwargs: Any
+    ) -> Any:
         scope = sentry_sdk.get_isolation_scope()
         scope.add_event_processor(_make_gql_event_processor(self, document))
 
@@ -112,10 +111,10 @@ def _patch_execute():
     gql.Client.execute = sentry_patched_execute
 
 
-def _make_gql_event_processor(client, document):
-    # type: (gql.Client, DocumentNode) -> EventProcessor
-    def processor(event, hint):
-        # type: (Event, dict[str, Any]) -> Event
+def _make_gql_event_processor(
+    client: gql.Client, document: DocumentNode
+) -> EventProcessor:
+    def processor(event: Event, hint: dict[str, Any]) -> Event:
         try:
             errors = hint["exc_info"][1].errors
         except (AttributeError, KeyError):

sentry_sdk/integrations/graphene.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from contextlib import contextmanager
 
 import sentry_sdk
@@ -31,22 +32,21 @@ class GrapheneIntegration(Integration):
     identifier = "graphene"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         version = package_version("graphene")
         _check_minimum_version(GrapheneIntegration, version)
 
         _patch_graphql()
 
 
-def _patch_graphql():
-    # type: () -> None
+def _patch_graphql() -> None:
     old_graphql_sync = graphene_schema.graphql_sync
     old_graphql_async = graphene_schema.graphql
 
     @ensure_integration_enabled(GrapheneIntegration, old_graphql_sync)
-    def _sentry_patched_graphql_sync(schema, source, *args, **kwargs):
-        # type: (GraphQLSchema, Union[str, Source], Any, Any) -> ExecutionResult
+    def _sentry_patched_graphql_sync(
+        schema: GraphQLSchema, source: Union[str, Source], *args: Any, **kwargs: Any
+    ) -> ExecutionResult:
         scope = sentry_sdk.get_isolation_scope()
         scope.add_event_processor(_event_processor)
 
@@ -68,8 +68,9 @@ def _patch_graphql():
 
         return result
 
-    async def _sentry_patched_graphql_async(schema, source, *args, **kwargs):
-        # type: (GraphQLSchema, Union[str, Source], Any, Any) -> ExecutionResult
+    async def _sentry_patched_graphql_async(
+        schema: GraphQLSchema, source: Union[str, Source], *args: Any, **kwargs: Any
+    ) -> ExecutionResult:
         integration = sentry_sdk.get_client().get_integration(GrapheneIntegration)
         if integration is None:
             return await old_graphql_async(schema, source, *args, **kwargs)
@@ -99,8 +100,7 @@ def _patch_graphql():
     graphene_schema.graphql = _sentry_patched_graphql_async
 
 
-def _event_processor(event, hint):
-    # type: (Event, Dict[str, Any]) -> Event
+def _event_processor(event: Event, hint: Dict[str, Any]) -> Event:
     if should_send_default_pii():
         request_info = event.setdefault("request", {})
         request_info["api_target"] = "graphql"
@@ -112,8 +112,9 @@ def _event_processor(event, hint):
 
 
 @contextmanager
-def graphql_span(schema, source, kwargs):
-    # type: (GraphQLSchema, Union[str, Source], Dict[str, Any]) -> Generator[None, None, None]
+def graphql_span(
+    schema: GraphQLSchema, source: Union[str, Source], kwargs: Dict[str, Any]
+) -> Generator[None, None, None]:
     operation_name = kwargs.get("operation_name")
 
     operation_type = "query"

sentry_sdk/integrations/grpc/__init__.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from functools import wraps
 
 import grpc
@@ -6,6 +7,7 @@ from grpc.aio import Channel as AsyncChannel
 from grpc.aio import Server as AsyncServer
 
 from sentry_sdk.integrations import Integration
+from sentry_sdk.utils import parse_version
 
 from .client import ClientInterceptor
 from .server import ServerInterceptor
@@ -41,6 +43,8 @@ else:
 
 P = ParamSpec("P")
 
+GRPC_VERSION = parse_version(grpc.__version__)
+
 
 def _wrap_channel_sync(func: Callable[P, Channel]) -> Callable[P, Channel]:
     "Wrapper for synchronous secure and insecure channel."
@@ -127,7 +131,21 @@ def _wrap_async_server(func: Callable[P, AsyncServer]) -> Callable[P, AsyncServe
         **kwargs: P.kwargs,
     ) -> Server:
         server_interceptor = AsyncServerInterceptor()
-        interceptors = (server_interceptor, *(interceptors or []))
+        interceptors: Sequence[grpc.ServerInterceptor] = [
+            server_interceptor,
+            *(interceptors or []),
+        ]
+
+        try:
+            # We prefer interceptors as a list because of compatibility with
+            # opentelemetry https://github.com/getsentry/sentry-python/issues/4389
+            # However, prior to grpc 1.42.0, only tuples were accepted, so we
+            # have no choice there.
+            if GRPC_VERSION is not None and GRPC_VERSION < (1, 42, 0):
+                interceptors = tuple(interceptors)
+        except Exception:
+            pass
+
         return func(*args, interceptors=interceptors, **kwargs)  # type: ignore
 
     return patched_aio_server  # type: ignore

sentry_sdk/integrations/grpc/aio/server.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sentry_sdk
 from sentry_sdk.consts import OP
 from sentry_sdk.integrations import DidNotEnable
@@ -21,14 +22,19 @@ except ImportError:
 
 
 class ServerInterceptor(grpc.aio.ServerInterceptor):  # type: ignore
-    def __init__(self, find_name=None):
-        # type: (ServerInterceptor, Callable[[ServicerContext], str] | None) -> None
+    def __init__(
+        self: ServerInterceptor,
+        find_name: Callable[[ServicerContext], str] | None = None,
+    ) -> None:
         self._find_method_name = find_name or self._find_name
 
         super().__init__()
 
-    async def intercept_service(self, continuation, handler_call_details):
-        # type: (ServerInterceptor, Callable[[HandlerCallDetails], Awaitable[RpcMethodHandler]], HandlerCallDetails) -> Optional[Awaitable[RpcMethodHandler]]
+    async def intercept_service(
+        self: ServerInterceptor,
+        continuation: Callable[[HandlerCallDetails], Awaitable[RpcMethodHandler]],
+        handler_call_details: HandlerCallDetails,
+    ) -> Optional[Awaitable[RpcMethodHandler]]:
         self._handler_call_details = handler_call_details
         handler = await continuation(handler_call_details)
         if handler is None:
@@ -37,8 +43,7 @@ class ServerInterceptor(grpc.aio.ServerInterceptor):  # type: ignore
         if not handler.request_streaming and not handler.response_streaming:
             handler_factory = grpc.unary_unary_rpc_method_handler
 
-            async def wrapped(request, context):
-                # type: (Any, ServicerContext) -> Any
+            async def wrapped(request: Any, context: ServicerContext) -> Any:
                 name = self._find_method_name(context)
                 if not name:
                     return await handler(request, context)
@@ -66,24 +71,21 @@ class ServerInterceptor(grpc.aio.ServerInterceptor):  # type: ignore
         elif not handler.request_streaming and handler.response_streaming:
             handler_factory = grpc.unary_stream_rpc_method_handler
 
-            async def wrapped(request, context):  # type: ignore
-                # type: (Any, ServicerContext) -> Any
+            async def wrapped(request: Any, context: ServicerContext) -> Any:  # type: ignore
                 async for r in handler.unary_stream(request, context):
                     yield r
 
         elif handler.request_streaming and not handler.response_streaming:
             handler_factory = grpc.stream_unary_rpc_method_handler
 
-            async def wrapped(request, context):
-                # type: (Any, ServicerContext) -> Any
+            async def wrapped(request: Any, context: ServicerContext) -> Any:
                 response = handler.stream_unary(request, context)
                 return await response
 
         elif handler.request_streaming and handler.response_streaming:
             handler_factory = grpc.stream_stream_rpc_method_handler
 
-            async def wrapped(request, context):  # type: ignore
-                # type: (Any, ServicerContext) -> Any
+            async def wrapped(request: Any, context: ServicerContext) -> Any:  # type: ignore
                 async for r in handler.stream_stream(request, context):
                     yield r
 
@@ -93,6 +95,5 @@ class ServerInterceptor(grpc.aio.ServerInterceptor):  # type: ignore
             response_serializer=handler.response_serializer,
         )
 
-    def _find_name(self, context):
-        # type: (ServicerContext) -> str
+    def _find_name(self, context: ServicerContext) -> str:
         return self._handler_call_details.method

sentry_sdk/integrations/grpc/client.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sentry_sdk
 from sentry_sdk.consts import OP
 from sentry_sdk.integrations import DidNotEnable
@@ -23,8 +24,12 @@ class ClientInterceptor(
 ):
     _is_intercepted = False
 
-    def intercept_unary_unary(self, continuation, client_call_details, request):
-        # type: (ClientInterceptor, Callable[[ClientCallDetails, Message], _UnaryOutcome], ClientCallDetails, Message) -> _UnaryOutcome
+    def intercept_unary_unary(
+        self: ClientInterceptor,
+        continuation: Callable[[ClientCallDetails, Message], _UnaryOutcome],
+        client_call_details: ClientCallDetails,
+        request: Message,
+    ) -> _UnaryOutcome:
         method = client_call_details.method
 
         with sentry_sdk.start_span(
@@ -45,8 +50,14 @@ class ClientInterceptor(
 
             return response
 
-    def intercept_unary_stream(self, continuation, client_call_details, request):
-        # type: (ClientInterceptor, Callable[[ClientCallDetails, Message], Union[Iterable[Any], UnaryStreamCall]], ClientCallDetails, Message) -> Union[Iterator[Message], Call]
+    def intercept_unary_stream(
+        self: ClientInterceptor,
+        continuation: Callable[
+            [ClientCallDetails, Message], Union[Iterable[Any], UnaryStreamCall]
+        ],
+        client_call_details: ClientCallDetails,
+        request: Message,
+    ) -> Union[Iterator[Message], Call]:
         method = client_call_details.method
 
         with sentry_sdk.start_span(
@@ -62,17 +73,16 @@ class ClientInterceptor(
                 client_call_details
             )
 
-            response = continuation(
-                client_call_details, request
-            )  # type: UnaryStreamCall
+            response: UnaryStreamCall = continuation(client_call_details, request)
             # Setting code on unary-stream leads to execution getting stuck
             # span.set_attribute("code", response.code().name)
 
             return response
 
     @staticmethod
-    def _update_client_call_details_metadata_from_scope(client_call_details):
-        # type: (ClientCallDetails) -> ClientCallDetails
+    def _update_client_call_details_metadata_from_scope(
+        client_call_details: ClientCallDetails,
+    ) -> ClientCallDetails:
         metadata = (
             list(client_call_details.metadata) if client_call_details.metadata else []
         )

sentry_sdk/integrations/grpc/consts.py

@@ -1 +1,3 @@
+from __future__ import annotations
+
 SPAN_ORIGIN = "auto.grpc.grpc"

sentry_sdk/integrations/grpc/server.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sentry_sdk
 from sentry_sdk.consts import OP
 from sentry_sdk.integrations import DidNotEnable
@@ -18,20 +19,24 @@ except ImportError:
 
 
 class ServerInterceptor(grpc.ServerInterceptor):  # type: ignore
-    def __init__(self, find_name=None):
-        # type: (ServerInterceptor, Optional[Callable[[ServicerContext], str]]) -> None
+    def __init__(
+        self: ServerInterceptor,
+        find_name: Optional[Callable[[ServicerContext], str]] = None,
+    ) -> None:
         self._find_method_name = find_name or ServerInterceptor._find_name
 
         super().__init__()
 
-    def intercept_service(self, continuation, handler_call_details):
-        # type: (ServerInterceptor, Callable[[HandlerCallDetails], RpcMethodHandler], HandlerCallDetails) -> RpcMethodHandler
+    def intercept_service(
+        self: ServerInterceptor,
+        continuation: Callable[[HandlerCallDetails], RpcMethodHandler],
+        handler_call_details: HandlerCallDetails,
+    ) -> RpcMethodHandler:
         handler = continuation(handler_call_details)
         if not handler or not handler.unary_unary:
             return handler
 
-        def behavior(request, context):
-            # type: (Message, ServicerContext) -> Message
+        def behavior(request: Message, context: ServicerContext) -> Message:
             with sentry_sdk.isolation_scope():
                 name = self._find_method_name(context)
 
@@ -59,6 +64,5 @@ class ServerInterceptor(grpc.ServerInterceptor):  # type: ignore
         )
 
     @staticmethod
-    def _find_name(context):
-        # type: (ServicerContext) -> str
+    def _find_name(context: ServicerContext) -> str:
         return context._rpc_event.call_details.method.decode()