sentry-sdk 3.0.0a2__py2.py3-none-any.whl → 3.0.0a4__py2.py3-none-any.whl

sentry_sdk/integrations/celery/beat.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sentry_sdk
 from sentry_sdk.crons import capture_checkin, MonitorStatus
 from sentry_sdk.integrations import DidNotEnable
@@ -42,8 +43,7 @@ except ImportError:
     RedBeatScheduler = None
 
 
-def _get_headers(task):
-    # type: (Task) -> dict[str, Any]
+def _get_headers(task: Task) -> dict[str, Any]:
     headers = task.request.get("headers") or {}
 
     # flatten nested headers
@@ -56,12 +56,13 @@ def _get_headers(task):
     return headers
 
 
-def _get_monitor_config(celery_schedule, app, monitor_name):
-    # 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[MonitorConfigScheduleUnit]
+def _get_monitor_config(
+    celery_schedule: Any, app: Celery, monitor_name: str
+) -> MonitorConfig:
+    monitor_config: MonitorConfig = {}
+    schedule_type: Optional[MonitorConfigScheduleType] = None
+    schedule_value: Optional[Union[str, int]] = None
+    schedule_unit: Optional[MonitorConfigScheduleUnit] = None
 
     if isinstance(celery_schedule, crontab):
         schedule_type = "crontab"
@@ -113,8 +114,11 @@ def _get_monitor_config(celery_schedule, app, monitor_name):
     return monitor_config
 
 
-def _apply_crons_data_to_schedule_entry(scheduler, schedule_entry, integration):
-    # type: (Any, Any, sentry_sdk.integrations.celery.CeleryIntegration) -> None
+def _apply_crons_data_to_schedule_entry(
+    scheduler: Any,
+    schedule_entry: Any,
+    integration: sentry_sdk.integrations.celery.CeleryIntegration,
+) -> None:
     """
     Add Sentry Crons information to the schedule_entry headers.
     """
@@ -158,8 +162,7 @@ def _apply_crons_data_to_schedule_entry(scheduler, schedule_entry, integration):
     schedule_entry.options["headers"] = headers
 
 
