Merge branch 'master' into sentry-sdk-2.0

Author: sentrivana

CHANGELOG.md

@@ -277,6 +277,19 @@ _Plus 2 more_
 - The parameter `propagate_hub` in `ThreadingIntegration()` was deprecated and renamed to `propagate_scope`.
 
 
+## 1.44.1
+
+### Various fixes & improvements
+
+- Make `monitor` async friendly (#2912) by @sentrivana
+
+  You can now decorate your async functions with the `monitor`
+  decorator and they will correctly report their duration
+  and completion status.
+
+- Fixed `Event | None` runtime `TypeError` (#2928) by @szokeasaurusrex
+
+
 ## 1.44.0
 
 ### Various fixes & improvements

CONTRIBUTING.md

@@ -8,7 +8,6 @@ This file outlines the process to contribute to the SDK itself. For contributing
 
 Please search the [issue tracker](https://github.com/getsentry/sentry-python/issues) before creating a new issue (a problem or an improvement request). Please also ask in our [Sentry Community on Discord](https://discord.com/invite/Ww9hbqr) before submitting a new issue. There are a ton of great people in our Discord community ready to help you!
 
-
 ## Submitting Changes
 
 - Fork the `sentry-python` repo and prepare your changes.
@@ -64,7 +63,7 @@ This will make sure that your commits will have the correct coding style.
 ```bash
 cd sentry-python
 
-pip install -r linter-requirements.txt
+pip install -r devenv-requirements.txt
 
 pip install pre-commit
 
@@ -75,12 +74,8 @@ That's it. You should be ready to make changes, run tests, and make commits! If
 
 ## Running Tests
 
-To run the tests, first setup your development environment according to the instructions above. Then, install the required packages for running tests with the following command:
-```bash
-pip install -r test-requirements.txt
-```
+You can run all tests with the following command:
 
-Once the requirements are installed, you can run all tests with the following command:
 ```bash
 pytest tests/
 ```

codecov.yml

@@ -9,3 +9,5 @@ coverage:
 ignore:
   - "tests"
   - "sentry_sdk/_types.py"
+github_checks:
+  annotations: false

devenv-requirements.txt

@@ -0,0 +1,5 @@
+-r linter-requirements.txt
+-r test-requirements.txt
+mockupdb # required by `pymongo` tests that are enabled by `pymongo` from linter requirements
+pytest<7.0.0 # https://github.com/pytest-dev/pytest/issues/9621; see tox.ini
+pytest-asyncio<=0.21.1 # https://github.com/pytest-dev/pytest-asyncio/issues/706

sentry_sdk/_types.py

@@ -113,7 +113,7 @@
         "session",
         "internal",
         "profile",
-        "statsd",
+        "metric_bucket",
         "monitor",
     ]
     SessionStatus = Literal["ok", "exited", "crashed", "abnormal"]
@@ -177,3 +177,37 @@
 
     BucketKey = Tuple[MetricType, str, MeasurementUnit, MetricTagsInternal]
     MetricMetaKey = Tuple[MetricType, str, MeasurementUnit]
+
+    MonitorConfigScheduleType = Literal["crontab", "interval"]
+    MonitorConfigScheduleUnit = Literal[
+        "year",
+        "month",
+        "week",
+        "day",
+        "hour",
+        "minute",
+        "second",  # not supported in Sentry and will result in a warning
+    ]
+
+    MonitorConfigSchedule = TypedDict(
+        "MonitorConfigSchedule",
+        {
+            "type": MonitorConfigScheduleType,
+            "value": Union[int, str],
+            "unit": MonitorConfigScheduleUnit,
+        },
+        total=False,
+    )
+
+    MonitorConfig = TypedDict(
+        "MonitorConfig",
+        {
+            "schedule": MonitorConfigSchedule,
+            "timezone": str,
+            "checkin_margin": int,
+            "max_runtime": int,
+            "failure_issue_threshold": int,
+            "recovery_threshold": int,
+        },
+        total=False,
+    )

sentry_sdk/consts.py

@@ -37,10 +37,12 @@ class EndpointType(Enum):
         Event,
         EventProcessor,
         Hint,
+        MeasurementUnit,
         ProfilerMode,
         TracesSampler,
         TransactionProcessor,
         MetricTags,
+        MetricValue,
     )
 
     # Experiments are feature flags to enable and disable certain unstable SDK
@@ -57,9 +59,9 @@ class EndpointType(Enum):
             "transport_zlib_compression_level": Optional[int],
             "transport_num_pools": Optional[int],
             "enable_metrics": Optional[bool],
-            "metrics_summary_sample_rate": Optional[float],
-            "should_summarize_metric": Optional[Callable[[str, MetricTags], bool]],
-            "before_emit_metric": Optional[Callable[[str, MetricTags], bool]],
+            "before_emit_metric": Optional[
+                Callable[[str, MetricValue, MeasurementUnit, MetricTags], bool]
+            ],
             "metric_code_locations": Optional[bool],
         },
         total=False,

sentry_sdk/crons/api.py

@@ -5,18 +5,18 @@
 
 
 if TYPE_CHECKING:
-    from typing import Any, Dict, Optional
-    from sentry_sdk._types import Event
+    from typing import Optional
+    from sentry_sdk._types import Event, MonitorConfig
 
 
 def _create_check_in_event(
-    monitor_slug=None,
-    check_in_id=None,
-    status=None,
-    duration_s=None,
-    monitor_config=None,
+    monitor_slug=None,  # type: Optional[str]
+    check_in_id=None,  # type: Optional[str]
+    status=None,  # type: Optional[str]
+    duration_s=None,  # type: Optional[float]
+    monitor_config=None,  # type: Optional[MonitorConfig]
 ):
-    # type: (Optional[str], Optional[str], Optional[str], Optional[float], Optional[Dict[str, Any]]) -> Event
+    # type: (...) -> Event
     options = sentry_sdk.get_client().options
     check_in_id = check_in_id or uuid.uuid4().hex  # type: str
 
@@ -37,13 +37,13 @@ def _create_check_in_event(
 
 
 def capture_checkin(
-    monitor_slug=None,
-    check_in_id=None,
-    status=None,
-    duration=None,
-    monitor_config=None,
+    monitor_slug=None,  # type: Optional[str]
+    check_in_id=None,  # type: Optional[str]
+    status=None,  # type: Optional[str]
+    duration=None,  # type: Optional[float]
+    monitor_config=None,  # type: Optional[MonitorConfig]
 ):
-    # type: (Optional[str], Optional[str], Optional[str], Optional[float], Optional[Dict[str, Any]]) -> str
+    # type: (...) -> str
     check_in_event = _create_check_in_event(
         monitor_slug=monitor_slug,
         check_in_id=check_in_id,

sentry_sdk/crons/decorator.py

@@ -7,17 +7,19 @@
 from sentry_sdk.utils import now
 
 if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
     from types import TracebackType
     from typing import (
         Any,
-        Awaitable,
-        Callable,
         Optional,
         ParamSpec,
         Type,
         TypeVar,
         Union,
+        cast,
+        overload,
     )
+    from sentry_sdk._types import MonitorConfig
 
     P = ParamSpec("P")
     R = TypeVar("R")
@@ -53,7 +55,7 @@ def test(arg):
     """
 
     def __init__(self, monitor_slug=None, monitor_config=None):
-        # type: (Optional[str], Optional[dict[str, Any]]) -> None
+        # type: (Optional[str], Optional[MonitorConfig]) -> None
         self.monitor_slug = monitor_slug
         self.monitor_config = monitor_config
 
@@ -83,22 +85,50 @@ def __exit__(self, exc_type, exc_value, traceback):
             monitor_config=self.monitor_config,
         )
 
-    def __call__(self, fn):
-        # type: (Callable[P, R]) -> Callable[P, Union[R, Awaitable[R]]]
+    if TYPE_CHECKING:
+
+        @overload
+        def __call__(self, fn):
+            # type: (Callable[P, Awaitable[Any]]) -> Callable[P, Awaitable[Any]]
+            # Unfortunately, mypy does not give us any reliable way to type check the
+            # return value of an Awaitable (i.e. async function) for this overload,
+            # since calling iscouroutinefunction narrows the type to Callable[P, Awaitable[Any]].
+            ...
+
+        @overload
+        def __call__(self, fn):
+            # type: (Callable[P, R]) -> Callable[P, R]
+            ...
+
+    def __call__(
+        self,
+        fn,  # type: Union[Callable[P, R], Callable[P, Awaitable[Any]]]
+    ):
+        # type: (...) -> Union[Callable[P, R], Callable[P, Awaitable[Any]]]
         if iscoroutinefunction(fn):
-
-            @wraps(fn)
-            async def inner(*args: "P.args", **kwargs: "P.kwargs"):
-                # type: (...) -> R
-                with self:
-                    return await fn(*args, **kwargs)
+            return self._async_wrapper(fn)
 
         else:
+            if TYPE_CHECKING:
+                fn = cast("Callable[P, R]", fn)
+            return self._sync_wrapper(fn)
+
+    def _async_wrapper(self, fn):
+        # type: (Callable[P, Awaitable[Any]]) -> Callable[P, Awaitable[Any]]
+        @wraps(fn)
+        async def inner(*args: "P.args", **kwargs: "P.kwargs"):
+            # type: (...) -> R
+            with self:
+                return await fn(*args, **kwargs)
+
+        return inner
 
-            @wraps(fn)
-            def inner(*args: "P.args", **kwargs: "P.kwargs"):
-                # type: (...) -> R
-                with self:
-                    return fn(*args, **kwargs)
+    def _sync_wrapper(self, fn):
+        # type: (Callable[P, R]) -> Callable[P, R]
+        @wraps(fn)
+        def inner(*args: "P.args", **kwargs: "P.kwargs"):
+            # type: (...) -> R
+            with self:
+                return fn(*args, **kwargs)
 
         return inner

sentry_sdk/envelope.py

@@ -266,7 +266,7 @@ def data_category(self):
         elif ty == "profile":
             return "profile"
         elif ty == "statsd":
-            return "statsd"
+            return "metric_bucket"
         elif ty == "check_in":
             return "monitor"
         else:

sentry_sdk/integrations/celery/beat.py

@@ -13,12 +13,13 @@
 )
 
 if TYPE_CHECKING:
-    from typing import Any
-    from typing import Callable
-    from typing import Dict
-    from typing import Optional
-    from typing import TypeVar
-    from typing import Union
+    from collections.abc import Callable
+    from typing import Any, Optional, TypeVar, Union
+    from sentry_sdk._types import (
+        MonitorConfig,
+        MonitorConfigScheduleType,
+        MonitorConfigScheduleUnit,
+    )
 
     F = TypeVar("F", bound=Callable[..., Any])
 
@@ -42,7 +43,7 @@
 
 
 def _get_headers(task):
-    # type: (Task) -> Dict[str, Any]
+    # type: (Task) -> dict[str, Any]
     headers = task.request.get("headers") or {}
 
     # flatten nested headers
@@ -56,11 +57,11 @@ def _get_headers(task):
 
 
 def _get_monitor_config(celery_schedule, app, monitor_name):
-    # type: (Any, Celery, str) -> Dict[str, Any]
-    monitor_config = {}  # type: Dict[str, Any]
-    schedule_type = None  # type: Optional[str]
+    # type: (Any, Celery, str) -> MonitorConfig
+    monitor_config = {}  # type: MonitorConfig
+    schedule_type = None  # type: Optional[MonitorConfigScheduleType]
     schedule_value = None  # type: Optional[Union[str, int]]
-    schedule_unit = None  # type: Optional[str]
+    schedule_unit = None  # type: Optional[MonitorConfigScheduleUnit]
 
     if isinstance(celery_schedule, crontab):
         schedule_type = "crontab"
@@ -242,7 +243,7 @@ def _setup_celery_beat_signals():
 
 
 def crons_task_success(sender, **kwargs):
-    # type: (Task, Dict[Any, Any]) -> None
+    # type: (Task, dict[Any, Any]) -> None
     logger.debug("celery_task_success %s", sender)
     headers = _get_headers(sender)
 
@@ -263,7 +264,7 @@ def crons_task_success(sender, **kwargs):
 
 
 def crons_task_failure(sender, **kwargs):
-    # type: (Task, Dict[Any, Any]) -> None
+    # type: (Task, dict[Any, Any]) -> None
     logger.debug("celery_task_failure %s", sender)
     headers = _get_headers(sender)
 
@@ -284,7 +285,7 @@ def crons_task_failure(sender, **kwargs):
 
 
 def crons_task_retry(sender, **kwargs):
-    # type: (Task, Dict[Any, Any]) -> None
+    # type: (Task, dict[Any, Any]) -> None
     logger.debug("celery_task_retry %s", sender)
     headers = _get_headers(sender)