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

sentry_sdk/transport.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from abc import ABC, abstractmethod
 import io
 import os
@@ -14,6 +15,14 @@ try:
 except ImportError:
     brotli = None
 
+try:
+    import httpcore
+    import h2  # noqa: F401
+
+    HTTP2_ENABLED = True
+except ImportError:
+    HTTP2_ENABLED = False
+
 import urllib3
 import certifi
 
@@ -22,20 +31,23 @@ from sentry_sdk.utils import Dsn, logger, capture_internal_exceptions
 from sentry_sdk.worker import BackgroundWorker
 from sentry_sdk.envelope import Envelope, Item, PayloadRef
 
-from typing import TYPE_CHECKING, cast, List, Dict
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import Any
-    from typing import Callable
-    from typing import DefaultDict
-    from typing import Iterable
-    from typing import Mapping
-    from typing import Optional
-    from typing import Self
-    from typing import Tuple
-    from typing import Type
-    from typing import Union
-
+    from typing import (
+        List,
+        Dict,
+        Any,
+        Callable,
+        DefaultDict,
+        Iterable,
+        Mapping,
+        Optional,
+        Tuple,
+        Type,
+        Union,
+        Self,
+    )
     from urllib3.poolmanager import PoolManager
     from urllib3.poolmanager import ProxyManager
 
@@ -62,10 +74,9 @@ class Transport(ABC):
     A transport is used to send an event to sentry.
     """
 
-    parsed_dsn = None  # type: Optional[Dsn]
+    parsed_dsn: Optional[Dsn] = None
 
-    def __init__(self, options=None):
-        # type: (Self, Optional[Dict[str, Any]]) -> None
+    def __init__(self: Self, options: Optional[Dict[str, Any]] = None) -> None:
         self.options = options
         if options and options["dsn"] is not None and options["dsn"]:
             self.parsed_dsn = Dsn(options["dsn"])
@@ -73,8 +84,7 @@ class Transport(ABC):
             self.parsed_dsn = None
 
     @abstractmethod
-    def capture_envelope(self, envelope):
-        # type: (Self, Envelope) -> None
+    def capture_envelope(self: Self, envelope: Envelope) -> None:
         """
         Send an envelope to Sentry.
 
@@ -85,11 +95,10 @@ class Transport(ABC):
         pass
 
     def flush(
-        self,
-        timeout,
-        callback=None,
-    ):
-        # type: (Self, float, Optional[Any]) -> None
+        self: Self,
+        timeout: float,
+        callback: Optional[Any] = None,
+    ) -> None:
         """
         Wait `timeout` seconds for the current events to be sent out.
 
@@ -98,8 +107,7 @@ class Transport(ABC):
         """
         return None
 
-    def kill(self):
-        # type: (Self) -> None
+    def kill(self: Self) -> None:
         """
         Forcefully kills the transport.
 
@@ -109,14 +117,13 @@ class Transport(ABC):
         return None
 
     def record_lost_event(
-        self,
-        reason,  # type: str
-        data_category=None,  # type: Optional[EventDataCategory]
-        item=None,  # type: Optional[Item]
+        self: Self,
+        reason: str,
+        data_category: Optional[EventDataCategory] = None,
+        item: Optional[Item] = None,
         *,
-        quantity=1,  # type: int
-    ):
-        # type: (...) -> None
+        quantity: int = 1,
+    ) -> None:
         """This increments a counter for event loss by reason and
         data category by the given positive-int quantity (default 1).
 
