sentry-sdk 3.0.0a6__tar.gz → 3.0.0a7__tar.gz

{sentry_sdk-3.0.0a6/sentry_sdk.egg-info → sentry_sdk-3.0.0a7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry-sdk
-Version: 3.0.0a6
+Version: 3.0.0a7
 Summary: Python client for Sentry (https://sentry.io)
 Home-page: https://github.com/getsentry/sentry-python
 Author: Sentry Team and Contributors

{sentry_sdk-3.0.0a6 → sentry_sdk-3.0.0a7}/sentry_sdk/_init_implementation.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+import warnings
 
 from typing import TYPE_CHECKING
 
@@ -25,6 +26,10 @@ def _init(*args: Optional[str], **kwargs: Any) -> None:
     setup_scope_context_management()
     client = sentry_sdk.Client(*args, **kwargs)
     sentry_sdk.get_global_scope().set_client(client)
+    warnings.warn(
+        "We won't be continuing development on SDK 3.0. Please use the last stable version of the SDK to get access to the newest features and fixes. See https://github.com/getsentry/sentry-python/discussions/4955",
+        stacklevel=2,
+    )
     _check_python_deprecations()
 
 

{sentry_sdk-3.0.0a6 → sentry_sdk-3.0.0a7}/sentry_sdk/consts.py

@@ -77,7 +77,6 @@ if TYPE_CHECKING:
             "transport_compression_level": Optional[int],
             "transport_compression_algo": Optional[CompressionAlgo],
             "transport_num_pools": Optional[int],
-            "transport_http2": Optional[bool],
             "transport_async": Optional[bool],
         },
         total=False,
@@ -971,6 +970,7 @@ class ClientConstructor:
         max_stack_frames: Optional[int] = DEFAULT_MAX_STACK_FRAMES,
         enable_logs: bool = False,
         before_send_log: Optional[Callable[[Log, Hint], Optional[Log]]] = None,
+        http2: Optional[bool] = None,
     ) -> None:
         """Initialize the Sentry SDK with the given parameters. All parameters described here can be used in a call to `sentry_sdk.init()`.
 
@@ -1343,6 +1343,8 @@ class ClientConstructor:
             This is relative to the tracing sample rate - e.g. `0.5` means 50% of sampled transactions will be
             profiled.
 
+        :param http2: Defaults to `True`, enables HTTP/2 support for the SDK.
+
         :param profiles_sampler:
 
         :param profiler_mode:
@@ -1389,4 +1391,4 @@ DEFAULT_OPTIONS = _get_default_options()
 del _get_default_options
 
 
-VERSION = "3.0.0a6"
+VERSION = "3.0.0a7"

{sentry_sdk-3.0.0a6 → sentry_sdk-3.0.0a7}/sentry_sdk/integrations/threading.py

@@ -38,7 +38,7 @@ class ThreadingIntegration(Integration):
 
         try:
             from django import VERSION as django_version  # noqa: N811
-            import channels  # type: ignore[import-not-found]
+            import channels  # type: ignore
 
             channels_version = channels.__version__
         except ImportError:

sentry_sdk-3.0.0a7/sentry_sdk/spotlight.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+import io
+import logging
+import urllib3
+import sys
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any, Dict, Optional
+
+from sentry_sdk.utils import (
+    logger as sentry_logger,
+)
+from sentry_sdk.envelope import Envelope
+
+
+logger = logging.getLogger("spotlight")
+
+
+DEFAULT_SPOTLIGHT_URL = "http://localhost:8969/stream"
+DJANGO_SPOTLIGHT_MIDDLEWARE_PATH = "sentry_sdk.spotlight.SpotlightMiddleware"
+
+
+class SpotlightClient:
+    def __init__(self, url: str) -> None:
+        self.url = url
+        self.http = urllib3.PoolManager()
+        self.fails = 0
+
+    def capture_envelope(self, envelope: Envelope) -> None:
+        body = io.BytesIO()
+        envelope.serialize_into(body)
+        try:
+            req = self.http.request(
+                url=self.url,
+                body=body.getvalue(),
+                method="POST",
+                headers={
+                    "Content-Type": "application/x-sentry-envelope",
+                },
+            )
+            req.close()
+            self.fails = 0
+        except Exception as e:
+            if self.fails < 2:
+                sentry_logger.warning(str(e))
+                self.fails += 1
+            elif self.fails == 2:
+                self.fails += 1
+                sentry_logger.warning(
+                    "Looks like Spotlight is not running, will keep trying to send events but will not log errors."
+                )
+            # omitting self.fails += 1 in the `else:` case intentionally
+            # to avoid overflowing the variable if Spotlight never becomes reachable
+
+
+def setup_spotlight(options: Dict[str, Any]) -> Optional[SpotlightClient]:
+    _handler = logging.StreamHandler(sys.stderr)
+    _handler.setFormatter(logging.Formatter(" [spotlight] %(levelname)s: %(message)s"))
+    logger.addHandler(_handler)
+    logger.setLevel(logging.INFO)
+
+    url = options.get("spotlight")
+
+    if url is True:
+        url = DEFAULT_SPOTLIGHT_URL
+
+    if not isinstance(url, str):
+        return None
+
+    client = SpotlightClient(url)
+    logger.info("Enabled Spotlight using sidecar at %s", url)
+
+    return client

{sentry_sdk-3.0.0a6 → sentry_sdk-3.0.0a7}/sentry_sdk/transport.py

@@ -1051,7 +1051,12 @@ else:
 def make_transport(options: Dict[str, Any]) -> Optional[Transport]:
     ref_transport = options["transport"]
 
-    use_http2_transport = options.get("_experiments", {}).get("transport_http2", False)
+    # We default to using HTTP2 transport if the user also has the required h2
+    # library installed (through the subclass check). The reason is h2 not being
+    # available on py3.7 which we still support.
+    use_http2_transport = options.get("http2") is not False and not issubclass(
+        Http2Transport, HttpTransport
+    )
     use_async_transport = options.get("_experiments", {}).get("transport_async", False)
     async_integration = any(
         integration.__class__.__name__ == "AsyncioIntegration"

{sentry_sdk-3.0.0a6 → sentry_sdk-3.0.0a7/sentry_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry-sdk
-Version: 3.0.0a6
+Version: 3.0.0a7
 Summary: Python client for Sentry (https://sentry.io)
 Home-page: https://github.com/getsentry/sentry-python
 Author: Sentry Team and Contributors

{sentry_sdk-3.0.0a6 → sentry_sdk-3.0.0a7}/setup.py

@@ -21,7 +21,7 @@ def get_file_text(file_name):
 
 setup(
     name="sentry-sdk",
-    version="3.0.0a6",
+    version="3.0.0a7",
     author="Sentry Team and Contributors",
     author_email="hello@sentry.io",
     url="https://github.com/getsentry/sentry-python",

{sentry_sdk-3.0.0a6 → sentry_sdk-3.0.0a7}/tests/test_client.py

@@ -257,8 +257,8 @@ def test_proxy(monkeypatch, testcase, http2):
 
     kwargs = {}
 
-    if http2:
-        kwargs["_experiments"] = {"transport_http2": True}
+    if not http2:
+        kwargs["http2"] = False
 
     if testcase["arg_http_proxy"] is not None:
         kwargs["http_proxy"] = testcase["arg_http_proxy"]

{sentry_sdk-3.0.0a6 → sentry_sdk-3.0.0a7}/tests/test_transport.py

@@ -83,7 +83,7 @@ def mock_transaction_envelope(span_count: int) -> Envelope:
 @pytest.mark.parametrize("use_pickle", (True, False))
 @pytest.mark.parametrize("compression_level", (0, 9, None))
 @pytest.mark.parametrize("compression_algo", ("gzip", "br", "<invalid>", None))
-@pytest.mark.parametrize("http2", [True, False] if PY38 else [False])
+@pytest.mark.parametrize("http2", [None, False])
 def test_transport_works(
     capturing_server,
     request,
@@ -106,11 +106,9 @@ def test_transport_works(
     if compression_algo is not None:
         experiments["transport_compression_algo"] = compression_algo
 
-    if http2:
-        experiments["transport_http2"] = True
-
     client = make_client(
         debug=debug,
+        http2=http2,
         _experiments=experiments,
     )
 
@@ -245,7 +243,7 @@ def test_transport_num_pools(make_client, num_pools, expected_num_pools):
     if num_pools is not None:
         _experiments["transport_num_pools"] = num_pools
 
-    client = make_client(_experiments=_experiments)
+    client = make_client(_experiments=_experiments, http2=False)
 
     options = client.transport._get_pool_options()
     assert options["num_pools"] == expected_num_pools
@@ -255,17 +253,13 @@ def test_transport_num_pools(make_client, num_pools, expected_num_pools):
     "http2", [True, False] if sys.version_info >= (3, 8) else [False]
 )
 def test_two_way_ssl_authentication(make_client, http2):
-    _experiments = {}
-    if http2:
-        _experiments["transport_http2"] = True
-
     current_dir = os.path.dirname(__file__)
     cert_file = f"{current_dir}/test.pem"
     key_file = f"{current_dir}/test.key"
     client = make_client(
         cert_file=cert_file,
         key_file=key_file,
-        _experiments=_experiments,
+        http2=http2,
     )
     options = client.transport._get_pool_options()
 
@@ -290,20 +284,20 @@ def test_socket_options(make_client):
 
 
 def test_keep_alive_true(make_client):
-    client = make_client(keep_alive=True)
+    client = make_client(keep_alive=True, http2=False)
 
     options = client.transport._get_pool_options()
     assert options["socket_options"] == KEEP_ALIVE_SOCKET_OPTIONS
 
 
 def test_keep_alive_on_by_default(make_client):
-    client = make_client()
+    client = make_client(http2=False)
     options = client.transport._get_pool_options()
     assert "socket_options" not in options
 
 
 def test_default_timeout(make_client):
-    client = make_client()
+    client = make_client(http2=False)
 
     options = client.transport._get_pool_options()
     assert "timeout" in options
@@ -312,7 +306,7 @@ def test_default_timeout(make_client):
 
 @pytest.mark.skipif(not PY38, reason="HTTP2 libraries are only available in py3.8+")
 def test_default_timeout_http2(make_client):
-    client = make_client(_experiments={"transport_http2": True})
+    client = make_client()
 
     with mock.patch(
         "sentry_sdk.transport.httpcore.ConnectionPool.request",
@@ -335,7 +329,7 @@ def test_default_timeout_http2(make_client):
 
 @pytest.mark.skipif(not PY38, reason="HTTP2 libraries are only available in py3.8+")
 def test_http2_with_https_dsn(make_client):
-    client = make_client(_experiments={"transport_http2": True})
+    client = make_client()
     client.transport.parsed_dsn.scheme = "https"
     options = client.transport._get_pool_options()
     assert options["http2"] is True
@@ -343,7 +337,7 @@ def test_http2_with_https_dsn(make_client):
 
 @pytest.mark.skipif(not PY38, reason="HTTP2 libraries are only available in py3.8+")
 def test_no_http2_with_http_dsn(make_client):
-    client = make_client(_experiments={"transport_http2": True})
+    client = make_client()
     client.transport.parsed_dsn.scheme = "http"
     options = client.transport._get_pool_options()
     assert options["http2"] is False
@@ -356,19 +350,44 @@ def test_socket_options_override_keep_alive(make_client):
         (socket.SOL_TCP, socket.TCP_KEEPCNT, 6),
     ]
 
-    client = make_client(socket_options=socket_options, keep_alive=False)
+    client = make_client(socket_options=socket_options, keep_alive=False, http2=False)
 
     options = client.transport._get_pool_options()
     assert options["socket_options"] == socket_options
 
 
+@pytest.mark.skipif(not PY38, reason="HTTP2 libraries are only available in py3.8+")
+def test_socket_options_merge_with_keep_alive_http2(make_client):
+    socket_options = [
+        (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 42),
+        (socket.SOL_TCP, socket.TCP_KEEPINTVL, 42),
+    ]
+
+    client = make_client(socket_options=socket_options)
+
+    options = client.transport._get_pool_options()
+    try:
+        assert options["socket_options"] == [
+            (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 42),
+            (socket.SOL_TCP, socket.TCP_KEEPINTVL, 42),
+            (socket.SOL_TCP, socket.TCP_KEEPIDLE, 45),
+            (socket.SOL_TCP, socket.TCP_KEEPCNT, 6),
+        ]
+    except AttributeError:
+        assert options["socket_options"] == [
+            (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 42),
+            (socket.SOL_TCP, socket.TCP_KEEPINTVL, 42),
+            (socket.SOL_TCP, socket.TCP_KEEPCNT, 6),
+        ]
+
+
 def test_socket_options_merge_with_keep_alive(make_client):
     socket_options = [
         (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 42),
         (socket.SOL_TCP, socket.TCP_KEEPINTVL, 42),
     ]
 
-    client = make_client(socket_options=socket_options, keep_alive=True)
+    client = make_client(socket_options=socket_options, keep_alive=True, http2=False)
 
     options = client.transport._get_pool_options()
     try:
@@ -386,12 +405,23 @@ def test_socket_options_merge_with_keep_alive(make_client):
         ]
 
 
-def test_socket_options_override_defaults(make_client):
+@pytest.mark.skipif(not PY38, reason="HTTP2 libraries are only available in py3.8+")
+def test_socket_options_override_defaults_http2(make_client):
     # If socket_options are set to [], this doesn't mean the user doesn't want
     # any custom socket_options, but rather that they want to disable the urllib3
     # socket option defaults, so we need to set this and not ignore it.
     client = make_client(socket_options=[])
 
+    options = client.transport._get_pool_options()
+    assert options["socket_options"] == KEEP_ALIVE_SOCKET_OPTIONS
+
+
+def test_socket_options_override_defaults(make_client):
+    # If socket_options are set to [], this doesn't mean the user doesn't want
+    # any custom socket_options, but rather that they want to disable the urllib3
+    # socket option defaults, so we need to set this and not ignore it.
+    client = make_client(http2=False, socket_options=[])
+
     options = client.transport._get_pool_options()
     assert options["socket_options"] == []
 

sentry_sdk-3.0.0a6/sentry_sdk/spotlight.py

@@ -1,236 +0,0 @@
-from __future__ import annotations
-import io
-import logging
-import os
-import urllib.parse
-import urllib.request
-import urllib.error
-import urllib3
-import sys
-
-from itertools import chain, product
-
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from typing import Any, Callable, Dict, Optional
-
-from sentry_sdk.utils import (
-    logger as sentry_logger,
-    env_to_bool,
-    capture_internal_exceptions,
-)
-from sentry_sdk.envelope import Envelope
-
-
-logger = logging.getLogger("spotlight")
-
-
-DEFAULT_SPOTLIGHT_URL = "http://localhost:8969/stream"
-DJANGO_SPOTLIGHT_MIDDLEWARE_PATH = "sentry_sdk.spotlight.SpotlightMiddleware"
-
-
-class SpotlightClient:
-    def __init__(self, url: str) -> None:
-        self.url = url
-        self.http = urllib3.PoolManager()
-        self.fails = 0
-
-    def capture_envelope(self, envelope: Envelope) -> None:
-        body = io.BytesIO()
-        envelope.serialize_into(body)
-        try:
-            req = self.http.request(
-                url=self.url,
-                body=body.getvalue(),
-                method="POST",
-                headers={
-                    "Content-Type": "application/x-sentry-envelope",
-                },
-            )
-            req.close()
-            self.fails = 0
-        except Exception as e:
-            if self.fails < 2:
-                sentry_logger.warning(str(e))
-                self.fails += 1
-            elif self.fails == 2:
-                self.fails += 1
-                sentry_logger.warning(
-                    "Looks like Spotlight is not running, will keep trying to send events but will not log errors."
-                )
-            # omitting self.fails += 1 in the `else:` case intentionally
-            # to avoid overflowing the variable if Spotlight never becomes reachable
-
-
-try:
-    from django.utils.deprecation import MiddlewareMixin
-    from django.http import HttpResponseServerError, HttpResponse, HttpRequest
-    from django.conf import settings
-
-    SPOTLIGHT_JS_ENTRY_PATH = "/assets/main.js"
-    SPOTLIGHT_JS_SNIPPET_PATTERN = (
-        "<script>window.__spotlight = {{ initOptions: {{ sidecarUrl: '{spotlight_url}', fullPage: false }} }};</script>\n"
-        '<script type="module" crossorigin src="{spotlight_js_url}"></script>\n'
-    )
-    SPOTLIGHT_ERROR_PAGE_SNIPPET = (
-        '<html><base href="{spotlight_url}">\n'
-        '<script>window.__spotlight = {{ initOptions: {{ fullPage: true, startFrom: "/errors/{event_id}" }}}};</script>\n'
-    )
-    CHARSET_PREFIX = "charset="
-    BODY_TAG_NAME = "body"
-    BODY_CLOSE_TAG_POSSIBILITIES = tuple(
-        "</{}>".format("".join(chars))
-        for chars in product(*zip(BODY_TAG_NAME.upper(), BODY_TAG_NAME.lower()))
-    )
-
-    class SpotlightMiddleware(MiddlewareMixin):  # type: ignore[misc]
-        _spotlight_script: Optional[str] = None
-        _spotlight_url: Optional[str] = None
-
-        def __init__(self, get_response: Callable[..., HttpResponse]) -> None:
-            super().__init__(get_response)
-
-            import sentry_sdk.api
-
-            self.sentry_sdk = sentry_sdk.api
-
-            spotlight_client = self.sentry_sdk.get_client().spotlight
-            if spotlight_client is None:
-                sentry_logger.warning(
-                    "Cannot find Spotlight client from SpotlightMiddleware, disabling the middleware."
-                )
-                return None
-            # Spotlight URL has a trailing `/stream` part at the end so split it off
-            self._spotlight_url = urllib.parse.urljoin(spotlight_client.url, "../")
-
-        @property
-        def spotlight_script(self) -> Optional[str]:
-            if self._spotlight_url is not None and self._spotlight_script is None:
-                try:
-                    spotlight_js_url = urllib.parse.urljoin(
-                        self._spotlight_url, SPOTLIGHT_JS_ENTRY_PATH
-                    )
-                    req = urllib.request.Request(
-                        spotlight_js_url,
-                        method="HEAD",
-                    )
-                    urllib.request.urlopen(req)
-                    self._spotlight_script = SPOTLIGHT_JS_SNIPPET_PATTERN.format(
-                        spotlight_url=self._spotlight_url,
-                        spotlight_js_url=spotlight_js_url,
-                    )
-                except urllib.error.URLError as err:
-                    sentry_logger.debug(
-                        "Cannot get Spotlight JS to inject at %s. SpotlightMiddleware will not be very useful.",
-                        spotlight_js_url,
-                        exc_info=err,
-                    )
-
-            return self._spotlight_script
-
-        def process_response(
-            self, _request: HttpRequest, response: HttpResponse
-        ) -> Optional[HttpResponse]:
-            content_type_header = tuple(
-                p.strip()
-                for p in response.headers.get("Content-Type", "").lower().split(";")
-            )
-            content_type = content_type_header[0]
-            if len(content_type_header) > 1 and content_type_header[1].startswith(
-                CHARSET_PREFIX
-            ):
-                encoding = content_type_header[1][len(CHARSET_PREFIX) :]
-            else:
-                encoding = "utf-8"
-
-            if (
-                self.spotlight_script is not None
-                and not response.streaming
-                and content_type == "text/html"
-            ):
-                content_length = len(response.content)
-                injection = self.spotlight_script.encode(encoding)
-                injection_site = next(
-                    (
-                        idx
-                        for idx in (
-                            response.content.rfind(body_variant.encode(encoding))
-                            for body_variant in BODY_CLOSE_TAG_POSSIBILITIES
-                        )
-                        if idx > -1
-                    ),
-                    content_length,
-                )
-
-                # This approach works even when we don't have a `</body>` tag
-                response.content = (
-                    response.content[:injection_site]
-                    + injection
-                    + response.content[injection_site:]
-                )
-
-                if response.has_header("Content-Length"):
-                    response.headers["Content-Length"] = content_length + len(injection)
-
-            return response
-
-        def process_exception(
-            self, _request: HttpRequest, exception: Exception
-        ) -> Optional[HttpResponseServerError]:
-            if not settings.DEBUG or not self._spotlight_url:
-                return None
-
-            try:
-                spotlight = (
-                    urllib.request.urlopen(self._spotlight_url).read().decode("utf-8")
-                )
-            except urllib.error.URLError:
-                return None
-            else:
-                event_id = self.sentry_sdk.capture_exception(exception)
-                return HttpResponseServerError(
-                    spotlight.replace(
-                        "<html>",
-                        SPOTLIGHT_ERROR_PAGE_SNIPPET.format(
-                            spotlight_url=self._spotlight_url, event_id=event_id
-                        ),
-                    )
-                )
-
-except ImportError:
-    settings = None
-
-
-def setup_spotlight(options: Dict[str, Any]) -> Optional[SpotlightClient]:
-    _handler = logging.StreamHandler(sys.stderr)
-    _handler.setFormatter(logging.Formatter(" [spotlight] %(levelname)s: %(message)s"))
-    logger.addHandler(_handler)
-    logger.setLevel(logging.INFO)
-
-    url = options.get("spotlight")
-
-    if url is True:
-        url = DEFAULT_SPOTLIGHT_URL
-
-    if not isinstance(url, str):
-        return None
-
-    with capture_internal_exceptions():
-        if (
-            settings is not None
-            and settings.DEBUG
-            and env_to_bool(os.environ.get("SENTRY_SPOTLIGHT_ON_ERROR", "1"))
-            and env_to_bool(os.environ.get("SENTRY_SPOTLIGHT_MIDDLEWARE", "1"))
-        ):
-            middleware = settings.MIDDLEWARE
-            if DJANGO_SPOTLIGHT_MIDDLEWARE_PATH not in middleware:
-                settings.MIDDLEWARE = type(middleware)(
-                    chain(middleware, (DJANGO_SPOTLIGHT_MIDDLEWARE_PATH,))
-                )
-                logger.info("Enabled Spotlight integration for Django")
-
-    client = SpotlightClient(url)
-    logger.info("Enabled Spotlight using sidecar at %s", url)
-
-    return client