sentry-sdk 0.18.0__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

@@ -1,46 +1,69 @@
 import os
-import uuid
-import time
-from datetime import datetime
-from threading import Thread, Lock
+import warnings
+from threading import Thread, Lock, Event
 from contextlib import contextmanager
 
-from sentry_sdk._types import MYPY
+import sentry_sdk
+from sentry_sdk.envelope import Envelope
+from sentry_sdk.session import Session
 from sentry_sdk.utils import format_timestamp
 
-if MYPY:
-    import sentry_sdk
+from typing import TYPE_CHECKING
 
-    from typing import Optional
-    from typing import Union
+if TYPE_CHECKING:
     from typing import Any
+    from typing import Callable
     from typing import Dict
     from typing import Generator
-
-    from sentry_sdk._types import SessionStatus
+    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]) -> bool
-    """Utility function to find out if session tracking is enabled."""
+    # 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:
-        exp = hub.client.options["_experiments"] if hub.client else {}
-        should_track = exp.get("auto_session_tracking")
+        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):
-    # type: (Optional[sentry_sdk.Hub]) -> Generator[None, None, None]
-    """Starts and stops a session automatically around a block."""
+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
-    should_track = is_auto_session_tracking_enabled(hub)
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", DeprecationWarning)
+        should_track = is_auto_session_tracking_enabled(hub)
     if should_track:
-        hub.start_session()
+        hub.start_session(session_mode=session_mode)
     try:
         yield
     finally:
@@ -48,41 +71,134 @@ def auto_session_tracking(hub=None):
             hub.end_session()
 
 
-def _make_uuid(
-    val,  # type: Union[str, uuid.UUID]
-):
-    # type: (...) -> uuid.UUID
-    if isinstance(val, uuid.UUID):
-        return val
-    return uuid.UUID(val)
+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(object):
+
+class SessionFlusher:
     def __init__(
         self,
-        flush_func,  # type: Any
-        flush_interval=10,  # type: int
+        capture_func,  # type: Callable[[Envelope], None]
+        flush_interval=60,  # type: int
     ):
         # type: (...) -> None
-        self.flush_func = flush_func
+        self.capture_func = capture_func
         self.flush_interval = flush_interval
-        self.pending = {}  # type: Dict[str, Any]
+        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._running = True
+        self.__shutdown_requested = Event()
 
     def flush(self):
         # type: (...) -> None
-        pending = self.pending
-        self.pending = {}
-        self.flush_func(list(pending.values()))
+        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:
@@ -91,162 +207,69 @@ class SessionFlusher(object):
 
             def _thread():
                 # type: (...) -> None
-                while self._running:
-                    time.sleep(self.flush_interval)
-                    if self.pending and self._running:
-                        self.flush()
+                running = True
+                while running:
+                    running = not self.__shutdown_requested.wait(self.flush_interval)
+                    self.flush()
 
             thread = Thread(target=_thread)
             thread.daemon = True
-            thread.start()
+            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_session(
-        self, session  # type: Session
+    def add_aggregate_session(
+        self,
+        session,  # type: Session
     ):
         # type: (...) -> None
-        self.pending[session.sid.hex] = session.to_json()
-        self._ensure_running()
-
-    def kill(self):
-        # type: (...) -> None
-        self._running = False
+        # 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.
 
-    def __del__(self):
-        # type: (...) -> None
-        self.kill()
+        # 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
 
-class Session(object):
-    def __init__(
+    def add_session(
         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,  # type: Session
     ):
         # type: (...) -> None
-        if sid is None:
-            sid = uuid.uuid4()
-        if started is None:
-            started = datetime.utcnow()
-        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.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,
-        )
-
-    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]
-    ):
+        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
-        # 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.utcnow()
-        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 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 = {}
-        if self.release is not None:
-            attrs["release"] = self.release
-        if self.environment is not None:
-            attrs["environment"] = self.environment
-        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
-        if attrs:
-            rv["attrs"] = attrs
-        return rv
+        self.__shutdown_requested.set()