sentry-sdk 0.7.5__py2.py3-none-any.whl → 2.46.0__py2.py3-none-any.whl

sentry_sdk/session.py

@@ -0,0 +1,177 @@
+import uuid
+from datetime import datetime, timezone
+
+from sentry_sdk.utils import format_timestamp
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Optional
+    from typing import Union
+    from typing import Any
+    from typing import Dict
+
+    from sentry_sdk._types import SessionStatus
+
+
+def _minute_trunc(ts):
+    # type: (datetime) -> datetime
+    return ts.replace(second=0, microsecond=0)
+
+
+def _make_uuid(
+    val,  # type: Union[str, uuid.UUID]
+):
+    # type: (...) -> uuid.UUID
+    if isinstance(val, uuid.UUID):
+        return val
+    return uuid.UUID(val)
+
+
+class Session:
+    def __init__(
+        self,
+        sid=None,  # type: Optional[Union[str, uuid.UUID]]
+        did=None,  # type: Optional[str]
+        timestamp=None,  # type: Optional[datetime]
+        started=None,  # type: Optional[datetime]
+        duration=None,  # type: Optional[float]
+        status=None,  # type: Optional[SessionStatus]
+        release=None,  # type: Optional[str]
+        environment=None,  # type: Optional[str]
+        user_agent=None,  # type: Optional[str]
+        ip_address=None,  # type: Optional[str]
+        errors=None,  # type: Optional[int]
+        user=None,  # type: Optional[Any]
+        session_mode="application",  # type: str
+    ):
+        # type: (...) -> None
+        if sid is None:
+            sid = uuid.uuid4()
+        if started is None:
+            started = datetime.now(timezone.utc)
+        if status is None:
+            status = "ok"
+        self.status = status
+        self.did = None  # type: Optional[str]
+        self.started = started
+        self.release = None  # type: Optional[str]
+        self.environment = None  # type: Optional[str]
+        self.duration = None  # type: Optional[float]
+        self.user_agent = None  # type: Optional[str]
+        self.ip_address = None  # type: Optional[str]
+        self.session_mode = session_mode  # type: str
+        self.errors = 0
+
+        self.update(
+            sid=sid,
+            did=did,
+            timestamp=timestamp,
+            duration=duration,
+            release=release,
+            environment=environment,
+            user_agent=user_agent,
+            ip_address=ip_address,
+            errors=errors,
+            user=user,
+        )
+
+    @property
+    def truncated_started(self):
+        # type: (...) -> datetime
+        return _minute_trunc(self.started)
+
+    def update(
+        self,
+        sid=None,  # type: Optional[Union[str, uuid.UUID]]
+        did=None,  # type: Optional[str]
+        timestamp=None,  # type: Optional[datetime]
+        started=None,  # type: Optional[datetime]
+        duration=None,  # type: Optional[float]
+        status=None,  # type: Optional[SessionStatus]
+        release=None,  # type: Optional[str]
+        environment=None,  # type: Optional[str]
+        user_agent=None,  # type: Optional[str]
+        ip_address=None,  # type: Optional[str]
+        errors=None,  # type: Optional[int]
+        user=None,  # type: Optional[Any]
+    ):
+        # type: (...) -> None
+        # If a user is supplied we pull some data form it
+        if user:
+            if ip_address is None:
+                ip_address = user.get("ip_address")
+            if did is None:
+                did = user.get("id") or user.get("email") or user.get("username")
+
+        if sid is not None:
+            self.sid = _make_uuid(sid)
+        if did is not None:
+            self.did = str(did)
+        if timestamp is None:
+            timestamp = datetime.now(timezone.utc)
+        self.timestamp = timestamp
+        if started is not None:
+            self.started = started
+        if duration is not None:
+            self.duration = duration
+        if release is not None:
+            self.release = release
+        if environment is not None:
+            self.environment = environment
+        if ip_address is not None:
+            self.ip_address = ip_address
+        if user_agent is not None:
+            self.user_agent = user_agent
+        if errors is not None:
+            self.errors = errors
+
+        if status is not None:
+            self.status = status
+
+    def close(
+        self,
+        status=None,  # type: Optional[SessionStatus]
+    ):
+        # type: (...) -> Any
+        if status is None and self.status == "ok":
+            status = "exited"
+        if status is not None:
+            self.update(status=status)
+
+    def get_json_attrs(
+        self,
+        with_user_info=True,  # type: Optional[bool]
+    ):
+        # type: (...) -> Any
+        attrs = {}
+        if self.release is not None:
+            attrs["release"] = self.release
+        if self.environment is not None:
+            attrs["environment"] = self.environment
+        if with_user_info:
+            if self.ip_address is not None:
+                attrs["ip_address"] = self.ip_address
+            if self.user_agent is not None:
+                attrs["user_agent"] = self.user_agent
+        return attrs
+
+    def to_json(self):
+        # type: (...) -> Any
+        rv = {
+            "sid": str(self.sid),
+            "init": True,
+            "started": format_timestamp(self.started),
+            "timestamp": format_timestamp(self.timestamp),
+            "status": self.status,
+        }  # type: Dict[str, Any]
+        if self.errors:
+            rv["errors"] = self.errors
+        if self.did is not None:
+            rv["did"] = self.did
+        if self.duration is not None:
+            rv["duration"] = self.duration
+        attrs = self.get_json_attrs()
+        if attrs:
+            rv["attrs"] = attrs
+        return rv

