sentry-sdk 2.26.1__py2.py3-none-any.whl → 3.0.0a1__py2.py3-none-any.whl

sentry_sdk/__init__.py

@@ -1,4 +1,6 @@
-from sentry_sdk.scope import Scope
+# TODO-neel scope switch
+# TODO-neel avoid duplication between api and __init__
+from sentry_sdk.opentelemetry.scope import PotelScope as Scope
 from sentry_sdk.transport import Transport, HttpTransport
 from sentry_sdk.client import Client
 
@@ -7,7 +9,6 @@ from sentry_sdk.api import *  # noqa
 from sentry_sdk.consts import VERSION  # noqa
 
 __all__ = [  # noqa
-    "Hub",
     "Scope",
     "Client",
     "Transport",
@@ -15,11 +16,11 @@ __all__ = [  # noqa
     "integrations",
     # From sentry_sdk.api
     "init",
+    "add_attachment",
     "add_breadcrumb",
     "capture_event",
     "capture_exception",
     "capture_message",
-    "configure_scope",
     "continue_trace",
     "flush",
     "get_baggage",
@@ -33,11 +34,9 @@ __all__ = [  # noqa
     "isolation_scope",
     "last_event_id",
     "new_scope",
-    "push_scope",
     "set_context",
     "set_extra",
     "set_level",
-    "set_measurement",
     "set_tag",
     "set_tags",
     "set_user",
@@ -53,6 +52,3 @@ from sentry_sdk.debug import init_debug_support
 
 init_debug_support()
 del init_debug_support
-
-# circular imports
-from sentry_sdk.hub import Hub

sentry_sdk/_compat.py

@@ -9,7 +9,6 @@ if TYPE_CHECKING:
     T = TypeVar("T")
 
 
-PY37 = sys.version_info[0] == 3 and sys.version_info[1] >= 7
 PY38 = sys.version_info[0] == 3 and sys.version_info[1] >= 8
 PY310 = sys.version_info[0] == 3 and sys.version_info[1] >= 10
 PY311 = sys.version_info[0] == 3 and sys.version_info[1] >= 11

sentry_sdk/_init_implementation.py

@@ -1,48 +1,11 @@
-import warnings
-
 from typing import TYPE_CHECKING
 
 import sentry_sdk
+from sentry_sdk.consts import ClientConstructor
+from sentry_sdk.opentelemetry.scope import setup_scope_context_management
 
 if TYPE_CHECKING:
-    from typing import Any, ContextManager, Optional
-
-    import sentry_sdk.consts
-
-
-class _InitGuard:
-    _CONTEXT_MANAGER_DEPRECATION_WARNING_MESSAGE = (
-        "Using the return value of sentry_sdk.init as a context manager "
-        "and manually calling the __enter__ and __exit__ methods on the "
-        "return value are deprecated. We are no longer maintaining this "
-        "functionality, and we will remove it in the next major release."
-    )
-
-    def __init__(self, client):
-        # type: (sentry_sdk.Client) -> None
-        self._client = client
-
-    def __enter__(self):
-        # type: () -> _InitGuard
-        warnings.warn(
-            self._CONTEXT_MANAGER_DEPRECATION_WARNING_MESSAGE,
-            stacklevel=2,
-            category=DeprecationWarning,
-        )
-
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        # type: (Any, Any, Any) -> None
-        warnings.warn(
-            self._CONTEXT_MANAGER_DEPRECATION_WARNING_MESSAGE,
-            stacklevel=2,
-            category=DeprecationWarning,
-        )
-
-        c = self._client
-        if c is not None:
-            c.close()
+    from typing import Any, Optional
 
 
 def _check_python_deprecations():
@@ -54,16 +17,15 @@ def _check_python_deprecations():
 
 
 def _init(*args, **kwargs):
-    # type: (*Optional[str], **Any) -> ContextManager[Any]
+    # type: (*Optional[str], **Any) -> None
     """Initializes the SDK and optionally integrations.
 
     This takes the same arguments as the client constructor.
     """
+    setup_scope_context_management()
     client = sentry_sdk.Client(*args, **kwargs)
     sentry_sdk.get_global_scope().set_client(client)
     _check_python_deprecations()
-    rv = _InitGuard(client)
-    return rv
 
 
 if TYPE_CHECKING:
@@ -73,7 +35,7 @@ if TYPE_CHECKING:
     # Use `ClientConstructor` to define the argument types of `init` and
     # `ContextManager[Any]` to tell static analyzers about the return type.
 
-    class init(sentry_sdk.consts.ClientConstructor, _InitGuard):  # noqa: N801
+    class init(ClientConstructor):  # noqa: N801
         pass
 
 else:

sentry_sdk/_log_batcher.py

@@ -5,7 +5,7 @@ from datetime import datetime, timezone
 from typing import Optional, List, Callable, TYPE_CHECKING, Any
 
 from sentry_sdk.utils import format_timestamp, safe_repr
-from sentry_sdk.envelope import Envelope
+from sentry_sdk.envelope import Envelope, Item, PayloadRef
 
 if TYPE_CHECKING:
     from sentry_sdk._types import Log
@@ -97,34 +97,36 @@ class LogBatcher:
         self._flush()
 
     @staticmethod
-    def _log_to_otel(log):
+    def _log_to_transport_format(log):
         # type: (Log) -> Any
-        def format_attribute(key, val):
-            # type: (str, int | float | str | bool) -> Any
+        def format_attribute(val):
+            # type: (int | float | str | bool) -> Any
             if isinstance(val, bool):
-                return {"key": key, "value": {"boolValue": val}}
+                return {"value": val, "type": "boolean"}
             if isinstance(val, int):
-                return {"key": key, "value": {"intValue": str(val)}}
+                return {"value": val, "type": "integer"}
             if isinstance(val, float):
-                return {"key": key, "value": {"doubleValue": val}}
+                return {"value": val, "type": "double"}
             if isinstance(val, str):
-                return {"key": key, "value": {"stringValue": val}}
-            return {"key": key, "value": {"stringValue": safe_repr(val)}}
-
-        otel_log = {
-            "severityText": log["severity_text"],
-            "severityNumber": log["severity_number"],
-            "body": {"stringValue": log["body"]},
-            "timeUnixNano": str(log["time_unix_nano"]),
-            "attributes": [
-                format_attribute(k, v) for (k, v) in log["attributes"].items()
-            ],
+                return {"value": val, "type": "string"}
+            return {"value": safe_repr(val), "type": "string"}
+
+        if "sentry.severity_number" not in log["attributes"]:
+            log["attributes"]["sentry.severity_number"] = log["severity_number"]
+        if "sentry.severity_text" not in log["attributes"]:
+            log["attributes"]["sentry.severity_text"] = log["severity_text"]
+
+        res = {
+            "timestamp": int(log["time_unix_nano"]) / 1.0e9,
+            "trace_id": log.get("trace_id", "00000000-0000-0000-0000-000000000000"),
+            "level": str(log["severity_text"]),
+            "body": str(log["body"]),
+            "attributes": {
+                k: format_attribute(v) for (k, v) in log["attributes"].items()
+            },
         }
 
-        if "trace_id" in log:
-            otel_log["traceId"] = log["trace_id"]
-
-        return otel_log
+        return res
 
     def _flush(self):
         # type: (...) -> Optional[Envelope]
@@ -133,10 +135,27 @@ class LogBatcher:
             headers={"sent_at": format_timestamp(datetime.now(timezone.utc))}
         )
         with self._lock:
-            for log in self._log_buffer:
-                envelope.add_log(self._log_to_otel(log))
+            if len(self._log_buffer) == 0:
+                return None
+
+            envelope.add_item(
+                Item(
+                    type="log",
+                    content_type="application/vnd.sentry.items.log+json",
+                    headers={
+                        "item_count": len(self._log_buffer),
+                    },
+                    payload=PayloadRef(
+                        json={
+                            "items": [
+                                self._log_to_transport_format(log)
+                                for log in self._log_buffer
+                            ]
+                        }
+                    ),
+                )
+            )
             self._log_buffer.clear()
-        if envelope.items:
-            self._capture_func(envelope)
-            return envelope
-        return None
+
+        self._capture_func(envelope)
+        return envelope

sentry_sdk/_types.py

@@ -107,9 +107,7 @@ if TYPE_CHECKING:
     from typing import Callable
     from typing import Dict
     from typing import Mapping
-    from typing import NotRequired
     from typing import Optional
-    from typing import Tuple
     from typing import Type
     from typing_extensions import Literal, TypedDict
 
@@ -121,45 +119,6 @@ if TYPE_CHECKING:
     # "critical" is an alias of "fatal" recognized by Relay
     LogLevelStr = Literal["fatal", "critical", "error", "warning", "info", "debug"]
 
-    DurationUnit = Literal[
-        "nanosecond",
-        "microsecond",
-        "millisecond",
-        "second",
-        "minute",
-        "hour",
-        "day",
-        "week",
-    ]
-
-    InformationUnit = Literal[
-        "bit",
-        "byte",
-        "kilobyte",
-        "kibibyte",
-        "megabyte",
-        "mebibyte",
-        "gigabyte",
-        "gibibyte",
-        "terabyte",
-        "tebibyte",
-        "petabyte",
-        "pebibyte",
-        "exabyte",
-        "exbibyte",
-    ]
-
-    FractionUnit = Literal["ratio", "percent"]
-    MeasurementUnit = Union[DurationUnit, InformationUnit, FractionUnit, str]
-
-    MeasurementValue = TypedDict(
-        "MeasurementValue",
-        {
-            "value": float,
-            "unit": NotRequired[Optional[MeasurementUnit]],
-        },
-    )
-
     Event = TypedDict(
         "Event",
         {
@@ -181,7 +140,6 @@ if TYPE_CHECKING:
             "level": LogLevelStr,
             "logentry": Mapping[str, object],
             "logger": str,
-            "measurements": dict[str, MeasurementValue],
             "message": str,
             "modules": dict[str, str],
             "monitor_config": Mapping[str, object],
@@ -210,7 +168,6 @@ if TYPE_CHECKING:
             "type": Literal["check_in", "transaction"],
             "user": dict[str, object],
             "_dropped_spans": int,
-            "_metrics_summary": dict[str, object],
         },
         total=False,
     )
@@ -220,7 +177,9 @@ if TYPE_CHECKING:
         tuple[None, None, None],
     ]
 
+    # TODO: Make a proper type definition for this (PRs welcome!)
     Hint = Dict[str, Any]
+
     Log = TypedDict(
         "Log",
         {
@@ -233,9 +192,13 @@ if TYPE_CHECKING:
         },
     )
 
+    # TODO: Make a proper type definition for this (PRs welcome!)
     Breadcrumb = Dict[str, Any]
+
+    # TODO: Make a proper type definition for this (PRs welcome!)
     BreadcrumbHint = Dict[str, Any]
 
+    # TODO: Make a proper type definition for this (PRs welcome!)
     SamplingContext = Dict[str, Any]
 
     EventProcessor = Callable[[Event, Hint], Optional[Event]]
@@ -260,7 +223,6 @@ if TYPE_CHECKING:
         "internal",
         "profile",
         "profile_chunk",
-        "metric_bucket",
         "monitor",
         "span",
         "log",
@@ -270,26 +232,6 @@ if TYPE_CHECKING:
     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",
@@ -325,3 +267,5 @@ if TYPE_CHECKING:
     )
 
     HttpStatusCodeRange = Union[int, Container[int]]
+
+    OtelExtractedSpanData = tuple[str, str, Optional[str], Optional[int], Optional[str]]

sentry_sdk/ai/monitoring.py

@@ -33,13 +33,15 @@ def ai_track(description, **span_kwargs):
             curr_pipeline = _ai_pipeline_name.get()
             op = span_kwargs.get("op", "ai.run" if curr_pipeline else "ai.pipeline")
 
-            with start_span(name=description, op=op, **span_kwargs) as span:
+            with start_span(
+                name=description, op=op, only_if_parent=True, **span_kwargs
+            ) as span:
                 for k, v in kwargs.pop("sentry_tags", {}).items():
                     span.set_tag(k, v)
                 for k, v in kwargs.pop("sentry_data", {}).items():
-                    span.set_data(k, v)
+                    span.set_attribute(k, v)
                 if curr_pipeline:
-                    span.set_data("ai.pipeline.name", curr_pipeline)
+                    span.set_attribute("ai.pipeline.name", curr_pipeline)
                     return f(*args, **kwargs)
                 else:
                     _ai_pipeline_name.set(description)
@@ -62,13 +64,15 @@ def ai_track(description, **span_kwargs):
             curr_pipeline = _ai_pipeline_name.get()
             op = span_kwargs.get("op", "ai.run" if curr_pipeline else "ai.pipeline")
 
-            with start_span(name=description, op=op, **span_kwargs) as span:
+            with start_span(
+                name=description, op=op, only_if_parent=True, **span_kwargs
+            ) as span:
                 for k, v in kwargs.pop("sentry_tags", {}).items():
                     span.set_tag(k, v)
                 for k, v in kwargs.pop("sentry_data", {}).items():
-                    span.set_data(k, v)
+                    span.set_attribute(k, v)
                 if curr_pipeline:
-                    span.set_data("ai.pipeline.name", curr_pipeline)
+                    span.set_attribute("ai.pipeline.name", curr_pipeline)
                     return await f(*args, **kwargs)
                 else:
                     _ai_pipeline_name.set(description)
@@ -100,11 +104,11 @@ def record_token_usage(
     # type: (Span, Optional[int], Optional[int], Optional[int]) -> None
     ai_pipeline_name = get_ai_pipeline_name()
     if ai_pipeline_name:
-        span.set_data("ai.pipeline.name", ai_pipeline_name)
+        span.set_attribute("ai.pipeline.name", ai_pipeline_name)
     if prompt_tokens is not None:
-        span.set_measurement("ai_prompt_tokens_used", value=prompt_tokens)
+        span.set_attribute("ai.prompt_tokens.used", prompt_tokens)
     if completion_tokens is not None:
-        span.set_measurement("ai_completion_tokens_used", value=completion_tokens)
+        span.set_attribute("ai.completion_tokens.used", completion_tokens)
     if (
         total_tokens is None
         and prompt_tokens is not None
@@ -112,4 +116,4 @@ def record_token_usage(
     ):
         total_tokens = prompt_tokens + completion_tokens
     if total_tokens is not None:
-        span.set_measurement("ai_total_tokens_used", total_tokens)
+        span.set_attribute("ai.total_tokens.used", total_tokens)

sentry_sdk/ai/utils.py

@@ -29,4 +29,4 @@ def _normalize_data(data):
 def set_data_normalized(span, key, value):
     # type: (Span, str, Any) -> None
     normalized = _normalize_data(value)
-    span.set_data(key, normalized)
+    span.set_attribute(key, normalized)