sentry-sdk 2.39.0__py2.py3-none-any.whl → 2.41.0__py2.py3-none-any.whl

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/_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/_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/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/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()

sentry_sdk/client.py

@@ -24,7 +24,9 @@ from sentry_sdk.utils import (
     is_gevent,
     logger,
     get_before_send_log,
+    get_before_send_metric,
     has_logs_enabled,
+    has_metrics_enabled,
 )
 from sentry_sdk.serializer import serialize
 from sentry_sdk.tracing import trace
@@ -59,14 +61,14 @@ if TYPE_CHECKING:
     from typing import Union
     from typing import TypeVar
 
-    from sentry_sdk._types import Event, Hint, SDKInfo, Log
+    from sentry_sdk._types import Event, Hint, SDKInfo, Log, Metric
     from sentry_sdk.integrations import Integration
-    from sentry_sdk.metrics import MetricsAggregator
     from sentry_sdk.scope import Scope
     from sentry_sdk.session import Session
     from sentry_sdk.spotlight import SpotlightClient
     from sentry_sdk.transport import Transport
     from sentry_sdk._log_batcher import LogBatcher
+    from sentry_sdk._metrics_batcher import MetricsBatcher
 
     I = TypeVar("I", bound=Integration)  # noqa: E741
 
@@ -178,14 +180,12 @@ class BaseClient:
 
     def __init__(self, options=None):
         # type: (Optional[Dict[str, Any]]) -> None
-        self.options = (
-            options if options is not None else DEFAULT_OPTIONS
-        )  # type: Dict[str, Any]
+        self.options = options if options is not None else DEFAULT_OPTIONS  # type: Dict[str, Any]
 
         self.transport = None  # type: Optional[Transport]
         self.monitor = None  # type: Optional[Monitor]
-        self.metrics_aggregator = None  # type: Optional[MetricsAggregator]
         self.log_batcher = None  # type: Optional[LogBatcher]
+        self.metrics_batcher = None  # type: Optional[MetricsBatcher]
 
     def __getstate__(self, *args, **kwargs):
         # type: (*Any, **Any) -> Any
@@ -217,10 +217,14 @@ class BaseClient:
         # type: (*Any, **Any) -> Optional[str]
         return None
 
-    def _capture_experimental_log(self, log):
+    def _capture_log(self, log):
         # type: (Log) -> None
         pass
 
+    def _capture_metric(self, metric):
+        # type: (Metric) -> None
+        pass
+
     def capture_session(self, *args, **kwargs):
         # type: (*Any, **Any) -> None
         return None
@@ -363,26 +367,6 @@ class _Client(BaseClient):
 
             self.session_flusher = SessionFlusher(capture_func=_capture_envelope)
 
-            self.metrics_aggregator = None  # type: Optional[MetricsAggregator]
-            experiments = self.options.get("_experiments", {})
-            if experiments.get("enable_metrics", True):
-                # Context vars are not working correctly on Python <=3.6
-                # with gevent.
-                metrics_supported = not is_gevent() or PY37
-                if metrics_supported:
-                    from sentry_sdk.metrics import MetricsAggregator
-
-                    self.metrics_aggregator = MetricsAggregator(
-                        capture_func=_capture_envelope,
-                        enable_code_locations=bool(
-                            experiments.get("metric_code_locations", True)
-                        ),
-                    )
-                else:
-                    logger.info(
-                        "Metrics not supported on Python 3.6 and lower with gevent."
-                    )
-
             self.log_batcher = None
 
             if has_logs_enabled(self.options):
@@ -390,6 +374,13 @@ class _Client(BaseClient):
 
                 self.log_batcher = LogBatcher(capture_func=_capture_envelope)
 