sentry_sdk/sessions.py

@@ -0,0 +1,275 @@
+import os
+import warnings
+from threading import Thread, Lock, Event
+from contextlib import contextmanager
+
+import sentry_sdk
+from sentry_sdk.envelope import Envelope
+from sentry_sdk.session import Session
+from sentry_sdk.utils import format_timestamp
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any
+    from typing import Callable
+    from typing import Dict
+    from typing import Generator
+    from typing import List
+    from typing import Optional
+    from typing import Union
+
+
+def is_auto_session_tracking_enabled(hub=None):
+    # type: (Optional[sentry_sdk.Hub]) -> Union[Any, bool, None]
+    """DEPRECATED: Utility function to find out if session tracking is enabled."""
+
+    # Internal callers should use private _is_auto_session_tracking_enabled, instead.
+    warnings.warn(
+        "This function is deprecated and will be removed in the next major release. "
+        "There is no public API replacement.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
+    if hub is None:
+        hub = sentry_sdk.Hub.current
+
+    should_track = hub.scope._force_auto_session_tracking
+
+    if should_track is None:
+        client_options = hub.client.options if hub.client else {}
+        should_track = client_options.get("auto_session_tracking", False)
+
+    return should_track
+
+
+@contextmanager
+def auto_session_tracking(hub=None, session_mode="application"):
+    # type: (Optional[sentry_sdk.Hub], str) -> Generator[None, None, None]
+    """DEPRECATED: Use track_session instead
+    Starts and stops a session automatically around a block.
+    """
+    warnings.warn(
+        "This function is deprecated and will be removed in the next major release. "
+        "Use track_session instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
+    if hub is None:
+        hub = sentry_sdk.Hub.current
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", DeprecationWarning)
+        should_track = is_auto_session_tracking_enabled(hub)
+    if should_track:
+        hub.start_session(session_mode=session_mode)
+    try:
+        yield
+    finally:
+        if should_track:
+            hub.end_session()
+
+
+def is_auto_session_tracking_enabled_scope(scope):
+    # type: (sentry_sdk.Scope) -> bool
+    """
+    DEPRECATED: Utility function to find out if session tracking is enabled.
+    """
+
+    warnings.warn(
+        "This function is deprecated and will be removed in the next major release. "
+        "There is no public API replacement.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
+    # Internal callers should use private _is_auto_session_tracking_enabled, instead.
+    return _is_auto_session_tracking_enabled(scope)
+
+
+def _is_auto_session_tracking_enabled(scope):
+    # type: (sentry_sdk.Scope) -> bool
+    """
+    Utility function to find out if session tracking is enabled.
+    """
+
+    should_track = scope._force_auto_session_tracking
+    if should_track is None:
+        client_options = sentry_sdk.get_client().options
+        should_track = client_options.get("auto_session_tracking", False)
+
+    return should_track
+
+
+@contextmanager
+def auto_session_tracking_scope(scope, session_mode="application"):
+    # type: (sentry_sdk.Scope, str) -> Generator[None, None, None]
+    """DEPRECATED: This function is a deprecated alias for track_session.
+    Starts and stops a session automatically around a block.
+    """
+
+    warnings.warn(
+        "This function is a deprecated alias for track_session and will be removed in the next major release.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
+    with track_session(scope, session_mode=session_mode):
+        yield
+
+
+@contextmanager
+def track_session(scope, session_mode="application"):
+    # type: (sentry_sdk.Scope, str) -> Generator[None, None, None]
+    """
+    Start a new session in the provided scope, assuming session tracking is enabled.
+    This is a no-op context manager if session tracking is not enabled.
+    """
+
+    should_track = _is_auto_session_tracking_enabled(scope)
+    if should_track:
+        scope.start_session(session_mode=session_mode)
+    try:
+        yield
+    finally:
+        if should_track:
+            scope.end_session()
+
+
+TERMINAL_SESSION_STATES = ("exited", "abnormal", "crashed")
+MAX_ENVELOPE_ITEMS = 100
+
+
+def make_aggregate_envelope(aggregate_states, attrs):
+    # type: (Any, Any) -> Any
+    return {"attrs": dict(attrs), "aggregates": list(aggregate_states.values())}
+
+
+class SessionFlusher:
+    def __init__(
+        self,
+        capture_func,  # type: Callable[[Envelope], None]
+        flush_interval=60,  # type: int
+    ):
+        # type: (...) -> None
+        self.capture_func = capture_func
+        self.flush_interval = flush_interval
+        self.pending_sessions = []  # type: List[Any]
+        self.pending_aggregates = {}  # type: Dict[Any, Any]
+        self._thread = None  # type: Optional[Thread]
+        self._thread_lock = Lock()
+        self._aggregate_lock = Lock()
+        self._thread_for_pid = None  # type: Optional[int]
+        self.__shutdown_requested = Event()
+
+    def flush(self):
+        # type: (...) -> None
+        pending_sessions = self.pending_sessions
+        self.pending_sessions = []
+
+        with self._aggregate_lock:
+            pending_aggregates = self.pending_aggregates
+            self.pending_aggregates = {}
+
+        envelope = Envelope()
+        for session in pending_sessions:
+            if len(envelope.items) == MAX_ENVELOPE_ITEMS:
+                self.capture_func(envelope)
+                envelope = Envelope()
+
+            envelope.add_session(session)
+
+        for attrs, states in pending_aggregates.items():
+            if len(envelope.items) == MAX_ENVELOPE_ITEMS:
+                self.capture_func(envelope)
+                envelope = Envelope()
+
+            envelope.add_sessions(make_aggregate_envelope(states, attrs))
+
+        if len(envelope.items) > 0:
+            self.capture_func(envelope)
+
+    def _ensure_running(self):
+        # type: (...) -> None
+        """
+        Check that we have an active thread to run in, or create one if not.
+
+        Note that this might fail (e.g. in Python 3.12 it's not possible to
+        spawn new threads at interpreter shutdown). In that case self._running
+        will be False after running this function.
+        """
+        if self._thread_for_pid == os.getpid() and self._thread is not None:
+            return None
+        with self._thread_lock:
+            if self._thread_for_pid == os.getpid() and self._thread is not None:
+                return None
+
+            def _thread():
+                # type: (...) -> None
+                running = True
+                while running:
+                    running = not self.__shutdown_requested.wait(self.flush_interval)
+                    self.flush()
+
+            thread = Thread(target=_thread)
+            thread.daemon = True
+            try:
+                thread.start()
+            except RuntimeError:
+                # Unfortunately at this point the interpreter is in a state that no
+                # longer allows us to spawn a thread and we have to bail.
+                self.__shutdown_requested.set()
+                return None
+
+            self._thread = thread
+            self._thread_for_pid = os.getpid()
+
+        return None
+
+    def add_aggregate_session(
+        self,
+        session,  # type: Session
+    ):
+        # type: (...) -> None
+        # NOTE on `session.did`:
+        # the protocol can deal with buckets that have a distinct-id, however
+        # in practice we expect the python SDK to have an extremely high cardinality
+        # here, effectively making aggregation useless, therefore we do not
+        # aggregate per-did.
+
+        # For this part we can get away with using the global interpreter lock
+        with self._aggregate_lock:
+            attrs = session.get_json_attrs(with_user_info=False)
+            primary_key = tuple(sorted(attrs.items()))
+            secondary_key = session.truncated_started  # (, session.did)
+            states = self.pending_aggregates.setdefault(primary_key, {})
+            state = states.setdefault(secondary_key, {})
+
+            if "started" not in state:
+                state["started"] = format_timestamp(session.truncated_started)
+            # if session.did is not None:
+            #     state["did"] = session.did
+            if session.status == "crashed":
+                state["crashed"] = state.get("crashed", 0) + 1
+            elif session.status == "abnormal":
+                state["abnormal"] = state.get("abnormal", 0) + 1
+            elif session.errors > 0:
+                state["errored"] = state.get("errored", 0) + 1
+            else:
+                state["exited"] = state.get("exited", 0) + 1
+
+    def add_session(
+        self,
+        session,  # type: Session
+    ):
+        # type: (...) -> None
+        if session.session_mode == "request":
+            self.add_aggregate_session(session)
+        else:
+            self.pending_sessions.append(session.to_json())
+        self._ensure_running()
+
+    def kill(self):
+        # type: (...) -> None
+        self.__shutdown_requested.set()

sentry_sdk/spotlight.py

@@ -0,0 +1,242 @@
+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
+    from typing import Callable
+    from typing import Dict
+    from typing import Optional
+    from typing import Self
+
+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):
+        # type: (str) -> None
+        self.url = url
+        self.http = urllib3.PoolManager()
+        self.fails = 0
+
+    def capture_envelope(self, envelope):
+        # type: (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 = None  # type: Optional[str]
+        _spotlight_url = None  # type: Optional[str]
+
+        def __init__(self, get_response):
+            # type: (Self, 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):
+            # type: (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, response):
+            # type: (Self, HttpRequest, 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, exception):
+            # type: (Self, HttpRequest, 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):
+    # type: (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