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

sentry_sdk/scrubber.py

@@ -1,14 +1,15 @@
+from __future__ import annotations
 from sentry_sdk.utils import (
     capture_internal_exceptions,
     AnnotatedValue,
     iter_event_frames,
 )
 
-from typing import TYPE_CHECKING, cast, List, Dict
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from typing import List, Optional
     from sentry_sdk._types import Event
-    from typing import Optional
 
 
 DEFAULT_DENYLIST = [
@@ -60,9 +61,12 @@ DEFAULT_PII_DENYLIST = [
 
 class EventScrubber:
     def __init__(
-        self, denylist=None, recursive=False, send_default_pii=False, pii_denylist=None
-    ):
-        # type: (Optional[List[str]], bool, bool, Optional[List[str]]) -> None
+        self,
+        denylist: Optional[List[str]] = None,
+        recursive: bool = False,
+        send_default_pii: bool = False,
+        pii_denylist: Optional[List[str]] = None,
+    ) -> None:
         """
         A scrubber that goes through the event payload and removes sensitive data configured through denylists.
 
@@ -82,8 +86,7 @@ class EventScrubber:
         self.denylist = [x.lower() for x in self.denylist]
         self.recursive = recursive
 
-    def scrub_list(self, lst):
-        # type: (object) -> None
+    def scrub_list(self, lst: object) -> None:
         """
         If a list is passed to this method, the method recursively searches the list and any
         nested lists for any dictionaries. The method calls scrub_dict on all dictionaries
@@ -97,8 +100,7 @@ class EventScrubber:
             self.scrub_dict(v)  # no-op unless v is a dict
             self.scrub_list(v)  # no-op unless v is a list
 
-    def scrub_dict(self, d):
-        # type: (object) -> None
+    def scrub_dict(self, d: object) -> None:
         """
         If a dictionary is passed to this method, the method scrubs the dictionary of any
         sensitive data. The method calls itself recursively on any nested dictionaries (
@@ -117,8 +119,7 @@ class EventScrubber:
                 self.scrub_dict(v)  # no-op unless v is a dict
                 self.scrub_list(v)  # no-op unless v is a list
 
-    def scrub_request(self, event):
-        # type: (Event) -> None
+    def scrub_request(self, event: Event) -> None:
         with capture_internal_exceptions():
             if "request" in event:
                 if "headers" in event["request"]:
@@ -128,20 +129,17 @@ class EventScrubber:
                 if "data" in event["request"]:
                     self.scrub_dict(event["request"]["data"])
 
-    def scrub_extra(self, event):
-        # type: (Event) -> None
+    def scrub_extra(self, event: Event) -> None:
         with capture_internal_exceptions():
             if "extra" in event:
                 self.scrub_dict(event["extra"])
 
-    def scrub_user(self, event):
-        # type: (Event) -> None
+    def scrub_user(self, event: Event) -> None:
         with capture_internal_exceptions():
             if "user" in event:
                 self.scrub_dict(event["user"])
 
-    def scrub_breadcrumbs(self, event):
-        # type: (Event) -> None
+    def scrub_breadcrumbs(self, event: Event) -> None:
         with capture_internal_exceptions():
             if "breadcrumbs" in event:
                 if (
@@ -152,23 +150,21 @@ class EventScrubber:
                         if "data" in value:
                             self.scrub_dict(value["data"])
 
-    def scrub_frames(self, event):
-        # type: (Event) -> None
+    def scrub_frames(self, event: Event) -> None:
         with capture_internal_exceptions():
             for frame in iter_event_frames(event):
                 if "vars" in frame:
                     self.scrub_dict(frame["vars"])
 
-    def scrub_spans(self, event):
-        # type: (Event) -> None
+    def scrub_spans(self, event: Event) -> None:
         with capture_internal_exceptions():
             if "spans" in event:
-                for span in cast(List[Dict[str, object]], event["spans"]):
-                    if "data" in span:
-                        self.scrub_dict(span["data"])
+                if not isinstance(event["spans"], AnnotatedValue):
+                    for span in event["spans"]:
+                        if "data" in span:
+                            self.scrub_dict(span["data"])
 
-    def scrub_event(self, event):
-        # type: (Event) -> None
+    def scrub_event(self, event: Event) -> None:
         self.scrub_request(event)
         self.scrub_extra(event)
         self.scrub_user(event)

sentry_sdk/serializer.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 import math
 from collections.abc import Mapping, Sequence, Set
@@ -26,7 +27,7 @@ if TYPE_CHECKING:
     from typing import Type
     from typing import Union
 
-    from sentry_sdk._types import NotImplementedType
+    from sentry_sdk._types import NotImplementedType, Event
 
     Span = Dict[str, Any]
 
@@ -55,29 +56,25 @@ MAX_DATABAG_BREADTH = 10
 CYCLE_MARKER = "<cyclic>"
 
 
-global_repr_processors = []  # type: List[ReprProcessor]
+global_repr_processors: List[ReprProcessor] = []
 
 
-def add_global_repr_processor(processor):
-    # type: (ReprProcessor) -> None
+def add_global_repr_processor(processor: ReprProcessor) -> None:
     global_repr_processors.append(processor)
 
 
 class Memo:
     __slots__ = ("_ids", "_objs")
 
-    def __init__(self):
-        # type: () -> None
-        self._ids = {}  # type: Dict[int, Any]
-        self._objs = []  # type: List[Any]
+    def __init__(self) -> None:
+        self._ids: Dict[int, Any] = {}
+        self._objs: List[Any] = []
 
-    def memoize(self, obj):
-        # type: (Any) -> ContextManager[bool]
+    def memoize(self, obj: Any) -> ContextManager[bool]:
         self._objs.append(obj)
         return self
 
-    def __enter__(self):
-        # type: () -> bool
+    def __enter__(self) -> bool:
         obj = self._objs[-1]
         if id(obj) in self._ids:
             return True
@@ -87,16 +84,14 @@ class Memo:
 
     def __exit__(
         self,
-        ty,  # type: Optional[Type[BaseException]]
-        value,  # type: Optional[BaseException]
-        tb,  # type: Optional[TracebackType]
-    ):
-        # type: (...) -> None
+        ty: Optional[Type[BaseException]],
+        value: Optional[BaseException],
+        tb: Optional[TracebackType],
+    ) -> None:
         self._ids.pop(id(self._objs.pop()), None)
 
 
-def serialize(event, **kwargs):
-    # type: (Dict[str, Any], **Any) -> Dict[str, Any]
+def serialize(event: Union[Dict[str, Any], Event], **kwargs: Any) -> Dict[str, Any]:
     """
     A very smart serializer that takes a dict and emits a json-friendly dict.
     Currently used for serializing the final Event and also prematurely while fetching the stack
@@ -117,18 +112,15 @@ def serialize(event, **kwargs):
 
     """
     memo = Memo()
-    path = []  # type: List[Segment]
-    meta_stack = []  # type: List[Dict[str, Any]]
+    path: List[Segment] = []
+    meta_stack: List[Dict[str, Any]] = []
 
-    keep_request_bodies = (
-        kwargs.pop("max_request_body_size", None) == "always"
-    )  # type: bool
-    max_value_length = kwargs.pop("max_value_length", None)  # type: Optional[int]
+    keep_request_bodies: bool = kwargs.pop("max_request_body_size", None) == "always"
+    max_value_length: Optional[int] = kwargs.pop("max_value_length", None)
     is_vars = kwargs.pop("is_vars", False)
-    custom_repr = kwargs.pop("custom_repr", None)  # type: Callable[..., Optional[str]]
+    custom_repr: Callable[..., Optional[str]] = kwargs.pop("custom_repr", None)
 
-    def _safe_repr_wrapper(value):
-        # type: (Any) -> str
+    def _safe_repr_wrapper(value: Any) -> str:
         try:
             repr_value = None
             if custom_repr is not None:
@@ -137,8 +129,7 @@ def serialize(event, **kwargs):
         except Exception:
             return safe_repr(value)
 
-    def _annotate(**meta):
-        # type: (**Any) -> None
+    def _annotate(**meta: Any) -> None:
         while len(meta_stack) <= len(path):
             try:
                 segment = path[len(meta_stack) - 1]
@@ -150,8 +141,7 @@ def serialize(event, **kwargs):
 
         meta_stack[-1].setdefault("", {}).update(meta)
 
-    def _is_databag():
-        # type: () -> Optional[bool]
+    def _is_databag() -> Optional[bool]:
         """
         A databag is any value that we need to trim.
         True for stuff like vars, request bodies, breadcrumbs and extra.
@@ -179,8 +169,7 @@ def serialize(event, **kwargs):
 
         return False
 
-    def _is_request_body():
-        # type: () -> Optional[bool]
+    def _is_request_body() -> Optional[bool]:
         try:
             if path[0] == "request" and path[1] == "data":
                 return True
@@ -190,15 +179,14 @@ def serialize(event, **kwargs):
         return False
 
     def _serialize_node(
-        obj,  # type: Any
-        is_databag=None,  # type: Optional[bool]
-        is_request_body=None,  # type: Optional[bool]
-        should_repr_strings=None,  # type: Optional[bool]
-        segment=None,  # type: Optional[Segment]
-        remaining_breadth=None,  # type: Optional[Union[int, float]]
-        remaining_depth=None,  # type: Optional[Union[int, float]]
-    ):
-        # type: (...) -> Any
+        obj: Any,
+        is_databag: Optional[bool] = None,
+        is_request_body: Optional[bool] = None,
+        should_repr_strings: Optional[bool] = None,
+        segment: Optional[Segment] = None,
+        remaining_breadth: Optional[Union[int, float]] = None,
+        remaining_depth: Optional[Union[int, float]] = None,
+    ) -> Any:
         if segment is not None:
             path.append(segment)
 
