sentry-sdk 2.39.0__tar.gz → 2.41.0__tar.gz

{sentry_sdk-2.39.0/sentry_sdk.egg-info → sentry_sdk-2.41.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry-sdk
-Version: 2.39.0
+Version: 2.41.0
 Summary: Python client for Sentry (https://sentry.io)
 Home-page: https://github.com/getsentry/sentry-python
 Author: Sentry Team and Contributors
@@ -76,6 +76,8 @@ Provides-Extra: langgraph
 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.77.5; extra == "litellm"
 Provides-Extra: litestar
 Requires-Dist: litestar>=2.0.0; extra == "litestar"
 Provides-Extra: loguru

{sentry_sdk-2.39.0 → sentry_sdk-2.41.0}/pyproject.toml

@@ -1,19 +1,3 @@
-#
-# Tool: Black
-#
-
-[tool.black]
-# 'extend-exclude' excludes files or directories in addition to the defaults
-extend-exclude = '''
-# A regex preceded with ^/ will apply only to files and directories
-# in the root of the project.
-(
-    .*_pb2.py  # exclude autogenerated Protocol Buffer files anywhere in the project
-    | .*_pb2_grpc.py  # exclude autogenerated Protocol Buffer files anywhere in the project
-)
-'''
-
-
 #
 # Tool: Coverage
 #
@@ -195,30 +179,53 @@ ignore_missing_imports = true
 module = "agents.*"
 ignore_missing_imports = true
 
+[[tool.mypy.overrides]]
+module = "dramatiq.*"
+ignore_missing_imports = true
+
 #
-# Tool: Flake8
+# Tool: Ruff (linting and formatting)
 #
 
-[tool.flake8]
-extend-ignore = [
-  # Handled by black (Whitespace before ':' -- handled by black)
-  "E203",
-  # Handled by black (Line too long)
-  "E501",
-  # Sometimes not possible due to execution order (Module level import is not at top of file)
-  "E402",
-  # I don't care (Do not assign a lambda expression, use a def)
-  "E731",
-  # does not apply to Python 2 (redundant exception types by flake8-bugbear)
-  "B014",
-  # I don't care (Lowercase imported as non-lowercase by pep8-naming)
-  "N812",
-  # is a worse version of and conflicts with B902 (first argument of a classmethod should be named cls)
-  "N804",
+[tool.ruff]
+# Target Python 3.7+ (minimum version supported by ruff)
+target-version = "py37"
+
+# Exclude files and directories
+extend-exclude = [
+    "*_pb2.py",     # Protocol Buffer files (covers all pb2 files including grpc_test_service_pb2.py)
+    "*_pb2_grpc.py", # Protocol Buffer files (covers all pb2_grpc files including grpc_test_service_pb2_grpc.py)
+    "checkouts",    # From flake8
+    "lol*",         # From flake8
+]
+
+[tool.ruff.lint]
+# Match flake8's default rule selection exactly
+# Flake8 by default only enables E and W (pycodestyle) + F (pyflakes)
+select = [
+    "E",   # pycodestyle errors (same as flake8 default)
+    "W",   # pycodestyle warnings (same as flake8 default)
+    "F",   # Pyflakes (same as flake8 default)
+    # Note: B and N rules are NOT enabled by default in flake8
+    # They were only active through the plugins, which may not have been fully enabled
 ]
-extend-exclude = ["checkouts", "lol*"]
-exclude = [
-  # gRCP generated files
-  "grpc_test_service_pb2.py",
-  "grpc_test_service_pb2_grpc.py",
+
+# Use ONLY the same ignores as the original flake8 config + compatibility for this codebase
+ignore = [
+    "E203", # Whitespace before ':'
+    "E501", # Line too long
+    "E402", # Module level import not at top of file
+    "E731", # Do not assign a lambda expression, use a def
+    "B014", # Redundant exception types
+    "N812", # Lowercase imported as non-lowercase
+    "N804", # First argument of classmethod should be named cls
+
+    # Additional ignores for codebase compatibility
+    "F401", # Unused imports - many in TYPE_CHECKING blocks used for type comments
+    "E721", # Use isinstance instead of type() == - existing pattern in this codebase
 ]
+
+[tool.ruff.format]
+# ruff format already excludes the same files as specified in extend-exclude
+# Ensure Python 3.7 compatibility - avoid using Python 3.9+ syntax features
+skip-magic-trailing-comma = false

sentry_sdk-2.41.0/sentry_sdk/_metrics.py

@@ -0,0 +1,81 @@
+"""
+NOTE: This file contains experimental code that may be changed or removed at any
+time without prior notice.
+"""
+
+import time
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+import sentry_sdk
+from sentry_sdk.utils import safe_repr
+
+if TYPE_CHECKING:
+    from sentry_sdk._types import Metric, MetricType
+
+
+def _capture_metric(
+    name,  # type: str
+    metric_type,  # type: MetricType
+    value,  # type: float
+    unit=None,  # type: Optional[str]
+    attributes=None,  # type: Optional[dict[str, Any]]
+):
+    # type: (...) -> None
+    client = sentry_sdk.get_client()
+
+    attrs = {}  # type: dict[str, Union[str, bool, float, int]]
+    if attributes:
+        for k, v in attributes.items():
+            attrs[k] = (
+                v
+                if (
+                    isinstance(v, str)
+                    or isinstance(v, int)
+                    or isinstance(v, bool)
+                    or isinstance(v, float)
+                )
+                else safe_repr(v)
+            )
+
+    metric = {
+        "timestamp": time.time(),
+        "trace_id": None,
+        "span_id": None,
+        "name": name,
+        "type": metric_type,
+        "value": float(value),
+        "unit": unit,
+        "attributes": attrs,
+    }  # type: Metric
+
+    client._capture_metric(metric)
+
+
+def count(
+    name,  # type: str
+    value,  # type: float
+    unit=None,  # type: Optional[str]
+    attributes=None,  # type: Optional[dict[str, Any]]
+):
+    # type: (...) -> None
+    _capture_metric(name, "counter", value, unit, attributes)
+
+
+def gauge(
+    name,  # type: str
+    value,  # type: float
+    unit=None,  # type: Optional[str]
+    attributes=None,  # type: Optional[dict[str, Any]]
+):
+    # type: (...) -> None
+    _capture_metric(name, "gauge", value, unit, attributes)
+
+
+def distribution(
+    name,  # type: str
+    value,  # type: float
+    unit=None,  # type: Optional[str]
+    attributes=None,  # type: Optional[dict[str, Any]]
+):
+    # type: (...) -> None
+    _capture_metric(name, "distribution", value, unit, attributes)

sentry_sdk-2.41.0/sentry_sdk/_metrics_batcher.py

@@ -0,0 +1,156 @@
+import os
+import random
+import threading
+from datetime import datetime, timezone
+from typing import Optional, List, Callable, TYPE_CHECKING, Any, Union
+
+from sentry_sdk.utils import format_timestamp, safe_repr
+from sentry_sdk.envelope import Envelope, Item, PayloadRef
+
+if TYPE_CHECKING:
+    from sentry_sdk._types import Metric
+
+
+class MetricsBatcher:
+    MAX_METRICS_BEFORE_FLUSH = 100
+    FLUSH_WAIT_TIME = 5.0
+
+    def __init__(
+        self,
+        capture_func,  # type: Callable[[Envelope], None]
+    ):
+        # type: (...) -> None
+        self._metric_buffer = []  # type: List[Metric]
+        self._capture_func = capture_func
+        self._running = True
+        self._lock = threading.Lock()
+
+        self._flush_event = threading.Event()  # type: threading.Event
+
+        self._flusher = None  # type: Optional[threading.Thread]
+        self._flusher_pid = None  # type: Optional[int]
+
+    def _ensure_thread(self):
+        # type: (...) -> bool
+        if not self._running:
+            return False
+
+        pid = os.getpid()
+        if self._flusher_pid == pid:
+            return True
+
+        with self._lock:
+            if self._flusher_pid == pid:
+                return True
+
+            self._flusher_pid = pid
+
+            self._flusher = threading.Thread(target=self._flush_loop)
+            self._flusher.daemon = True
+
+            try:
+                self._flusher.start()
+            except RuntimeError:
+                self._running = False
+                return False
+
+        return True
+
+    def _flush_loop(self):
+        # type: (...) -> None
+        while self._running:
+            self._flush_event.wait(self.FLUSH_WAIT_TIME + random.random())
+            self._flush_event.clear()
+            self._flush()
+
+    def add(
+        self,
+        metric,  # type: Metric
+    ):
+        # type: (...) -> None
+        if not self._ensure_thread() or self._flusher is None:
+            return None
+
+        with self._lock:
+            self._metric_buffer.append(metric)
+            if len(self._metric_buffer) >= self.MAX_METRICS_BEFORE_FLUSH:
+                self._flush_event.set()
+
+    def kill(self):
+        # type: (...) -> None
+        if self._flusher is None:
+            return
+
+        self._running = False
+        self._flush_event.set()
+        self._flusher = None
+
+    def flush(self):
+        # type: (...) -> None
+        self._flush()
+
+    @staticmethod
+    def _metric_to_transport_format(metric):
+        # type: (Metric) -> Any
+        def format_attribute(val):
+            # type: (Union[int, float, str, bool]) -> Any
+            if isinstance(val, bool):
+                return {"value": val, "type": "boolean"}
+            if isinstance(val, int):
+                return {"value": val, "type": "integer"}
+            if isinstance(val, float):
+                return {"value": val, "type": "double"}
+            if isinstance(val, str):
+                return {"value": val, "type": "string"}
+            return {"value": safe_repr(val), "type": "string"}
+
+        res = {
+            "timestamp": metric["timestamp"],
+            "trace_id": metric["trace_id"],
+            "name": metric["name"],
+            "type": metric["type"],
+            "value": metric["value"],
+            "attributes": {
+                k: format_attribute(v) for (k, v) in metric["attributes"].items()
+            },
+        }
+
+        if metric.get("span_id") is not None:
+            res["span_id"] = metric["span_id"]
+
+        if metric.get("unit") is not None:
+            res["unit"] = metric["unit"]
+
+        return res
+
+    def _flush(self):
+        # type: (...) -> Optional[Envelope]
+
+        envelope = Envelope(
+            headers={"sent_at": format_timestamp(datetime.now(timezone.utc))}
+        )
+        with self._lock:
+            if len(self._metric_buffer) == 0:
+                return None
+
+            envelope.add_item(
+                Item(
+                    type="trace_metric",
+                    content_type="application/vnd.sentry.items.trace-metric+json",
+                    headers={
+                        "item_count": len(self._metric_buffer),
+                    },
+                    payload=PayloadRef(
+                        json={
+                            "items": [
+                                self._metric_to_transport_format(metric)
+                                for metric in self._metric_buffer
+                            ]
+                        }
+                    ),
+                )
+            )
+            self._metric_buffer.clear()
+
+        self._capture_func(envelope)
+        return envelope

{sentry_sdk-2.39.0 → sentry_sdk-2.41.0}/sentry_sdk/_types.py

@@ -210,7 +210,6 @@ if TYPE_CHECKING:
             "type": Literal["check_in", "transaction"],
             "user": dict[str, object],
             "_dropped_spans": int,
-            "_metrics_summary": dict[str, object],
         },
         total=False,
     )
@@ -235,6 +234,32 @@ if TYPE_CHECKING:
         },
     )
 
