Merge branch 'master' into sentry-sdk-2.0

Author: sentrivana

checkouts/data-schemas

@@ -201,6 +201,18 @@ class SPANDATA:
     Example: "http.handler"
     """
 
+    THREAD_ID = "thread.id"
+    """
+    Identifier of a thread from where the span originated. This should be a string.
+    Example: "7972576320"
+    """
+
+    THREAD_NAME = "thread.name"
+    """
+    Label identifying a thread from where the span originated. This should be a string.
+    Example: "MainThread"
+    """
+
 
 class OP:
     CACHE_GET_ITEM = "cache.get_item"

sentry_sdk/consts.py

@@ -1,18 +1,28 @@
-import sys
-from contextlib import contextmanager
+from functools import wraps
+from inspect import iscoroutinefunction
 
 from sentry_sdk._types import TYPE_CHECKING
 from sentry_sdk.crons import capture_checkin
 from sentry_sdk.crons.consts import MonitorStatus
-from sentry_sdk.utils import now, reraise
+from sentry_sdk.utils import now
 
 if TYPE_CHECKING:
-    from typing import Generator, Optional
+    from types import TracebackType
+    from typing import (
+        Awaitable,
+        Callable,
+        Optional,
+        ParamSpec,
+        Type,
+        TypeVar,
+        Union,
+    )
+
+    P = ParamSpec("P")
+    R = TypeVar("R")
 
 
-@contextmanager
-def monitor(monitor_slug=None):
-    # type: (Optional[str]) -> Generator[None, None, None]
+class monitor:  # noqa: N801
     """
     Decorator/context manager to capture checkin events for a monitor.
 