@@ -227,22 +215,20 @@ def serialize(event, **kwargs):
                 path.pop()
                 del meta_stack[len(path) + 1 :]
 
-    def _flatten_annotated(obj):
-        # type: (Any) -> Any
+    def _flatten_annotated(obj: Any) -> Any:
         if isinstance(obj, AnnotatedValue):
             _annotate(**obj.metadata)
             obj = obj.value
         return obj
 
     def _serialize_node_impl(
-        obj,
-        is_databag,
-        is_request_body,
-        should_repr_strings,
-        remaining_depth,
-        remaining_breadth,
-    ):
-        # type: (Any, Optional[bool], Optional[bool], Optional[bool], Optional[Union[float, int]], Optional[Union[float, int]]) -> Any
+        obj: Any,
+        is_databag: Optional[bool],
+        is_request_body: Optional[bool],
+        should_repr_strings: Optional[bool],
+        remaining_depth: Optional[Union[float, int]],
+        remaining_breadth: Optional[Union[float, int]],
+    ) -> Any:
         if isinstance(obj, AnnotatedValue):
             should_repr_strings = False
         if should_repr_strings is None:
@@ -306,7 +292,7 @@ def serialize(event, **kwargs):
             # might mutate our dictionary while we're still iterating over it.
             obj = dict(obj.items())
 