@@ -133,20 +140,13 @@ class Transport(ABC):
         """
         return None
 
-    def is_healthy(self):
-        # type: (Self) -> bool
+    def is_healthy(self: Self) -> bool:
         return True
 
-    def __del__(self):
-        # type: (Self) -> None
-        try:
-            self.kill()
-        except Exception:
-            pass
-
 
-def _parse_rate_limits(header, now=None):
-    # type: (str, Optional[datetime]) -> Iterable[Tuple[Optional[EventDataCategory], datetime]]
+def _parse_rate_limits(
+    header: str, now: Optional[datetime] = None
+) -> Iterable[Tuple[Optional[str], datetime]]:
     if now is None:
         now = datetime.now(timezone.utc)
 
@@ -157,7 +157,6 @@ def _parse_rate_limits(header, now=None):
 
             retry_after = now + timedelta(seconds=int(retry_after_val))
             for category in categories and categories.split(";") or (None,):
-                category = cast("Optional[EventDataCategory]", category)
                 yield category, retry_after
         except (LookupError, ValueError):
             continue
@@ -168,21 +167,20 @@ class BaseHttpTransport(Transport):
 
     TIMEOUT = 30  # seconds
 
-    def __init__(self, options):
-        # type: (Self, Dict[str, Any]) -> None
+    def __init__(self: Self, options: Dict[str, Any]) -> None:
         from sentry_sdk.consts import VERSION
 
         Transport.__init__(self, options)
         assert self.parsed_dsn is not None
-        self.options = options  # type: Dict[str, Any]
+        self.options: Dict[str, Any] = options
         self._worker = BackgroundWorker(queue_size=options["transport_queue_size"])
         self._auth = self.parsed_dsn.to_auth("sentry.python/%s" % VERSION)
-        self._disabled_until = {}  # type: Dict[Optional[EventDataCategory], datetime]
+        self._disabled_until: Dict[Optional[str], datetime] = {}
         # We only use this Retry() class for the `get_retry_after` method it exposes
         self._retry = urllib3.util.Retry()
-        self._discarded_events = defaultdict(
-            int
-        )  # type: DefaultDict[Tuple[EventDataCategory, str], int]
+        self._discarded_events: DefaultDict[Tuple[EventDataCategory, str], int] = (
+            defaultdict(int)
+        )
         self._last_client_report_sent = time.time()
 
         self._pool = self._make_pool()
@@ -227,14 +225,13 @@ class BaseHttpTransport(Transport):
             self._compression_level = 4
 
     def record_lost_event(
-        self,
-        reason,  # type: str
-        data_category=None,  # type: Optional[EventDataCategory]
-        item=None,  # type: Optional[Item]
+        self: Self,
+        reason: str,
+        data_category: Optional[EventDataCategory] = None,
+        item: Optional[Item] = None,
         *,
-        quantity=1,  # type: int
-    ):
-        # type: (...) -> None
+        quantity: int = 1,
+    ) -> None:
         if not self.options["send_client_reports"]:
             return
 
@@ -247,9 +244,7 @@ class BaseHttpTransport(Transport):
                 event = item.get_transaction_event() or {}
 
                 # +1 for the transaction itself
-                span_count = (
-                    len(cast(List[Dict[str, object]], event.get("spans") or [])) + 1
-                )
+                span_count = len(event.get("spans") or []) + 1
                 self.record_lost_event(reason, "span", quantity=span_count)
 
             elif data_category == "attachment":
@@ -262,12 +257,12 @@ class BaseHttpTransport(Transport):
 
         self._discarded_events[data_category, reason] += quantity
 
-    def _get_header_value(self, response, header):
-        # type: (Self, Any, str) -> Optional[str]
+    def _get_header_value(self: Self, response: Any, header: str) -> Optional[str]:
         return response.headers.get(header)
 
-    def _update_rate_limits(self, response):
-        # type: (Self, Union[urllib3.BaseHTTPResponse, httpcore.Response]) -> None
+    def _update_rate_limits(
+        self: Self, response: Union[urllib3.BaseHTTPResponse, httpcore.Response]
+    ) -> None:
 
         # new sentries with more rate limit insights.  We honor this header
         # no matter of the status code to update our internal rate limits.
@@ -292,16 +287,13 @@ class BaseHttpTransport(Transport):
             )
 
     def _send_request(
-        self,
-        body,
-        headers,
-        endpoint_type=EndpointType.ENVELOPE,
-        envelope=None,
-    ):
-        # type: (Self, bytes, Dict[str, str], EndpointType, Optional[Envelope]) -> None
-
-        def record_loss(reason):
-            # type: (str) -> None
+        self: Self,
+        body: bytes,
+        headers: Dict[str, str],
+        endpoint_type: EndpointType = EndpointType.ENVELOPE,
+        envelope: Optional[Envelope] = None,
+    ) -> None:
+        def record_loss(reason: str) -> None:
             if envelope is None:
                 self.record_lost_event(reason, data_category="error")
             else:
@@ -348,12 +340,12 @@ class BaseHttpTransport(Transport):
         finally:
             response.close()
 
-    def on_dropped_event(self, _reason):
-        # type: (Self, str) -> None
+    def on_dropped_event(self: Self, _reason: str) -> None:
         return None
 
-    def _fetch_pending_client_report(self, force=False, interval=60):
-        # type: (Self, bool, int) -> Optional[Item]
+    def _fetch_pending_client_report(
+        self: Self, force: bool = False, interval: int = 60
+    ) -> Optional[Item]:
         if not self.options["send_client_reports"]:
             return None
 
@@ -383,37 +375,30 @@ class BaseHttpTransport(Transport):
             type="client_report",
         )
 
-    def _flush_client_reports(self, force=False):
-        # type: (Self, bool) -> None
+    def _flush_client_reports(self: Self, force: bool = False) -> None:
         client_report = self._fetch_pending_client_report(force=force, interval=60)
         if client_report is not None:
             self.capture_envelope(Envelope(items=[client_report]))
 
-    def _check_disabled(self, category):
-        # type: (str) -> bool
-        def _disabled(bucket):
-            # type: (Any) -> bool
+    def _check_disabled(self: Self, category: EventDataCategory) -> bool:
+        def _disabled(bucket: Optional[EventDataCategory]) -> bool:
             ts = self._disabled_until.get(bucket)
             return ts is not None and ts > datetime.now(timezone.utc)
 
         return _disabled(category) or _disabled(None)
 
-    def _is_rate_limited(self):
-        # type: (Self) -> bool
+    def _is_rate_limited(self: Self) -> bool:
         return any(
             ts > datetime.now(timezone.utc) for ts in self._disabled_until.values()
         )
 
-    def _is_worker_full(self):
-        # type: (Self) -> bool
+    def _is_worker_full(self: Self) -> bool:
         return self._worker.full()
 
-    def is_healthy(self):
-        # type: (Self) -> bool
+    def is_healthy(self: Self) -> bool:
         return not (self._is_worker_full() or self._is_rate_limited())
 
-    def _send_envelope(self, envelope):
-        # type: (Self, Envelope) -> None
+    def _send_envelope(self: Self, envelope: Envelope) -> None:
 
         # remove all items from the envelope which are over quota
         new_items = []
@@ -465,8 +450,9 @@ class BaseHttpTransport(Transport):
         )
         return None
 
-    def _serialize_envelope(self, envelope):
-        # type: (Self, Envelope) -> tuple[Optional[str], io.BytesIO]
+    def _serialize_envelope(
+        self: Self, envelope: Envelope
+    ) -> tuple[Optional[str], io.BytesIO]:
         content_encoding = None
         body = io.BytesIO()
         if self._compression_level == 0 or self._compression_algo is None:
@@ -487,12 +473,10 @@ class BaseHttpTransport(Transport):
 
         return content_encoding, body
 
-    def _get_pool_options(self):
-        # type: (Self) -> Dict[str, Any]
+    def _get_pool_options(self: Self) -> Dict[str, Any]:
         raise NotImplementedError()
 
-    def _in_no_proxy(self, parsed_dsn):
-        # type: (Self, Dsn) -> bool
+    def _in_no_proxy(self: Self, parsed_dsn: Dsn) -> bool:
         no_proxy = getproxies().get("no")
         if not no_proxy:
             return False
@@ -502,26 +486,28 @@ class BaseHttpTransport(Transport):
                 return True
         return False
 
-    def _make_pool(self):
-        # type: (Self) -> Union[PoolManager, ProxyManager, httpcore.SOCKSProxy, httpcore.HTTPProxy, httpcore.ConnectionPool]
+    def _make_pool(
+        self: Self,
+    ) -> Union[
+        PoolManager,
+        ProxyManager,
+        httpcore.SOCKSProxy,
+        httpcore.HTTPProxy,
+        httpcore.ConnectionPool,
+    ]:
         raise NotImplementedError()
 
     def _request(
-        self,
-        method,
-        endpoint_type,
-        body,
-        headers,
-    ):
-        # type: (Self, str, EndpointType, Any, Mapping[str, str]) -> Union[urllib3.BaseHTTPResponse, httpcore.Response]
+        self: Self,
+        method: str,
+        endpoint_type: EndpointType,
+        body: Any,
+        headers: Mapping[str, str],
+    ) -> Union[urllib3.BaseHTTPResponse, httpcore.Response]:
         raise NotImplementedError()
 
-    def capture_envelope(
-        self, envelope  # type: Envelope
-    ):
-        # type: (...) -> None
-        def send_envelope_wrapper():
-            # type: () -> None
+    def capture_envelope(self: Self, envelope: Envelope) -> None:
+        def send_envelope_wrapper() -> None:
             with capture_internal_exceptions():
                 self._send_envelope(envelope)
                 self._flush_client_reports()
@@ -532,19 +518,17 @@ class BaseHttpTransport(Transport):
                 self.record_lost_event("queue_overflow", item=item)
 
     def flush(
-        self,
-        timeout,
-        callback=None,
-    ):
-        # type: (Self, float, Optional[Callable[[int, float], None]]) -> None
+        self: Self,
+        timeout: float,
+        callback: Optional[Callable[[int, float], None]] = None,
+    ) -> None:
         logger.debug("Flushing HTTP transport")
 
         if timeout > 0:
             self._worker.submit(lambda: self._flush_client_reports(force=True))
             self._worker.flush(timeout, callback)
 
-    def kill(self):
-        # type: (Self) -> None
+    def kill(self: Self) -> None:
         logger.debug("Killing HTTP transport")
         self._worker.kill()
 
@@ -553,8 +537,7 @@ class HttpTransport(BaseHttpTransport):
     if TYPE_CHECKING:
         _pool: Union[PoolManager, ProxyManager]
 
-    def _get_pool_options(self):
-        # type: (Self) -> Dict[str, Any]
+    def _get_pool_options(self: Self) -> Dict[str, Any]:
 
         num_pools = self.options.get("_experiments", {}).get("transport_num_pools")
         options = {
@@ -563,7 +546,7 @@ class HttpTransport(BaseHttpTransport):
             "timeout": urllib3.Timeout(total=self.TIMEOUT),
         }
 
-        socket_options = None  # type: Optional[List[Tuple[int, int, int | bytes]]]
+        socket_options: Optional[List[Tuple[int, int, int | bytes]]] = None
 
         if self.options["socket_options"] is not None:
             socket_options = self.options["socket_options"]
@@ -596,8 +579,7 @@ class HttpTransport(BaseHttpTransport):
 
         return options
 
-    def _make_pool(self):
-        # type: (Self) -> Union[PoolManager, ProxyManager]
+    def _make_pool(self: Self) -> Union[PoolManager, ProxyManager]:
         if self.parsed_dsn is None:
             raise ValueError("Cannot create HTTP-based transport without valid DSN")
 
@@ -643,13 +625,12 @@ class HttpTransport(BaseHttpTransport):
             return urllib3.PoolManager(**opts)
 
     def _request(
-        self,
-        method,
-        endpoint_type,
-        body,
-        headers,
-    ):
-        # type: (Self, str, EndpointType, Any, Mapping[str, str]) -> urllib3.BaseHTTPResponse
+        self: Self,
+        method: str,
+        endpoint_type: EndpointType,
+        body: Any,
+        headers: Mapping[str, str],
+    ) -> urllib3.BaseHTTPResponse:
         return self._pool.request(
             method,
             self._auth.get_api_url(endpoint_type),
@@ -658,14 +639,10 @@ class HttpTransport(BaseHttpTransport):
         )
 
 
-try:
-    import httpcore
-    import h2  # noqa: F401
-except ImportError:
+if not HTTP2_ENABLED:
     # Sorry, no Http2Transport for you
     class Http2Transport(HttpTransport):
-        def __init__(self, options):
-            # type: (Self, Dict[str, Any]) -> None
+        def __init__(self: Self, options: Dict[str, Any]) -> None:
             super().__init__(options)
             logger.warning(
                 "You tried to use HTTP2Transport but don't have httpcore[http2] installed. Falling back to HTTPTransport."
@@ -683,8 +660,7 @@ else:
                 httpcore.SOCKSProxy, httpcore.HTTPProxy, httpcore.ConnectionPool
             ]
 
-        def _get_header_value(self, response, header):
-            # type: (Self, httpcore.Response, str) -> Optional[str]
+        def _get_header_value(self: Self, response: Any, header: str) -> Optional[str]:
             return next(
                 (
                     val.decode("ascii")
@@ -695,13 +671,12 @@ else:
             )
 
         def _request(
-            self,
-            method,
-            endpoint_type,
-            body,
-            headers,
-        ):
-            # type: (Self, str, EndpointType, Any, Mapping[str, str]) -> httpcore.Response
+            self: Self,
+            method: str,
+            endpoint_type: EndpointType,
+            body: Any,
+            headers: Mapping[str, str],
+        ) -> httpcore.Response:
             response = self._pool.request(
                 method,
                 self._auth.get_api_url(endpoint_type),
@@ -718,13 +693,12 @@ else:
             )
             return response
 
-        def _get_pool_options(self):
-            # type: (Self) -> Dict[str, Any]
-            options = {
+        def _get_pool_options(self: Self) -> Dict[str, Any]:
+            options: Dict[str, Any] = {
                 "http2": self.parsed_dsn is not None
                 and self.parsed_dsn.scheme == "https",
                 "retries": 3,
-            }  # type: Dict[str, Any]
+            }
 
             socket_options = (
                 self.options["socket_options"]
@@ -755,8 +729,9 @@ else:
 
             return options
 
-        def _make_pool(self):
-            # type: (Self) -> Union[httpcore.SOCKSProxy, httpcore.HTTPProxy, httpcore.ConnectionPool]
+        def _make_pool(
+            self: Self,
+        ) -> Union[httpcore.SOCKSProxy, httpcore.HTTPProxy, httpcore.ConnectionPool]:
             if self.parsed_dsn is None:
                 raise ValueError("Cannot create HTTP-based transport without valid DSN")
             proxy = None
@@ -799,16 +774,15 @@ else:
             return httpcore.ConnectionPool(**opts)
 
 
-def make_transport(options):
-    # type: (Dict[str, Any]) -> Optional[Transport]
+def make_transport(options: Dict[str, Any]) -> Optional[Transport]:
     ref_transport = options["transport"]
 
     use_http2_transport = options.get("_experiments", {}).get("transport_http2", False)
 
     # By default, we use the http transport class
-    transport_cls = (
+    transport_cls: Type[Transport] = (
         Http2Transport if use_http2_transport else HttpTransport
-    )  # type: Type[Transport]
+    )
 
     if isinstance(ref_transport, Transport):
         return ref_transport