sentry-sdk 2.72.0__tar.gz → 2.74.0__tar.gz

{sentry_sdk-2.72.0/sentry_sdk.egg-info → sentry_sdk-2.74.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry-sdk
-Version: 2.72.0
+Version: 2.74.0
 Summary: Python client for Sentry (https://sentry.io)
 Home-page: https://github.com/getsentry/sentry-python
 Author: Sentry Team and Contributors
@@ -80,7 +80,7 @@ Requires-Dist: langgraph>=0.6.6; extra == "langgraph"
 Provides-Extra: launchdarkly
 Requires-Dist: launchdarkly-server-sdk>=9.8.0; extra == "launchdarkly"
 Provides-Extra: litellm
-Requires-Dist: litellm!=1.82.7,!=1.82.8,>=1.77.5; extra == "litellm"
+Requires-Dist: litellm!=1.107.0,!=1.82.7,!=1.82.8,>=1.77.5; extra == "litellm"
 Provides-Extra: litestar
 Requires-Dist: litestar>=2.0.0; extra == "litestar"
 Provides-Extra: loguru

{sentry_sdk-2.72.0 → sentry_sdk-2.74.0}/pyproject.toml

@@ -16,7 +16,7 @@ dev = [
 
 toxgen = [
     "jinja2",
-    "packaging<26.0",
+    "packaging",
     "pip",
     "requests",
 ]
@@ -24,7 +24,7 @@ toxgen = [
 docs = [
     "gevent",
     "shibuya",
-    "sphinx<8.2",
+    "sphinx",
     "sphinx-autodoc-typehints[type_comments]>=2.3.0",
     "typing-extensions",
 ]
@@ -81,7 +81,7 @@ typing = [
     "aiohttp>=3.14.3",
     "openai-agents>=0.22.0",
     "mistralai>=2.10.1",
-    "typesafe-sdk>=0.7.2",
+    "typesafe-sdk>=0.7.5",
 ]
 test = [
     "dataclasses ; python_full_version < '3.7'",

{sentry_sdk-2.72.0 → sentry_sdk-2.74.0}/sentry_sdk/consts.py

@@ -1924,4 +1924,4 @@ DEFAULT_OPTIONS = _get_default_options()
 del _get_default_options
 
 
-VERSION = "2.72.0"
+VERSION = "2.74.0"

sentry_sdk-2.74.0/sentry_sdk/crons/utils.py

@@ -0,0 +1,29 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Optional, Tuple
+
+    from sentry_sdk._types import MonitorConfigSchedule, MonitorConfigScheduleUnit
+
+
+_INTERVAL_UNITS: "Tuple[Tuple[MonitorConfigScheduleUnit, int], ...]" = (
+    ("day", 60 * 60 * 24),
+    ("hour", 60 * 60),
+    ("minute", 60),
+)
+
+
+def _get_interval_schedule(seconds: float) -> "Optional[MonitorConfigSchedule]":
+    """
+    Express an interval in the largest unit that divides it evenly.
+
+    Returns None if the interval isn't a whole number of minutes.
+    """
+    for unit, unit_seconds in _INTERVAL_UNITS:
+        if seconds >= unit_seconds and seconds % unit_seconds == 0:
+            return {
+                "type": "interval",
+                "value": int(seconds // unit_seconds),
+                "unit": unit,
+            }
+    return None

{sentry_sdk-2.72.0 → sentry_sdk-2.74.0}/sentry_sdk/integrations/aiohttp.py

@@ -34,6 +34,7 @@ from sentry_sdk.tracing import (
     TransactionSource,
 )
 from sentry_sdk.tracing_utils import (
+    Baggage,
     add_http_breadcrumb,
     add_http_request_source,
     has_span_streaming_enabled,
@@ -488,6 +489,19 @@ def create_trace_config() -> "TraceConfig":
             if SENTRY_TRACE_HEADER_NAME in params.headers:
                 headers_to_skip.add(SENTRY_TRACE_HEADER_NAME)
 
+            # `baggage` with Sentry members (e.g. merged by the boto3 integration
+            # before signing): skip so Sentry members are not duplicated.
+            with capture_internal_exceptions():
+                baggage = params.headers.get(BAGGAGE_HEADER_NAME)
+                if baggage:
+                    if isinstance(baggage, bytes):
+                        baggage = baggage.decode("latin-1")
+                    if any(
+                        Baggage.SENTRY_PREFIX_REGEX.match(item.strip())
+                        for item in baggage.split(",")
+                    ):
+                        headers_to_skip.add(BAGGAGE_HEADER_NAME)
+
             with capture_internal_exceptions():
                 authorization = params.headers.get("Authorization")
                 if authorization:

{sentry_sdk-2.72.0 → sentry_sdk-2.74.0}/sentry_sdk/integrations/anthropic.py

@@ -64,6 +64,12 @@ try:
 except ImportError:
     raise DidNotEnable("Anthropic not installed")
 
+try:
+    from anthropic.types import ThinkingBlock, ThinkingDelta
+except ImportError:
+    ThinkingBlock = None  # type: ignore[assignment,misc]
+    ThinkingDelta = None  # type: ignore[assignment,misc]
+
 if TYPE_CHECKING:
     from typing import (
         Any,
@@ -85,15 +91,15 @@ if TYPE_CHECKING:
         ToolUnionParam,
     )
 
-    from sentry_sdk._types import TextPart
+    from sentry_sdk._types import ReasoningPart, TextPart
 
-    class _PatchedRawMessageStream(Stream[RawMessageStreamEvent]):
+    class _PatchedRawMessageStream(Stream[Any]):
         _span: Union[Span, StreamedSpan]
         _integration: "AnthropicIntegration"
 
         _model: Optional[ModelParam]
         _usage: "_RecordedUsage"
-        _content_blocks: list[Any]
+        _content_blocks: "list[dict[str, Any]]"
         _response_id: Optional[str]
         _finish_reason: Optional[str]
 
@@ -103,17 +109,17 @@ if TYPE_CHECKING:
 
         _model: Optional[ModelParam]
         _usage: "_RecordedUsage"
-        _content_blocks: list[Any]
+        _content_blocks: "list[dict[str, Any]]"
         _response_id: Optional[str]
         _finish_reason: Optional[str]
 
-    class _PatchedRawAsyncMessageStream(AsyncStream[RawMessageStreamEvent]):
+    class _PatchedRawAsyncMessageStream(AsyncStream[Any]):
         _span: Union[Span, StreamedSpan]
         _integration: "AnthropicIntegration"
 
         _model: Optional[ModelParam]
         _usage: "_RecordedUsage"
-        _content_blocks: list[Any]
+        _content_blocks: "list[dict[str, Any]]"
         _response_id: Optional[str]
         _finish_reason: Optional[str]
 
@@ -123,7 +129,7 @@ if TYPE_CHECKING:
 
         _model: Optional[ModelParam]
         _usage: "_RecordedUsage"
-        _content_blocks: list[Any]
+        _content_blocks: "list[dict[str, Any]]"
         _response_id: Optional[str]
         _finish_reason: Optional[str]
 
@@ -220,6 +226,7 @@ class _StreamSpanContext:
 class AnthropicIntegration(Integration):
     identifier = "anthropic"
     origin = f"auto.ai.{identifier}"
+    _version: "Union[tuple[int, ...], None]" = None
 
     def __init__(self: "AnthropicIntegration", include_prompts: bool = True) -> None:
         self.include_prompts = include_prompts
@@ -228,6 +235,7 @@ class AnthropicIntegration(Integration):
     def setup_once() -> None:
         version = package_version("anthropic")
         _check_minimum_version(AnthropicIntegration, version)
+        AnthropicIntegration._version = version
 
         """
         client.messages.create(stream=True) can return an instance of the Stream class, which implements the iterator protocol.
@@ -272,6 +280,46 @@ class AnthropicIntegration(Integration):
         if not issubclass(AsyncMessageStream, AsyncStream):
             AsyncMessageStream.close = _wrap_async_close(AsyncMessageStream.close)  # type: ignore[method-assign]
 
+        try:
+            from functools import cached_property
+        except ImportError:
+            return
+
+        # In newer anthropic SDK versions, _iterator is a cached_property instead of being eagerly assigned in __init__.
+        # This is good for us, since we do a global patch instead of patching _iterator on every instance.
+        # We also should apply a global patch to keep the cached "_iterator" lazy.
+        if isinstance(Stream.__dict__.get("_iterator"), cached_property):
+            _original_stream_iterator = Stream._iterator.func  # type: ignore[attr-defined]
+
+            def _sentry_patched_stream_iterator(self: "Stream[Any]") -> "Any":
+                iterator = _original_stream_iterator(self)
+                if not hasattr(self, "_span"):
+                    return iterator
+                return _wrap_synchronous_message_iterator(
+                    cast("_PatchedRawMessageStream", self), iterator
+                )
+
+            patched = cached_property(_sentry_patched_stream_iterator)
+            patched.__set_name__(Stream, "_iterator")
+            Stream._iterator = patched  # type: ignore[assignment,method-assign]
+
+        if isinstance(AsyncStream.__dict__.get("_iterator"), cached_property):
+            _original_async_stream_iterator = AsyncStream._iterator.func  # type: ignore[attr-defined]
+
+            def _sentry_patched_async_stream_iterator(
+                self: "AsyncStream[Any]",
+            ) -> "Any":
+                iterator = _original_async_stream_iterator(self)
+                if not hasattr(self, "_span"):
+                    return iterator
+                return _wrap_asynchronous_message_iterator(
+                    cast("_PatchedRawAsyncMessageStream", self), iterator
+                )
+
+            patched = cached_property(_sentry_patched_async_stream_iterator)
+            patched.__set_name__(AsyncStream, "_iterator")
+            AsyncStream._iterator = patched  # type: ignore[assignment,method-assign]
+
 
 def _capture_exception(exc: "Any") -> None:
     event, hint = event_from_exception(
@@ -323,22 +371,32 @@ def _collect_ai_data(
     event: "MessageStreamEvent",
     model: "str | None",
     usage: "_RecordedUsage",
-    content_blocks: "list[str]",
+    content_blocks: "list[dict[str, Any]]",
     response_id: "str | None" = None,
     finish_reason: "str | None" = None,
-) -> "tuple[str | None, _RecordedUsage, list[str], str | None, str | None]":
+) -> "tuple[str | None, _RecordedUsage, list[dict[str, Any]], str | None, str | None]":
     """
     Collect model information, token usage, and collect content blocks from the AI streaming response.
     """
     with capture_internal_exceptions():
         if hasattr(event, "type"):
             if event.type == "content_block_start":
-                pass
+                if ThinkingBlock is not None and isinstance(
+                    event.content_block, ThinkingBlock
+                ):
+                    content_blocks.append({"type": "thinking", "thinking": ""})
+                elif event.content_block.type in ("text", "tool_use"):
+                    content_blocks.append({"type": "text", "text": ""})
+                else:
+                    content_blocks.append({"type": event.content_block.type})
             elif event.type == "content_block_delta":
-                if hasattr(event.delta, "text"):
-                    content_blocks.append(event.delta.text)
+                block = content_blocks[event.index]
+                if ThinkingDelta is not None and isinstance(event.delta, ThinkingDelta):
+                    block["thinking"] += event.delta.thinking
+                elif hasattr(event.delta, "text"):
+                    block["text"] += event.delta.text
                 elif hasattr(event.delta, "partial_json"):
-                    content_blocks.append(event.delta.partial_json)
+                    block["text"] += event.delta.partial_json
             elif event.type == "content_block_stop":
                 pass
 
@@ -665,7 +723,7 @@ def _set_output_data(
     output_tokens: "int | None",
     cache_read_input_tokens: "int | None",
     cache_write_input_tokens: "int | None",
-    content_blocks: "list[Any]",
+    content_blocks: "list[dict[str, Any]]",
     response_id: "str | None" = None,
     finish_reason: "str | None" = None,
 ) -> None:
@@ -689,28 +747,31 @@ def _set_output_data(
         record_outputs = True
 
     if record_outputs:
-        output_messages: "dict[str, list[Any]]" = {
-            "response": [],
-            "tool": [],
-        }
+        parts: "list[Union[TextPart, ReasoningPart]]" = []
+        tool_calls = []
 
         for output in content_blocks:
             if output["type"] == "text":
-                output_messages["response"].append(output["text"])
+                parts.append({"type": "text", "content": output["text"]})
+            elif output["type"] == "thinking":
+                parts.append({"type": "reasoning", "content": output["thinking"]})
             elif output["type"] == "tool_use":
-                output_messages["tool"].append(output)
+                tool_calls.append(output)
 
-        if len(output_messages["tool"]) > 0:
+        if len(tool_calls) > 0:
             set_data_normalized(
                 span,
                 SPANDATA.GEN_AI_RESPONSE_TOOL_CALLS,
-                output_messages["tool"],
+                tool_calls,
                 unpack=False,
             )
 
-        if len(output_messages["response"]) > 0:
+        if len(parts) > 0:
             set_data_normalized(
-                span, SPANDATA.GEN_AI_RESPONSE_TEXT, output_messages["response"]
+                span,
+                SPANDATA.GEN_AI_OUTPUT_MESSAGES,
+                [{"role": "assistant", "parts": parts}],
+                unpack=False,
             )
 
     if input_tokens is not None:
@@ -783,10 +844,19 @@ def _sentry_patched_create_sync(f: "Any", *args: "Any", **kwargs: "Any") -> "Any
         result._integration = integration  # type: ignore[attr-defined]
 
         _initialize_data_accumulation_state(result)
-        result._iterator = _wrap_synchronous_message_iterator(
-            cast("_PatchedRawMessageStream", result),
-            result._iterator,
-        )
+        # New versions use global patch since _iterator was changed to a cached property.
+        if (
+            AnthropicIntegration._version is not None
+            and AnthropicIntegration._version
+            < (
+                1,
+                14,
+            )
+        ):
+            result._iterator = _wrap_synchronous_message_iterator(  # type: ignore[misc]
+                cast("_PatchedRawMessageStream", result),
+                result._iterator,
+            )
 
         return result
 
@@ -881,10 +951,19 @@ async def _sentry_patched_create_async(
         result._integration = integration  # type: ignore[attr-defined]
 
         _initialize_data_accumulation_state(result)
-        result._iterator = _wrap_asynchronous_message_iterator(
-            cast("_PatchedRawAsyncMessageStream", result),
-            result._iterator,
-        )
+        # New versions use global patch since _iterator was changed to a cached property.
+        if (
+            AnthropicIntegration._version is not None
+            and AnthropicIntegration._version
+            < (
+                1,
+                14,
+            )
+        ):
+            result._iterator = _wrap_asynchronous_message_iterator(  # type: ignore[misc]
+                cast("_PatchedRawAsyncMessageStream", result),
+                result._iterator,
+            )
 
         return result
 
@@ -979,7 +1058,7 @@ def _set_streaming_output_data(
     integration: "AnthropicIntegration",
     model: "Optional[str]",
     usage: "_RecordedUsage",
-    content_blocks: "list[str]",
+    content_blocks: "list[dict[str, Any]]",
     response_id: "Optional[str]",
     finish_reason: "Optional[str]",
 ) -> None:
@@ -1002,7 +1081,7 @@ def _set_streaming_output_data(
         output_tokens=usage.output_tokens,
         cache_read_input_tokens=usage.cache_read_input_tokens,
         cache_write_input_tokens=usage.cache_write_input_tokens,
-        content_blocks=[{"text": "".join(content_blocks), "type": "text"}],
+        content_blocks=content_blocks,
         response_id=response_id,
         finish_reason=finish_reason,
     )
@@ -1147,7 +1226,7 @@ def _wrap_message_stream_manager_enter(f: "Any") -> "Any":
 
         _initialize_data_accumulation_state(stream)
         stream._iterator = _wrap_synchronous_message_iterator(
-            stream,
+            cast("_PatchedMessageStream", stream),
             stream._iterator,
         )
 
@@ -1260,7 +1339,7 @@ def _wrap_async_message_stream_manager_aenter(f: "Any") -> "Any":
 
         _initialize_data_accumulation_state(stream)
         stream._iterator = _wrap_asynchronous_message_iterator(
-            stream,
+            cast("_PatchedAsyncMessageStream", stream),
             stream._iterator,
         )
 

{sentry_sdk-2.72.0 → sentry_sdk-2.74.0}/sentry_sdk/integrations/arq.py

@@ -1,7 +1,10 @@
 import sys
+import time
+from datetime import timedelta, timezone
 
 import sentry_sdk
 from sentry_sdk.consts import OP, SPANDATA, SPANSTATUS
+from sentry_sdk.crons import monitor
 from sentry_sdk.integrations import DidNotEnable, Integration, _check_minimum_version
 from sentry_sdk.integrations.logging import ignore_logger
 from sentry_sdk.scope import should_send_default_pii
@@ -15,6 +18,8 @@ from sentry_sdk.utils import (
     ensure_integration_enabled,
     event_from_exception,
     has_data_collection_enabled,
+    logger,
+    match_regex_list,
     parse_version,
     reraise,
 )
@@ -22,6 +27,7 @@ from sentry_sdk.utils import (
 try:
     import arq.worker
     from arq.connections import ArqRedis
+    from arq.typing import WEEKDAYS
     from arq.version import VERSION as ARQ_VERSION
     from arq.worker import JobExecutionFailed, Retry, RetryJob, Worker
 except ImportError:
@@ -30,14 +36,14 @@ except ImportError:
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import Any, Dict, Optional, Union
+    from typing import Any, Dict, List, Optional, Union
 
     from arq.cron import CronJob
     from arq.jobs import Job
     from arq.typing import WorkerCoroutine
     from arq.worker import Function
 
-    from sentry_sdk._types import Event, EventProcessor, ExcInfo, Hint
+    from sentry_sdk._types import Event, EventProcessor, ExcInfo, Hint, MonitorConfig
 
 ARQ_CONTROL_FLOW_EXCEPTIONS = (JobExecutionFailed, Retry, RetryJob)
 
@@ -46,6 +52,14 @@ class ArqIntegration(Integration):
     identifier = "arq"
     origin = f"auto.queue.{identifier}"
 
+    def __init__(
+        self,
+        monitor_cron_jobs: bool = False,
+        exclude_cron_jobs: "Optional[List[str]]" = None,
+    ) -> None:
+        self.monitor_cron_jobs = monitor_cron_jobs
+        self.exclude_cron_jobs = exclude_cron_jobs
+
     @staticmethod
     def setup_once() -> None:
         try:
@@ -278,7 +292,15 @@ def patch_create_worker() -> None:
                 _get_arq_cron_job(cron_job) for cron_job in kwargs.get("cron_jobs", [])
             ]
 
-        return old_create_worker(*args, **kwargs)
+        worker = old_create_worker(*args, **kwargs)
+
+        integration = sentry_sdk.get_client().get_integration(ArqIntegration)
+        if integration is not None and integration.monitor_cron_jobs:
+            for cron_job in worker.cron_jobs:
+                with capture_internal_exceptions():
+                    _monitor_cron_job(integration, cron_job, worker)
+
+        return worker
 
     arq.worker.create_worker = _sentry_create_worker
 
@@ -294,3 +316,115 @@ def _get_arq_cron_job(cron_job: "CronJob") -> "CronJob":
     cron_job.coroutine = _wrap_coroutine(cron_job.name, cron_job.coroutine)
 
     return cron_job
+
+
+def _monitor_cron_job(
+    integration: "ArqIntegration", cron_job: "CronJob", worker: "Worker"
+) -> None:
+    # Each create_worker call wraps the coroutine again.
+    if getattr(cron_job, "_sentry_monitored", False):
+        return
+    cron_job._sentry_monitored = True
+
+    # arq names cron jobs "cron:<function name>" by default.
+    monitor_slug = cron_job.name
+    if monitor_slug.startswith("cron:"):
+        monitor_slug = monitor_slug[len("cron:") :]
+    if match_regex_list(monitor_slug, integration.exclude_cron_jobs):
+        return
+
+    monitor_config = _get_monitor_config(cron_job, worker)
+    if monitor_config is None:
+        logger.debug(
+            "Not monitoring arq cron job %r: its schedule can't be expressed "
+            "as a Sentry Crons schedule.",
+            cron_job.name,
+        )
+        return
+
+    coroutine = cron_job.coroutine
+
+    async def _sentry_cron_coroutine(
+        ctx: "Dict[Any, Any]", *args: "Any", **kwargs: "Any"
+    ) -> "Any":
+        with monitor(monitor_slug=monitor_slug, monitor_config=monitor_config):
+            return await coroutine(ctx, *args, **kwargs)
+
+    cron_job.coroutine = _sentry_cron_coroutine
+
+
+def _get_crontab_field(value: "Any", offset: int = 0) -> "Optional[str]":
+    if value is None:
+        return "*"
+    if isinstance(value, int) and not isinstance(value, bool):
+        value = [value]
+    if not isinstance(value, (set, list, tuple)) or not value:
+        return None
+    if not all(isinstance(v, int) and not isinstance(v, bool) for v in value):
+        return None
+    if offset:
+        value = {(v + offset) % 7 for v in value}
+    return ",".join(str(v) for v in sorted(value))
+
+
+def _get_crontab(cron_job: "CronJob") -> "Optional[str]":
+    # Sentry crontabs have minute resolution.
+    if cron_job.second not in (0, {0}, [0], (0,)):
+        return None
+
+    weekday = cron_job.weekday
+    if isinstance(weekday, str):
+        weekday = WEEKDAYS.index(weekday.lower())
+
+    # arq requires both to match, cron requires either.
+    if cron_job.day is not None and weekday is not None:
+        return None
+
+    fields = [
+        _get_crontab_field(cron_job.minute),
+        _get_crontab_field(cron_job.hour),
+        _get_crontab_field(cron_job.day),
+        _get_crontab_field(cron_job.month),
+        # arq counts weekdays from Monday = 0, cron from Sunday = 0.
+        _get_crontab_field(weekday, offset=1),
+    ]
+    if None in fields:
+        return None
+    return " ".join(fields)  # type: ignore[arg-type]
+
+
+def _get_timezone_name(worker: "Worker") -> "Optional[str]":
+    tz = getattr(worker, "timezone", None)
+    if tz is None:
+        # Before arq 0.25, cron jobs ran in naive local time.
+        if time.timezone == 0 and (not time.daylight or time.altzone == 0):
+            return "UTC"
+        return None
+
+    # zoneinfo and pytz
+    name = getattr(tz, "key", None) or getattr(tz, "zone", None)
+    if isinstance(name, str):
+        return name
+
+    # arq defaults to the system's fixed UTC offset at startup.
+    if isinstance(tz, timezone):
+        offset = tz.utcoffset(None)
+        if offset % timedelta(hours=1):
+            return None
+        hours = offset // timedelta(hours=1)
+        return "Etc/GMT%+d" % -hours if hours else "UTC"
+
+    return None
+
+
+def _get_monitor_config(
+    cron_job: "CronJob", worker: "Worker"
+) -> "Optional[MonitorConfig]":
+    crontab = _get_crontab(cron_job)
+    timezone_name = _get_timezone_name(worker)
+    if crontab is None or timezone_name is None:
+        return None
+    return {
+        "schedule": {"type": "crontab", "value": crontab},
+        "timezone": timezone_name,
+    }

{sentry_sdk-2.72.0 → sentry_sdk-2.74.0}/sentry_sdk/integrations/celery/beat.py

@@ -2,11 +2,9 @@ from typing import TYPE_CHECKING
 
 import sentry_sdk
 from sentry_sdk.crons import MonitorStatus, capture_checkin
+from sentry_sdk.crons.utils import _get_interval_schedule
 from sentry_sdk.integrations import DidNotEnable
-from sentry_sdk.integrations.celery.utils import (
-    _get_humanized_interval,
-    _now_seconds_since_epoch,
-)
+from sentry_sdk.integrations.celery.utils import _now_seconds_since_epoch
 from sentry_sdk.utils import (
     logger,
     match_regex_list,
@@ -74,19 +72,28 @@ def _get_monitor_config(
             "{0._orig_day_of_week}".format(celery_schedule)
         )
     elif isinstance(celery_schedule, schedule):
-        schedule_type = "interval"
-        (schedule_value, schedule_unit) = _get_humanized_interval(
-            celery_schedule.seconds
-        )
-
-        if schedule_unit == "second":
-            logger.warning(
-                "Intervals shorter than one minute are not supported by Sentry Crons. Monitor '%s' has an interval of %s seconds. Use the `exclude_beat_tasks` option in the celery integration to exclude it.",
-                monitor_name,
-                schedule_value,
-            )
+        seconds = celery_schedule.seconds
+        interval_schedule = _get_interval_schedule(seconds)
+
+        if interval_schedule is None:
+            if seconds < 60:
+                logger.warning(
+                    "Intervals shorter than one minute are not supported by Sentry Crons. Monitor '%s' has an interval of %s seconds. Use the `exclude_beat_tasks` option in the celery integration to exclude it.",
+                    monitor_name,
+                    int(seconds),
+                )
+            else:
+                logger.warning(
+                    "Sentry Crons only supports intervals of whole minutes. Monitor '%s' has an interval of %s seconds. Use the `exclude_beat_tasks` option in the celery integration to exclude it.",
+                    monitor_name,
+                    int(seconds),
+                )
             return {}
 
+        schedule_type = "interval"
+        schedule_value = interval_schedule["value"]
+        schedule_unit = interval_schedule["unit"]
+
     else:
         logger.warning(
             "Celery schedule type '%s' not supported by Sentry Crons.",

sentry_sdk-2.74.0/sentry_sdk/integrations/celery/utils.py

@@ -0,0 +1,10 @@
+import time
+
+
+def _now_seconds_since_epoch() -> float:
+    # We cannot use `time.perf_counter()` when dealing with the duration
+    # of a Celery task, because the start of a Celery task and
+    # the end are recorded in different processes.
+    # Start happens in the Celery Beat process,
+    # the end in a Celery Worker process.
+    return time.time()