+    MetricType = Literal["counter", "gauge", "distribution"]
+
+    MetricAttributeValue = TypedDict(
+        "MetricAttributeValue",
+        {
+            "value": Union[str, bool, float, int],
+            "type": Literal["string", "boolean", "double", "integer"],
+        },
+    )
+
+    Metric = TypedDict(
+        "Metric",
+        {
+            "timestamp": float,
+            "trace_id": Optional[str],
+            "span_id": Optional[str],
+            "name": str,
+            "type": MetricType,
+            "value": float,
+            "unit": Optional[str],
+            "attributes": dict[str, str | bool | float | int],
+        },
+    )
+
+    MetricProcessor = Callable[[Metric, Hint], Optional[Metric]]
+
     # TODO: Make a proper type definition for this (PRs welcome!)
     Breadcrumb = Dict[str, Any]
 
@@ -266,36 +291,16 @@ if TYPE_CHECKING:
         "internal",
         "profile",
         "profile_chunk",
-        "metric_bucket",
         "monitor",
         "span",
         "log_item",
+        "trace_metric",
     ]
     SessionStatus = Literal["ok", "exited", "crashed", "abnormal"]
 
     ContinuousProfilerMode = Literal["thread", "gevent", "unknown"]
     ProfilerMode = Union[ContinuousProfilerMode, Literal["sleep"]]
 