+            self.metrics_batcher = None
+
+            if has_metrics_enabled(self.options):
+                from sentry_sdk._metrics_batcher import MetricsBatcher
+
+                self.metrics_batcher = MetricsBatcher(capture_func=_capture_envelope)
+
             max_request_body_size = ("always", "never", "small", "medium")
             if self.options["max_request_body_size"] not in max_request_body_size:
                 raise ValueError(
@@ -469,7 +460,6 @@ class _Client(BaseClient):
 
         if (
             self.monitor
-            or self.metrics_aggregator
             or self.log_batcher
             or has_profiling_enabled(self.options)
             or isinstance(self.transport, BaseHttpTransport)
@@ -902,7 +892,7 @@ class _Client(BaseClient):
 
         return return_value
 
-    def _capture_experimental_log(self, log):
+    def _capture_log(self, log):
         # type: (Optional[Log]) -> None
         if not has_logs_enabled(self.options) or log is None:
             return
@@ -956,7 +946,7 @@ class _Client(BaseClient):
         debug = self.options.get("debug", False)
         if debug:
             logger.debug(
-                f'[Sentry Logs] [{log.get("severity_text")}] {log.get("body")}'
+                f"[Sentry Logs] [{log.get('severity_text')}] {log.get('body')}"
             )
 
         before_send_log = get_before_send_log(self.options)
@@ -969,8 +959,68 @@ class _Client(BaseClient):
         if self.log_batcher:
             self.log_batcher.add(log)
 
+    def _capture_metric(self, metric):
+        # type: (Optional[Metric]) -> None
+        if not has_metrics_enabled(self.options) or metric is None:
+            return
+
+        isolation_scope = sentry_sdk.get_isolation_scope()
+
+        metric["attributes"]["sentry.sdk.name"] = SDK_INFO["name"]
+        metric["attributes"]["sentry.sdk.version"] = SDK_INFO["version"]
+
+        environment = self.options.get("environment")
+        if environment is not None and "sentry.environment" not in metric["attributes"]:
+            metric["attributes"]["sentry.environment"] = environment
+
+        release = self.options.get("release")
+        if release is not None and "sentry.release" not in metric["attributes"]:
+            metric["attributes"]["sentry.release"] = release
+
+        span = sentry_sdk.get_current_span()
+        metric["trace_id"] = "00000000-0000-0000-0000-000000000000"
+
+        if span:
+            metric["trace_id"] = span.trace_id
+            metric["span_id"] = span.span_id
+        else:
+            propagation_context = isolation_scope.get_active_propagation_context()
+            if propagation_context and propagation_context.trace_id:
+                metric["trace_id"] = propagation_context.trace_id
+
+        if isolation_scope._user is not None:
+            for metric_attribute, user_attribute in (
+                ("user.id", "id"),
+                ("user.name", "username"),
+                ("user.email", "email"),
+            ):
+                if (
+                    user_attribute in isolation_scope._user
+                    and metric_attribute not in metric["attributes"]
+                ):
+                    metric["attributes"][metric_attribute] = isolation_scope._user[
+                        user_attribute
+                    ]
+
+        debug = self.options.get("debug", False)
+        if debug:
+            logger.debug(
+                f"[Sentry Metrics] [{metric.get('type')}] {metric.get('name')}: {metric.get('value')}"
+            )
+
+        before_send_metric = get_before_send_metric(self.options)
+        if before_send_metric is not None:
+            metric = before_send_metric(metric, {})
+
+        if metric is None:
+            return
+
+        if self.metrics_batcher:
+            self.metrics_batcher.add(metric)
+
     def capture_session(
-        self, session  # type: Session
+        self,
+        session,  # type: Session
     ):
         # type: (...) -> None
         if not session.release:
@@ -991,7 +1041,8 @@ class _Client(BaseClient):
             ...
 
     def get_integration(
-        self, name_or_class  # type: Union[str, Type[Integration]]
+        self,
+        name_or_class,  # type: Union[str, Type[Integration]]
     ):
         # type: (...) -> Optional[Integration]
         """Returns the integration for this client by name or class.
@@ -1019,10 +1070,10 @@ class _Client(BaseClient):
         if self.transport is not None:
             self.flush(timeout=timeout, callback=callback)
             self.session_flusher.kill()
-            if self.metrics_aggregator is not None:
-                self.metrics_aggregator.kill()
             if self.log_batcher is not None:
                 self.log_batcher.kill()
+            if self.metrics_batcher is not None:
+                self.metrics_batcher.kill()
             if self.monitor:
                 self.monitor.kill()
             self.transport.kill()
@@ -1045,10 +1096,10 @@ class _Client(BaseClient):
             if timeout is None:
                 timeout = self.options["shutdown_timeout"]
             self.session_flusher.flush()
-            if self.metrics_aggregator is not None:
-                self.metrics_aggregator.flush()
             if self.log_batcher is not None:
                 self.log_batcher.flush()
+            if self.metrics_batcher is not None:
+                self.metrics_batcher.flush()
             self.transport.flush(timeout=timeout, callback=callback)
 
     def __enter__(self):

sentry_sdk/consts.py

@@ -40,6 +40,7 @@ if TYPE_CHECKING:
     from typing import Any
     from typing import Sequence
     from typing import Tuple
+    from typing import AbstractSet
     from typing_extensions import Literal
     from typing_extensions import TypedDict
 
@@ -51,11 +52,10 @@ if TYPE_CHECKING:
         Hint,
         Log,
         MeasurementUnit,
+        Metric,
         ProfilerMode,
         TracesSampler,
         TransactionProcessor,
-        MetricTags,
-        MetricValue,
     )
 
     # Experiments are feature flags to enable and disable certain unstable SDK
@@ -76,13 +76,10 @@ if TYPE_CHECKING:
             "transport_compression_algo": Optional[CompressionAlgo],
             "transport_num_pools": Optional[int],
             "transport_http2": Optional[bool],
-            "enable_metrics": Optional[bool],
-            "before_emit_metric": Optional[
-                Callable[[str, MetricValue, MeasurementUnit, MetricTags], bool]
-            ],
-            "metric_code_locations": Optional[bool],
             "enable_logs": Optional[bool],
             "before_send_log": Optional[Callable[[Log, Hint], Optional[Log]]],
+            "enable_metrics": Optional[bool],
+            "before_send_metric": Optional[Callable[[Metric, Hint], Optional[Metric]]],
         },
         total=False,
     )
@@ -838,6 +835,7 @@ class OP:
     QUEUE_TASK_HUEY = "queue.task.huey"
     QUEUE_SUBMIT_RAY = "queue.submit.ray"
     QUEUE_TASK_RAY = "queue.task.ray"
+    QUEUE_TASK_DRAMATIQ = "queue.task.dramatiq"
     SUBPROCESS = "subprocess"
     SUBPROCESS_WAIT = "subprocess.wait"
     SUBPROCESS_COMMUNICATE = "subprocess.communicate"
@@ -852,7 +850,6 @@ class OP:
 # This type exists to trick mypy and PyCharm into thinking `init` and `Client`
 # take these arguments (even though they take opaque **kwargs)
 class ClientConstructor:
-
     def __init__(
         self,
         dsn=None,  # type: Optional[str]
@@ -920,6 +917,7 @@ class ClientConstructor:
         max_stack_frames=DEFAULT_MAX_STACK_FRAMES,  # type: Optional[int]
         enable_logs=False,  # type: bool
         before_send_log=None,  # type: Optional[Callable[[Log, Hint], Optional[Log]]]
+        trace_ignore_status_codes=frozenset(),  # type: AbstractSet[int]
     ):
         # type: (...) -> None
         """Initialize the Sentry SDK with the given parameters. All parameters described here can be used in a call to `sentry_sdk.init()`.
@@ -1308,6 +1306,14 @@ class ClientConstructor:
             function will be retained. If the function returns None, the log will
             not be sent to Sentry.
 
+        :param trace_ignore_status_codes: An optional property that disables tracing for
+            HTTP requests with certain status codes.
+
+            Requests are not traced if the status code is contained in the provided set.
+
+            If `trace_ignore_status_codes` is not provided, requests with any status code
+            may be traced.
+
         :param _experiments:
         """
         pass
@@ -1333,4 +1339,4 @@ DEFAULT_OPTIONS = _get_default_options()
 del _get_default_options
 
 
-VERSION = "2.39.0"
+VERSION = "2.41.0"