sentry-sdk 2.27.0__tar.gz → 3.0.0a1__tar.gz

{sentry_sdk-2.27.0/sentry_sdk.egg-info → sentry_sdk-3.0.0a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry-sdk
-Version: 2.27.0
+Version: 3.0.0a1
 Summary: Python client for Sentry (https://sentry.io)
 Home-page: https://github.com/getsentry/sentry-python
 Author: Sentry Team and Contributors
@@ -15,7 +15,6 @@ Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
 Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
@@ -24,11 +23,12 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.6
+Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: urllib3>=1.26.11
 Requires-Dist: certifi
+Requires-Dist: opentelemetry-sdk>=1.4.0
 Provides-Extra: aiohttp
 Requires-Dist: aiohttp>=3.5; extra == "aiohttp"
 Provides-Extra: anthropic
@@ -85,8 +85,6 @@ Provides-Extra: openfeature
 Requires-Dist: openfeature-sdk>=0.7.1; extra == "openfeature"
 Provides-Extra: opentelemetry
 Requires-Dist: opentelemetry-distro>=0.35b0; extra == "opentelemetry"
-Provides-Extra: opentelemetry-experimental
-Requires-Dist: opentelemetry-distro; extra == "opentelemetry-experimental"
 Provides-Extra: pure-eval
 Requires-Dist: pure_eval; extra == "pure-eval"
 Requires-Dist: executing; extra == "pure-eval"

{sentry_sdk-2.27.0 → sentry_sdk-3.0.0a1}/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-2.27.0 → sentry_sdk-3.0.0a1}/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-3.0.0a1/sentry_sdk/_init_implementation.py

@@ -0,0 +1,46 @@
+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, Optional
+
+
+def _check_python_deprecations():
+    # type: () -> None
+    # Since we're likely to deprecate Python versions in the future, I'm keeping
+    # this handy function around. Use this to detect the Python version used and
+    # to output logger.warning()s if it's deprecated.
+    pass
+
+
+def _init(*args, **kwargs):
+    # 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()
+
+
+if TYPE_CHECKING:
+    # Make mypy, PyCharm and other static analyzers think `init` is a type to
+    # have nicer autocompletion for params.
+    #
+    # Use `ClientConstructor` to define the argument types of `init` and
+    # `ContextManager[Any]` to tell static analyzers about the return type.
+
+    class init(ClientConstructor):  # noqa: N801
+        pass
+
+else:
+    # Alias `init` for actual usage. Go through the lambda indirection to throw
+    # PyCharm off of the weakly typed signature (it would otherwise discover
+    # both the weakly typed signature of `_init` and our faked `init` type).
+
+    init = (lambda: _init)()

{sentry_sdk-2.27.0 → sentry_sdk-3.0.0a1}/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-2.27.0 → sentry_sdk-3.0.0a1}/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,
     )
@@ -266,7 +223,6 @@ if TYPE_CHECKING:
         "internal",
         "profile",
         "profile_chunk",
-        "metric_bucket",
         "monitor",
         "span",
         "log",
@@ -276,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",
@@ -331,3 +267,5 @@ if TYPE_CHECKING:
     )
 
     HttpStatusCodeRange = Union[int, Container[int]]
+
+    OtelExtractedSpanData = tuple[str, str, Optional[str], Optional[int], Optional[str]]

{sentry_sdk-2.27.0 → sentry_sdk-3.0.0a1}/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-2.27.0 → sentry_sdk-3.0.0a1}/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)