-    # Type of the metric.
-    MetricType = Literal["d", "s", "g", "c"]
-
-    # Value of the metric.
-    MetricValue = Union[int, float, str]
-
-    # Internal representation of tags as a tuple of tuples (this is done in order to allow for the same key to exist
-    # multiple times).
-    MetricTagsInternal = Tuple[Tuple[str, str], ...]
-
-    # External representation of tags as a dictionary.
-    MetricTagValue = Union[str, int, float, None]
-    MetricTags = Mapping[str, MetricTagValue]
-
-    # Value inside the generator for the metric value.
-    FlushedMetricValue = Union[int, float]
-
-    BucketKey = Tuple[MetricType, str, MeasurementUnit, MetricTagsInternal]
-    MetricMetaKey = Tuple[MetricType, str, MeasurementUnit]
-
     MonitorConfigScheduleType = Literal["crontab", "interval"]
     MonitorConfigScheduleUnit = Literal[
         "year",

sentry_sdk-2.41.0/sentry_sdk/ai/__init__.py

@@ -0,0 +1,7 @@
+from .utils import (
+    set_data_normalized,
+    GEN_AI_MESSAGE_ROLE_MAPPING,
+    GEN_AI_MESSAGE_ROLE_REVERSE_MAPPING,
+    normalize_message_role,
+    normalize_message_roles,
+)  # noqa: F401

{sentry_sdk-2.39.0 → sentry_sdk-2.41.0}/sentry_sdk/ai/utils.py

@@ -10,6 +10,26 @@ import sentry_sdk
 from sentry_sdk.utils import logger
 
 
+class GEN_AI_ALLOWED_MESSAGE_ROLES:
+    SYSTEM = "system"
+    USER = "user"
+    ASSISTANT = "assistant"
+    TOOL = "tool"
+
+
+GEN_AI_MESSAGE_ROLE_REVERSE_MAPPING = {
+    GEN_AI_ALLOWED_MESSAGE_ROLES.SYSTEM: ["system"],
+    GEN_AI_ALLOWED_MESSAGE_ROLES.USER: ["user", "human"],
+    GEN_AI_ALLOWED_MESSAGE_ROLES.ASSISTANT: ["assistant", "ai"],
+    GEN_AI_ALLOWED_MESSAGE_ROLES.TOOL: ["tool", "tool_call"],
+}
+
+GEN_AI_MESSAGE_ROLE_MAPPING = {}
+for target_role, source_roles in GEN_AI_MESSAGE_ROLE_REVERSE_MAPPING.items():
+    for source_role in source_roles:
+        GEN_AI_MESSAGE_ROLE_MAPPING[source_role] = target_role
+
+
 def _normalize_data(data, unpack=True):
     # type: (Any, bool) -> Any
     # convert pydantic data (e.g. OpenAI v1+) to json compatible format
@@ -40,6 +60,34 @@ def set_data_normalized(span, key, value, unpack=True):
         span.set_data(key, json.dumps(normalized))
 
 
+def normalize_message_role(role):
+    # type: (str) -> str
+    """
+    Normalize a message role to one of the 4 allowed gen_ai role values.
+    Maps "ai" -> "assistant" and keeps other standard roles unchanged.
+    """
+    return GEN_AI_MESSAGE_ROLE_MAPPING.get(role, role)
+
+
+def normalize_message_roles(messages):
+    # type: (list[dict[str, Any]]) -> list[dict[str, Any]]
+    """
+    Normalize roles in a list of messages to use standard gen_ai role values.
+    Creates a deep copy to avoid modifying the original messages.
+    """
+    normalized_messages = []
+    for message in messages:
+        if not isinstance(message, dict):
+            normalized_messages.append(message)
+            continue
+        normalized_message = message.copy()
+        if "role" in message:
+            normalized_message["role"] = normalize_message_role(message["role"])
+        normalized_messages.append(normalized_message)
+
+    return normalized_messages
+
+
 def get_start_span_function():
     # type: () -> Callable[..., Any]
     current_span = sentry_sdk.get_current_span()