@@ -39,32 +49,51 @@ def test(arg):
         with sentry_sdk.monitor(monitor_slug='my-fancy-slug'):
             print(arg)
     ```
+    """
 
+    def __init__(self, monitor_slug=None):
+        # type: (Optional[str]) -> None
+        self.monitor_slug = monitor_slug
 
-    """
+    def __enter__(self):
+        # type: () -> None
+        self.start_timestamp = now()
+        self.check_in_id = capture_checkin(
+            monitor_slug=self.monitor_slug, status=MonitorStatus.IN_PROGRESS
+        )
 
-    start_timestamp = now()
-    check_in_id = capture_checkin(
-        monitor_slug=monitor_slug, status=MonitorStatus.IN_PROGRESS
-    )
+    def __exit__(self, exc_type, exc_value, traceback):
+        # type: (Optional[Type[BaseException]], Optional[BaseException], Optional[TracebackType]) -> None
+        duration_s = now() - self.start_timestamp
+
+        if exc_type is None and exc_value is None and traceback is None:
+            status = MonitorStatus.OK
+        else:
+            status = MonitorStatus.ERROR
 
-    try:
-        yield
-    except Exception:
-        duration_s = now() - start_timestamp
         capture_checkin(
-            monitor_slug=monitor_slug,
-            check_in_id=check_in_id,
-            status=MonitorStatus.ERROR,
+            monitor_slug=self.monitor_slug,
+            check_in_id=self.check_in_id,
+            status=status,
             duration=duration_s,
         )
-        exc_info = sys.exc_info()
-        reraise(*exc_info)
-
-    duration_s = now() - start_timestamp
-    capture_checkin(
-        monitor_slug=monitor_slug,
-        check_in_id=check_in_id,
-        status=MonitorStatus.OK,
-        duration=duration_s,
-    )
+
+    def __call__(self, fn):
+        # type: (Callable[P, R]) -> Callable[P, Union[R, Awaitable[R]]]
+        if iscoroutinefunction(fn):
+
+            @wraps(fn)
+            async def inner(*args: "P.args", **kwargs: "P.kwargs"):
+                # type: (...) -> R
+                with self:
+                    return await fn(*args, **kwargs)
+
+        else:
+
+            @wraps(fn)
+            def inner(*args: "P.args", **kwargs: "P.kwargs"):
+                # type: (...) -> R
+                with self:
+                    return fn(*args, **kwargs)
+
+        return inner

sentry_sdk/crons/decorator.py

@@ -43,6 +43,8 @@
 from sentry_sdk.utils import (
     capture_internal_exception,
     filename_for_module,
+    get_current_thread_meta,
+    is_gevent,
     is_valid_sample_rate,
     logger,
     nanosecond_time,
@@ -127,32 +129,16 @@
 
 
 try:
-    from gevent import get_hub as get_gevent_hub  # type: ignore
-    from gevent.monkey import get_original, is_module_patched  # type: ignore
+    from gevent.monkey import get_original  # type: ignore
     from gevent.threadpool import ThreadPool  # type: ignore
 
     thread_sleep = get_original("time", "sleep")
 except ImportError:
-
-    def get_gevent_hub():
-        # type: () -> Any
-        return None
-
     thread_sleep = time.sleep
 
-    def is_module_patched(*args, **kwargs):
-        # type: (*Any, **Any) -> bool
-        # unable to import from gevent means no modules have been patched
-        return False
-
     ThreadPool = None
 
 
-def is_gevent():
-    # type: () -> bool
-    return is_module_patched("threading") or is_module_patched("_thread")
-
-
 _scheduler = None  # type: Optional[Scheduler]
 
 # The default sampling frequency to use. This is set at 101 in order to
@@ -395,52 +381,6 @@ def get_frame_name(frame):
 MAX_PROFILE_DURATION_NS = int(3e10)  # 30 seconds
 
 
-def get_current_thread_id(thread=None):
-    # type: (Optional[threading.Thread]) -> Optional[int]
-    """
-    Try to get the id of the current thread, with various fall backs.
-    """
-
-    # if a thread is specified, that takes priority
-    if thread is not None:
-        try:
-            thread_id = thread.ident
-            if thread_id is not None:
-                return thread_id
-        except AttributeError:
-            pass
-
-    # if the app is using gevent, we should look at the gevent hub first
-    # as the id there differs from what the threading module reports
-    if is_gevent():
-        gevent_hub = get_gevent_hub()
-        if gevent_hub is not None:
-            try:
-                # this is undocumented, so wrap it in try except to be safe
-                return gevent_hub.thread_ident
-            except AttributeError:
-                pass
-
-    # use the current thread's id if possible
-    try:
-        current_thread_id = threading.current_thread().ident
-        if current_thread_id is not None:
-            return current_thread_id
-    except AttributeError:
-        pass
-
-    # if we can't get the current thread id, fall back to the main thread id
-    try:
-        main_thread_id = threading.main_thread().ident
-        if main_thread_id is not None:
-            return main_thread_id
-    except AttributeError:
-        pass
-
-    # we've tried everything, time to give up
-    return None
-
-
 class Profile:
     def __init__(
         self,
@@ -462,7 +402,7 @@ def __init__(
 
         # Various framework integrations are capable of overwriting the active thread id.
         # If it is set to `None` at the end of the profile, we fall back to the default.
-        self._default_active_thread_id = get_current_thread_id() or 0  # type: int
+        self._default_active_thread_id = get_current_thread_meta()[0] or 0  # type: int
         self.active_thread_id = None  # type: Optional[int]
 
         try:
@@ -485,7 +425,7 @@ def __init__(
 
     def update_active_thread_id(self):
         # type: () -> None
-        self.active_thread_id = get_current_thread_id()
+        self.active_thread_id = get_current_thread_meta()[0]
         logger.debug(
             "[Profiling] updating active thread id to {tid}".format(
                 tid=self.active_thread_id

sentry_sdk/profiler.py

@@ -3,9 +3,13 @@
 from datetime import datetime, timedelta, timezone
 
 import sentry_sdk
-from sentry_sdk.consts import INSTRUMENTER
-from sentry_sdk.utils import is_valid_sample_rate, logger, nanosecond_time
-from sentry_sdk.consts import SPANDATA
+from sentry_sdk.consts import INSTRUMENTER, SPANDATA
+from sentry_sdk.utils import (
+    get_current_thread_meta,
+    is_valid_sample_rate,
+    logger,
+    nanosecond_time,
+)
 from sentry_sdk._types import TYPE_CHECKING
 
 
@@ -200,6 +204,9 @@ def __init__(
         self._span_recorder = None  # type: Optional[_SpanRecorder]
         self._local_aggregator = None  # type: Optional[LocalAggregator]
 
+        thread_id, thread_name = get_current_thread_meta()
+        self.set_thread(thread_id, thread_name)
+
     # TODO this should really live on the Transaction class rather than the Span
     # class
     def init_span_recorder(self, maxlen):
@@ -435,6 +442,15 @@ def set_status(self, value):
         # type: (str) -> None
         self.status = value
 
+    def set_thread(self, thread_id, thread_name):
+        # type: (Optional[int], Optional[str]) -> None
+
+        if thread_id is not None:
+            self.set_data(SPANDATA.THREAD_ID, str(thread_id))
+
+            if thread_name is not None:
+                self.set_data(SPANDATA.THREAD_NAME, thread_name)
+
     def set_http_status(self, http_status):
         # type: (int) -> None
         self.set_tag(

sentry_sdk/tracing.py

@@ -11,6 +11,11 @@
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from sentry_sdk._types import Event, Hint  # noqa: F401
+    from sentry_sdk._types import Event, Hint
+else:
+    # The lines below allow the types to be imported from outside `if TYPE_CHECKING`
+    # guards. The types in this module are only intended to be used for type hints.
+    Event = None
+    Hint = None
 
-    __all__ = ["Event", "Hint"]
+__all__ = ("Event", "Hint")

sentry_sdk/types.py

@@ -1783,9 +1783,14 @@ def now():
 
 
 try:
+    from gevent import get_hub as get_gevent_hub
     from gevent.monkey import is_module_patched
 except ImportError:
 
+    def get_gevent_hub():
+        # type: () -> Any
+        return None
+
     def is_module_patched(*args, **kwargs):
         # type: (*Any, **Any) -> bool
         # unable to import from gevent means no modules have been patched
@@ -1795,3 +1800,54 @@ def is_module_patched(*args, **kwargs):
 def is_gevent():
     # type: () -> bool
     return is_module_patched("threading") or is_module_patched("_thread")
+
+
+def get_current_thread_meta(thread=None):
+    # type: (Optional[threading.Thread]) -> Tuple[Optional[int], Optional[str]]
+    """
+    Try to get the id of the current thread, with various fall backs.
+    """
+
+    # if a thread is specified, that takes priority
+    if thread is not None:
+        try:
+            thread_id = thread.ident
+            thread_name = thread.name
+            if thread_id is not None:
+                return thread_id, thread_name
+        except AttributeError:
+            pass
+
+    # if the app is using gevent, we should look at the gevent hub first
+    # as the id there differs from what the threading module reports
+    if is_gevent():
+        gevent_hub = get_gevent_hub()
+        if gevent_hub is not None:
+            try:
+                # this is undocumented, so wrap it in try except to be safe
+                return gevent_hub.thread_ident, None
+            except AttributeError:
+                pass
+
+    # use the current thread's id if possible
+    try:
+        thread = threading.current_thread()
+        thread_id = thread.ident
+        thread_name = thread.name
+        if thread_id is not None:
+            return thread_id, thread_name
+    except AttributeError:
+        pass
+
+    # if we can't get the current thread id, fall back to the main thread id
+    try:
+        thread = threading.main_thread()
+        thread_id = thread.ident
+        thread_name = thread.name
+        if thread_id is not None:
+            return thread_id, thread_name
+    except AttributeError:
+        pass
+
+    # we've tried everything, time to give up
+    return None, None

sentry_sdk/utils.py

@@ -602,3 +602,15 @@ def patch_start_tracing_child(fake_transaction_is_none=False):
         "sentry_sdk.tracing_utils.get_current_span", return_value=fake_transaction
     ):
         yield fake_start_child
+
+
+class ApproxDict(dict):
+    def __eq__(self, other):
+        # For an ApproxDict to equal another dict, the other dict just needs to contain
+        # all the keys from the ApproxDict with the same values.
+        #
+        # The other dict may contain additional keys with any value.
+        return all(key in other and other[key] == value for key, value in self.items())
+
+    def __ne__(self, other):
+        return not self.__eq__(other)