-def _wrap_beat_scheduler(original_function):
-    # type: (Callable[..., Any]) -> Callable[..., Any]
+def _wrap_beat_scheduler(original_function: Callable[..., Any]) -> Callable[..., Any]:
     """
     Makes sure that:
     - a new Sentry trace is started for each task started by Celery Beat and
@@ -178,8 +181,7 @@ def _wrap_beat_scheduler(original_function):
 
     from sentry_sdk.integrations.celery import CeleryIntegration
 
-    def sentry_patched_scheduler(*args, **kwargs):
-        # type: (*Any, **Any) -> None
+    def sentry_patched_scheduler(*args: Any, **kwargs: Any) -> None:
         integration = sentry_sdk.get_client().get_integration(CeleryIntegration)
         if integration is None:
             return original_function(*args, **kwargs)
@@ -197,29 +199,25 @@ def _wrap_beat_scheduler(original_function):
     return sentry_patched_scheduler
 
 
-def _patch_beat_apply_entry():
-    # type: () -> None
+def _patch_beat_apply_entry() -> None:
     Scheduler.apply_entry = _wrap_beat_scheduler(Scheduler.apply_entry)
 
 
-def _patch_redbeat_apply_async():
-    # type: () -> None
+def _patch_redbeat_apply_async() -> None:
     if RedBeatScheduler is None:
         return
 
     RedBeatScheduler.apply_async = _wrap_beat_scheduler(RedBeatScheduler.apply_async)
 
 
-def _setup_celery_beat_signals(monitor_beat_tasks):
-    # type: (bool) -> None
+def _setup_celery_beat_signals(monitor_beat_tasks: bool) -> None:
     if monitor_beat_tasks:
         task_success.connect(crons_task_success)
         task_failure.connect(crons_task_failure)
         task_retry.connect(crons_task_retry)
 
 
-def crons_task_success(sender, **kwargs):
-    # type: (Task, dict[Any, Any]) -> None
+def crons_task_success(sender: Task, **kwargs: dict[Any, Any]) -> None:
     logger.debug("celery_task_success %s", sender)
     headers = _get_headers(sender)
 
@@ -243,8 +241,7 @@ def crons_task_success(sender, **kwargs):
     )
 
 
-def crons_task_failure(sender, **kwargs):
-    # type: (Task, dict[Any, Any]) -> None
+def crons_task_failure(sender: Task, **kwargs: dict[Any, Any]) -> None:
     logger.debug("celery_task_failure %s", sender)
     headers = _get_headers(sender)
 
@@ -268,8 +265,7 @@ def crons_task_failure(sender, **kwargs):
     )
 
 
-def crons_task_retry(sender, **kwargs):
-    # type: (Task, dict[Any, Any]) -> None
+def crons_task_retry(sender: Task, **kwargs: dict[Any, Any]) -> None:
     logger.debug("celery_task_retry %s", sender)
     headers = _get_headers(sender)
 

sentry_sdk/integrations/celery/utils.py

@@ -1,13 +1,20 @@
+from __future__ import annotations
 import time
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import Any, Tuple
+    from typing import Any, Tuple, List
     from sentry_sdk._types import MonitorConfigScheduleUnit
 
 
-def _now_seconds_since_epoch():
-    # type: () -> float
+TIME_UNITS: List[Tuple[MonitorConfigScheduleUnit, float]] = [
+    ("day", 60 * 60 * 24.0),
+    ("hour", 60 * 60.0),
+    ("minute", 60.0),
+]
+
+
+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.
@@ -16,28 +23,19 @@ def _now_seconds_since_epoch():
     return time.time()
 
 
-def _get_humanized_interval(seconds):
-    # type: (float) -> Tuple[int, MonitorConfigScheduleUnit]
-    TIME_UNITS = (  # noqa: N806
-        ("day", 60 * 60 * 24.0),
-        ("hour", 60 * 60.0),
-        ("minute", 60.0),
-    )
-
+def _get_humanized_interval(seconds: float) -> Tuple[int, MonitorConfigScheduleUnit]:
     seconds = float(seconds)
     for unit, divider in TIME_UNITS:
         if seconds >= divider:
             interval = int(seconds / divider)
-            return (interval, cast("MonitorConfigScheduleUnit", unit))
+            return (interval, unit)
 
     return (int(seconds), "second")
 
 
 class NoOpMgr:
-    def __enter__(self):
-        # type: () -> None
+    def __enter__(self) -> None:
         return None
 
-    def __exit__(self, exc_type, exc_value, traceback):
-        # type: (Any, Any, Any) -> None
+    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
         return None

sentry_sdk/integrations/chalice.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 from functools import wraps
 
@@ -32,8 +33,7 @@ if TYPE_CHECKING:
 
 
 class EventSourceHandler(ChaliceEventSourceHandler):  # type: ignore
-    def __call__(self, event, context):
-        # type: (Any, Any) -> Any
+    def __call__(self, event: Any, context: Any) -> Any:
         client = sentry_sdk.get_client()
 
         with sentry_sdk.isolation_scope() as scope:
@@ -56,11 +56,9 @@ class EventSourceHandler(ChaliceEventSourceHandler):  # type: ignore
                 reraise(*exc_info)
 
 
-def _get_view_function_response(app, view_function, function_args):
-    # type: (Any, F, Any) -> F
+def _get_view_function_response(app: Any, view_function: F, function_args: Any) -> F:
     @wraps(view_function)
-    def wrapped_view_function(**function_args):
-        # type: (**Any) -> Any
+    def wrapped_view_function(**function_args: Any) -> Any:
         client = sentry_sdk.get_client()
         with sentry_sdk.isolation_scope() as scope:
             with capture_internal_exceptions():
@@ -99,8 +97,7 @@ class ChaliceIntegration(Integration):
     identifier = "chalice"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
 
         version = parse_version(CHALICE_VERSION)
 
@@ -116,8 +113,9 @@ class ChaliceIntegration(Integration):
                 RestAPIEventHandler._get_view_function_response
             )
 
-        def sentry_event_response(app, view_function, function_args):
-            # type: (Any, F, Dict[str, Any]) -> Any
+        def sentry_event_response(
+            app: Any, view_function: F, function_args: Dict[str, Any]
+        ) -> Any:
             wrapped_view_function = _get_view_function_response(
                 app, view_function, function_args
             )

sentry_sdk/integrations/clickhouse_driver.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sentry_sdk
 from sentry_sdk.consts import OP, SPANDATA
 from sentry_sdk.integrations import _check_minimum_version, Integration, DidNotEnable
@@ -9,27 +10,13 @@ from sentry_sdk.utils import (
     ensure_integration_enabled,
 )
 
-from typing import TYPE_CHECKING, cast, Any, Dict, TypeVar
+from typing import TYPE_CHECKING
 
-# Hack to get new Python features working in older versions
-# without introducing a hard dependency on `typing_extensions`
-# from: https://stackoverflow.com/a/71944042/300572
 if TYPE_CHECKING:
-    from typing import ParamSpec, Callable
-else:
-    # Fake ParamSpec
-    class ParamSpec:
-        def __init__(self, _):
-            self.args = None
-            self.kwargs = None
+    from typing import ParamSpec, Callable, Any, Dict, TypeVar
 
-    # Callable[anything] will return None
-    class _Callable:
-        def __getitem__(self, _):
-            return None
-
-    # Make instances
-    Callable = _Callable()
+    P = ParamSpec("P")
+    T = TypeVar("T")
 
 
 try:
@@ -72,10 +59,6 @@ class ClickhouseDriverIntegration(Integration):
         )
 
 
-P = ParamSpec("P")
-T = TypeVar("T")
-
-
 def _wrap_start(f: Callable[P, T]) -> Callable[P, T]:
     @ensure_integration_enabled(ClickhouseDriverIntegration, f)
     def _inner(*args: P.args, **kwargs: P.kwargs) -> T:
@@ -88,13 +71,12 @@ def _wrap_start(f: Callable[P, T]) -> Callable[P, T]:
             op=OP.DB,
             name=query,
             origin=ClickhouseDriverIntegration.origin,
-            only_if_parent=True,
+            only_as_child_span=True,
         )
 
         connection._sentry_span = span  # type: ignore[attr-defined]
 
-        data = _get_db_data(connection)
-        data = cast("dict[str, Any]", data)
+        data: dict[str, Any] = _get_db_data(connection)
         data["db.query.text"] = query
 
         if query_id:
@@ -117,7 +99,11 @@ def _wrap_start(f: Callable[P, T]) -> Callable[P, T]:
 def _wrap_end(f: Callable[P, T]) -> Callable[P, T]:
     def _inner_end(*args: P.args, **kwargs: P.kwargs) -> T:
         res = f(*args, **kwargs)
-        client = cast("clickhouse_driver.client.Client", args[0])
+
+        client = args[0]
+        if not isinstance(client, clickhouse_driver.client.Client):
+            return res
+
         connection = client.connection
 
         span = getattr(connection, "_sentry_span", None)
@@ -150,9 +136,11 @@ def _wrap_end(f: Callable[P, T]) -> Callable[P, T]:
 
 def _wrap_send_data(f: Callable[P, T]) -> Callable[P, T]:
     def _inner_send_data(*args: P.args, **kwargs: P.kwargs) -> T:
-        client = cast("clickhouse_driver.client.Client", args[0])
+        client = args[0]
+        if not isinstance(client, clickhouse_driver.client.Client):
+            return f(*args, **kwargs)
+
         connection = client.connection
-        db_params_data = cast("list[Any]", args[2])
         span = getattr(connection, "_sentry_span", None)
 
         if span is not None:
@@ -160,11 +148,13 @@ def _wrap_send_data(f: Callable[P, T]) -> Callable[P, T]:
             _set_on_span(span, data)
 
             if should_send_default_pii():
-                saved_db_data = getattr(
+                saved_db_data: dict[str, Any] = getattr(
                     connection, "_sentry_db_data", {}
-                )  # type: dict[str, Any]
-                db_params = saved_db_data.get("db.params") or []  # type: list[Any]
-                db_params.extend(db_params_data)
+                )
+                db_params: list[Any] = saved_db_data.get("db.params") or []
+                db_params_data = args[2]
+                if isinstance(db_params_data, list):
+                    db_params.extend(db_params_data)
                 saved_db_data["db.params"] = db_params
                 span.set_attribute("db.params", _serialize_span_attribute(db_params))
 

sentry_sdk/integrations/cloud_resource_context.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import json
 import urllib3
 
@@ -65,13 +66,11 @@ class CloudResourceContextIntegration(Integration):
 
     gcp_metadata = None
 
-    def __init__(self, cloud_provider=""):
-        # type: (str) -> None
+    def __init__(self, cloud_provider: str = "") -> None:
         CloudResourceContextIntegration.cloud_provider = cloud_provider
 
     @classmethod
-    def _is_aws(cls):
-        # type: () -> bool
+    def _is_aws(cls) -> bool:
         try:
             r = cls.http.request(
                 "PUT",
@@ -95,8 +94,7 @@ class CloudResourceContextIntegration(Integration):
             return False
 
     @classmethod
-    def _get_aws_context(cls):
-        # type: () -> Dict[str, str]
+    def _get_aws_context(cls) -> Dict[str, str]:
         ctx = {
             "cloud.provider": CLOUD_PROVIDER.AWS,
             "cloud.platform": CLOUD_PLATFORM.AWS_EC2,
@@ -149,8 +147,7 @@ class CloudResourceContextIntegration(Integration):
         return ctx
 
     @classmethod
-    def _is_gcp(cls):
-        # type: () -> bool
+    def _is_gcp(cls) -> bool:
         try:
             r = cls.http.request(
                 "GET",
@@ -174,8 +171,7 @@ class CloudResourceContextIntegration(Integration):
             return False
 
     @classmethod
-    def _get_gcp_context(cls):
-        # type: () -> Dict[str, str]
+    def _get_gcp_context(cls) -> Dict[str, str]:
         ctx = {
             "cloud.provider": CLOUD_PROVIDER.GCP,
             "cloud.platform": CLOUD_PLATFORM.GCP_COMPUTE_ENGINE,
@@ -229,8 +225,7 @@ class CloudResourceContextIntegration(Integration):
         return ctx
 
     @classmethod
-    def _get_cloud_provider(cls):
-        # type: () -> str
+    def _get_cloud_provider(cls) -> str:
         if cls._is_aws():
             return CLOUD_PROVIDER.AWS
 
@@ -240,8 +235,7 @@ class CloudResourceContextIntegration(Integration):
         return ""
 
     @classmethod
-    def _get_cloud_resource_context(cls):
-        # type: () -> Dict[str, str]
+    def _get_cloud_resource_context(cls) -> Dict[str, str]:
         cloud_provider = (
             cls.cloud_provider
             if cls.cloud_provider != ""
@@ -253,8 +247,7 @@ class CloudResourceContextIntegration(Integration):
         return {}
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         cloud_provider = CloudResourceContextIntegration.cloud_provider
         unsupported_cloud_provider = (
             cloud_provider != "" and cloud_provider not in context_getters.keys()

sentry_sdk/integrations/cohere.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from functools import wraps
 
 from sentry_sdk import consts
@@ -70,20 +71,17 @@ class CohereIntegration(Integration):
     identifier = "cohere"
     origin = f"auto.ai.{identifier}"
 
-    def __init__(self, include_prompts=True):
-        # type: (CohereIntegration, bool) -> None
+    def __init__(self: CohereIntegration, include_prompts: bool = True) -> None:
         self.include_prompts = include_prompts
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         BaseCohere.chat = _wrap_chat(BaseCohere.chat, streaming=False)
         Client.embed = _wrap_embed(Client.embed)
         BaseCohere.chat_stream = _wrap_chat(BaseCohere.chat_stream, streaming=True)
 
 
-def _capture_exception(exc):
-    # type: (Any) -> None
+def _capture_exception(exc: Any) -> None:
     event, hint = event_from_exception(
         exc,
         client_options=sentry_sdk.get_client().options,
@@ -92,11 +90,11 @@ def _capture_exception(exc):
     sentry_sdk.capture_event(event, hint=hint)
 
 
-def _wrap_chat(f, streaming):
-    # type: (Callable[..., Any], bool) -> Callable[..., Any]
+def _wrap_chat(f: Callable[..., Any], streaming: bool) -> Callable[..., Any]:
 
-    def collect_chat_response_fields(span, res, include_pii):
-        # type: (Span, NonStreamedChatResponse, bool) -> None
+    def collect_chat_response_fields(
+        span: Span, res: NonStreamedChatResponse, include_pii: bool
+    ) -> None:
         if include_pii:
             if hasattr(res, "text"):
                 set_data_normalized(
@@ -116,22 +114,21 @@ def _wrap_chat(f, streaming):
             if hasattr(res.meta, "billed_units"):
                 record_token_usage(
                     span,
-                    prompt_tokens=res.meta.billed_units.input_tokens,
-                    completion_tokens=res.meta.billed_units.output_tokens,
+                    input_tokens=res.meta.billed_units.input_tokens,
+                    output_tokens=res.meta.billed_units.output_tokens,
                 )
             elif hasattr(res.meta, "tokens"):
                 record_token_usage(
                     span,
-                    prompt_tokens=res.meta.tokens.input_tokens,
-                    completion_tokens=res.meta.tokens.output_tokens,
+                    input_tokens=res.meta.tokens.input_tokens,
+                    output_tokens=res.meta.tokens.output_tokens,
                 )
 
             if hasattr(res.meta, "warnings"):
                 set_data_normalized(span, SPANDATA.AI_WARNINGS, res.meta.warnings)
 
     @wraps(f)
-    def new_chat(*args, **kwargs):
-        # type: (*Any, **Any) -> Any
+    def new_chat(*args: Any, **kwargs: Any) -> Any:
         integration = sentry_sdk.get_client().get_integration(CohereIntegration)
 
         if (
@@ -147,7 +144,7 @@ def _wrap_chat(f, streaming):
             op=consts.OP.COHERE_CHAT_COMPLETIONS_CREATE,
             name="cohere.client.Chat",
             origin=CohereIntegration.origin,
-            only_if_parent=True,
+            only_as_child_span=True,
         )
         span.__enter__()
         try:
@@ -185,8 +182,7 @@ def _wrap_chat(f, streaming):
             if streaming:
                 old_iterator = res
 
-                def new_iterator():
-                    # type: () -> Iterator[StreamedChatResponse]
+                def new_iterator() -> Iterator[StreamedChatResponse]:
 
                     with capture_internal_exceptions():
                         for x in old_iterator:
@@ -220,12 +216,10 @@ def _wrap_chat(f, streaming):
     return new_chat
 
 
-def _wrap_embed(f):
-    # type: (Callable[..., Any]) -> Callable[..., Any]
+def _wrap_embed(f: Callable[..., Any]) -> Callable[..., Any]:
 
     @wraps(f)
-    def new_embed(*args, **kwargs):
-        # type: (*Any, **Any) -> Any
+    def new_embed(*args: Any, **kwargs: Any) -> Any:
         integration = sentry_sdk.get_client().get_integration(CohereIntegration)
         if integration is None:
             return f(*args, **kwargs)
@@ -234,7 +228,7 @@ def _wrap_embed(f):
             op=consts.OP.COHERE_EMBEDDINGS_CREATE,
             name="Cohere Embedding Creation",
             origin=CohereIntegration.origin,
-            only_if_parent=True,
+            only_as_child_span=True,
         ) as span:
             if "texts" in kwargs and (
                 should_send_default_pii() and integration.include_prompts
@@ -264,7 +258,7 @@ def _wrap_embed(f):
             ):
                 record_token_usage(
                     span,
-                    prompt_tokens=res.meta.billed_units.input_tokens,
+                    input_tokens=res.meta.billed_units.input_tokens,
                     total_tokens=res.meta.billed_units.input_tokens,
                 )
             return res

sentry_sdk/integrations/dedupe.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sentry_sdk
 from sentry_sdk.utils import ContextVar
 from sentry_sdk.integrations import Integration
@@ -14,16 +15,13 @@ if TYPE_CHECKING:
 class DedupeIntegration(Integration):
     identifier = "dedupe"
 
-    def __init__(self):
-        # type: () -> None
+    def __init__(self) -> None:
         self._last_seen = ContextVar("last-seen")
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         @add_global_event_processor
-        def processor(event, hint):
-            # type: (Event, Optional[Hint]) -> Optional[Event]
+        def processor(event: Event, hint: Optional[Hint]) -> Optional[Event]:
             if hint is None:
                 return event
 
@@ -42,8 +40,7 @@ class DedupeIntegration(Integration):
             return event
 
     @staticmethod
-    def reset_last_seen():
-        # type: () -> None
+    def reset_last_seen() -> None:
         integration = sentry_sdk.get_client().get_integration(DedupeIntegration)
         if integration is None:
             return