-            rv_dict = {}  # type: Dict[str, Any]
+            rv_dict: Dict[str, Any] = {}
             i = 0
 
             for k, v in obj.items():

sentry_sdk/session.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import uuid
 from datetime import datetime, timezone
 
@@ -6,23 +7,15 @@ 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
+    from typing import Optional, Union, Any, Dict
 
 
-def _minute_trunc(ts):
-    # type: (datetime) -> datetime
+def _minute_trunc(ts: datetime) -> datetime:
     return ts.replace(second=0, microsecond=0)
 
 
-def _make_uuid(
-    val,  # type: Union[str, uuid.UUID]
-):
-    # type: (...) -> uuid.UUID
+def _make_uuid(val: Union[str, uuid.UUID]) -> uuid.UUID:
     if isinstance(val, uuid.UUID):
         return val
     return uuid.UUID(val)
@@ -31,21 +24,20 @@ def _make_uuid(
 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
+        sid: Optional[Union[str, uuid.UUID]] = None,
+        did: Optional[str] = None,
+        timestamp: Optional[datetime] = None,
+        started: Optional[datetime] = None,
+        duration: Optional[float] = None,
+        status: Optional[SessionStatus] = None,
+        release: Optional[str] = None,
+        environment: Optional[str] = None,
+        user_agent: Optional[str] = None,
+        ip_address: Optional[str] = None,
+        errors: Optional[int] = None,
+        user: Optional[Any] = None,
+        session_mode: str = "application",
+    ) -> None:
         if sid is None:
             sid = uuid.uuid4()
         if started is None:
@@ -53,14 +45,14 @@ class Session:
         if status is None:
             status = "ok"
         self.status = status
-        self.did = None  # type: Optional[str]
+        self.did: Optional[str] = None
         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.release: Optional[str] = None
+        self.environment: Optional[str] = None
+        self.duration: Optional[float] = None
+        self.user_agent: Optional[str] = None
+        self.ip_address: Optional[str] = None
+        self.session_mode: str = session_mode
         self.errors = 0
 
         self.update(
@@ -77,26 +69,24 @@ class Session:
         )
 
     @property
-    def truncated_started(self):
-        # type: (...) -> datetime
+    def truncated_started(self) -> 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
+        sid: Optional[Union[str, uuid.UUID]] = None,
+        did: Optional[str] = None,
+        timestamp: Optional[datetime] = None,
+        started: Optional[datetime] = None,
+        duration: Optional[float] = None,
+        status: Optional[SessionStatus] = None,
+        release: Optional[str] = None,
+        environment: Optional[str] = None,
+        user_agent: Optional[str] = None,
+        ip_address: Optional[str] = None,
+        errors: Optional[int] = None,
+        user: Optional[Any] = None,
+    ) -> None:
         # If a user is supplied we pull some data form it
         if user:
             if ip_address is None:
@@ -129,19 +119,13 @@ class Session:
         if status is not None:
             self.status = status
 
-    def close(
-        self, status=None  # type: Optional[SessionStatus]
-    ):
-        # type: (...) -> Any
+    def close(self, status: Optional[SessionStatus] = None) -> 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
+    def get_json_attrs(self, with_user_info: bool = True) -> Any:
         attrs = {}
         if self.release is not None:
             attrs["release"] = self.release
@@ -154,15 +138,14 @@ class Session:
                 attrs["user_agent"] = self.user_agent
         return attrs
 
-    def to_json(self):
-        # type: (...) -> Any
-        rv = {
+    def to_json(self) -> Any:
+        rv: Dict[str, Any] = {
             "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:

sentry_sdk/sessions.py

@@ -1,6 +1,6 @@
+from __future__ import annotations
 import os
-import time
-from threading import Thread, Lock
+from threading import Thread, Lock, Event
 from contextlib import contextmanager
 
 import sentry_sdk
@@ -11,16 +11,17 @@ 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 (
+        Any,
+        Callable,
+        Dict,
+        List,
+        Optional,
+        Generator,
+    )
 
 
-def _is_auto_session_tracking_enabled(scope):
-    # type: (sentry_sdk.Scope) -> bool
+def _is_auto_session_tracking_enabled(scope: sentry_sdk.Scope) -> bool:
     """
     Utility function to find out if session tracking is enabled.
     """
@@ -34,8 +35,9 @@ def _is_auto_session_tracking_enabled(scope):
 
 
 @contextmanager
-def track_session(scope, session_mode="application"):
-    # type: (sentry_sdk.Scope, str) -> Generator[None, None, None]
+def track_session(
+    scope: sentry_sdk.Scope, session_mode: str = "application"
+) -> 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.
@@ -55,30 +57,27 @@ TERMINAL_SESSION_STATES = ("exited", "abnormal", "crashed")
 MAX_ENVELOPE_ITEMS = 100
 
 
-def make_aggregate_envelope(aggregate_states, attrs):
-    # type: (Any, Any) -> Any
+def make_aggregate_envelope(aggregate_states: Any, attrs: 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
+        capture_func: Callable[[Envelope], None],
+        flush_interval: int = 60,
+    ) -> 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.pending_sessions: List[Any] = []
+        self.pending_aggregates: Dict[Any, Any] = {}
+        self._thread: Optional[Thread] = None
         self._thread_lock = Lock()
         self._aggregate_lock = Lock()
-        self._thread_for_pid = None  # type: Optional[int]
-        self._running = True
+        self._thread_for_pid: Optional[int] = None
+        self.__shutdown_requested: Event = Event()
 
-    def flush(self):
-        # type: (...) -> None
+    def flush(self) -> None:
         pending_sessions = self.pending_sessions
         self.pending_sessions = []
 
@@ -104,8 +103,7 @@ class SessionFlusher:
         if len(envelope.items) > 0:
             self.capture_func(envelope)
 
-    def _ensure_running(self):
-        # type: (...) -> None
+    def _ensure_running(self) -> None:
         """
         Check that we have an active thread to run in, or create one if not.
 
@@ -119,12 +117,11 @@ class SessionFlusher:
             if self._thread_for_pid == os.getpid() and self._thread is not None:
                 return None
 
-            def _thread():
-                # type: (...) -> None
-                while self._running:
-                    time.sleep(self.flush_interval)
-                    if self._running:
-                        self.flush()
+            def _thread() -> None:
+                running = True
+                while running:
+                    running = not self.__shutdown_requested.wait(self.flush_interval)
+                    self.flush()
 
             thread = Thread(target=_thread)
             thread.daemon = True
@@ -133,7 +130,7 @@ class SessionFlusher:
             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._running = False
+                self.__shutdown_requested.set()
                 return None
 
             self._thread = thread
@@ -141,10 +138,7 @@ class SessionFlusher:
 
         return None
 
-    def add_aggregate_session(
-        self, session  # type: Session
-    ):
-        # type: (...) -> None
+    def add_aggregate_session(self, session: Session) -> 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
@@ -172,20 +166,12 @@ class SessionFlusher:
             else:
                 state["exited"] = state.get("exited", 0) + 1
 
-    def add_session(
-        self, session  # type: Session
-    ):
-        # type: (...) -> None
+    def add_session(self, session: Session) -> 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._running = False
-
-    def __del__(self):
-        # type: (...) -> None
-        self.kill()
+    def kill(self) -> None:
+        self.__shutdown_requested.set()