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

sentry_sdk/consts.py

@@ -47,12 +47,9 @@ if TYPE_CHECKING:
         Event,
         EventProcessor,
         Hint,
-        MeasurementUnit,
         ProfilerMode,
         TracesSampler,
         TransactionProcessor,
-        MetricTags,
-        MetricValue,
     )
 
     # Experiments are feature flags to enable and disable certain unstable SDK
@@ -73,11 +70,6 @@ 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],
         },
         total=False,
@@ -96,11 +88,6 @@ FALSE_VALUES = [
 ]
 
 
-class INSTRUMENTER:
-    SENTRY = "sentry"
-    OTEL = "otel"
-
-
 class SPANDATA:
     """
     Additional information describing the type of the span.
@@ -174,7 +161,7 @@ class SPANDATA:
 
     AI_TOOL_CALLS = "ai.tool_calls"
     """
-    For an AI model call, the function that was called. This is deprecated for OpenAI, and replaced by tool_calls
+    For an AI model call, the function that was called.
     """
 
     AI_TOOLS = "ai.tools"
@@ -491,6 +478,46 @@ class OP:
     SOCKET_DNS = "socket.dns"
 
 
+BAGGAGE_HEADER_NAME = "baggage"
+SENTRY_TRACE_HEADER_NAME = "sentry-trace"
+
+DEFAULT_SPAN_ORIGIN = "manual"
+DEFAULT_SPAN_NAME = "<unlabeled span>"
+
+
+# Transaction source
+# see https://develop.sentry.dev/sdk/event-payloads/transaction/#transaction-annotations
+class TransactionSource(str, Enum):
+    COMPONENT = "component"
+    CUSTOM = "custom"
+    ROUTE = "route"
+    TASK = "task"
+    URL = "url"
+    VIEW = "view"
+
+    def __str__(self):
+        # type: () -> str
+        return self.value
+
+
+# These are typically high cardinality and the server hates them
+LOW_QUALITY_TRANSACTION_SOURCES = [
+    TransactionSource.URL,
+]
+
+SOURCE_FOR_STYLE = {
+    "endpoint": TransactionSource.COMPONENT,
+    "function_name": TransactionSource.COMPONENT,
+    "handler_name": TransactionSource.COMPONENT,
+    "method_and_path_pattern": TransactionSource.ROUTE,
+    "path": TransactionSource.URL,
+    "route_name": TransactionSource.COMPONENT,
+    "route_pattern": TransactionSource.ROUTE,
+    "uri_template": TransactionSource.ROUTE,
+    "url": TransactionSource.ROUTE,
+}
+
+
 # This type exists to trick mypy and PyCharm into thinking `init` and `Client`
 # take these arguments (even though they take opaque **kwargs)
 class ClientConstructor:
@@ -524,7 +551,6 @@ class ClientConstructor:
         debug=None,  # type: Optional[bool]
         attach_stacktrace=False,  # type: bool
         ca_certs=None,  # type: Optional[str]
-        propagate_traces=True,  # type: bool
         traces_sample_rate=None,  # type: Optional[float]
         traces_sampler=None,  # type: Optional[TracesSampler]
         profiles_sample_rate=None,  # type: Optional[float]
@@ -538,10 +564,8 @@ class ClientConstructor:
         send_client_reports=True,  # type: bool
         _experiments={},  # type: Experiments  # noqa: B006
         proxy_headers=None,  # type: Optional[Dict[str, str]]
-        instrumenter=INSTRUMENTER.SENTRY,  # type: Optional[str]
         before_send_transaction=None,  # type: Optional[TransactionProcessor]
         project_root=None,  # type: Optional[str]
-        enable_tracing=None,  # type: Optional[bool]
         include_local_variables=True,  # type: Optional[bool]
         include_source_context=True,  # type: Optional[bool]
         trace_propagation_targets=[  # noqa: B006
@@ -930,11 +954,6 @@ class ClientConstructor:
 
         :param profile_session_sample_rate:
 
-
-        :param enable_tracing:
-
-        :param propagate_traces:
-
         :param auto_session_tracking:
 
         :param spotlight:
@@ -966,4 +985,4 @@ DEFAULT_OPTIONS = _get_default_options()
 del _get_default_options
 
 
-VERSION = "2.27.0"
+VERSION = "3.0.0a1"

sentry_sdk/debug.py

@@ -1,6 +1,5 @@
 import sys
 import logging
-import warnings
 
 from sentry_sdk import get_client
 from sentry_sdk.client import _client_init_debug
@@ -30,12 +29,3 @@ def configure_logger():
     logger.addHandler(_handler)
     logger.setLevel(logging.DEBUG)
     logger.addFilter(_DebugFilter())
-
-
-def configure_debug_hub():
-    # type: () -> None
-    warnings.warn(
-        "configure_debug_hub is deprecated. Please remove calls to it, as it is a no-op.",
-        DeprecationWarning,
-        stacklevel=2,
-    )

sentry_sdk/envelope.py

@@ -106,12 +106,6 @@ class Envelope:
         # type: (...) -> None
         self.add_item(Item(payload=PayloadRef(json=sessions), type="sessions"))
 
-    def add_log(
-        self, log  # type: Any
-    ):
-        # type: (...) -> None
-        self.add_item(Item(payload=PayloadRef(json=log), type="otel_log"))
-
     def add_item(
         self, item  # type: Item
     ):
@@ -278,7 +272,7 @@ class Item:
             return "transaction"
         elif ty == "event":
             return "error"
-        elif ty == "otel_log":
+        elif ty == "log":
             return "log"
         elif ty == "client_report":
             return "internal"
@@ -286,8 +280,6 @@ class Item:
             return "profile"
         elif ty == "profile_chunk":
             return "profile_chunk"
-        elif ty == "statsd":
-            return "metric_bucket"
         elif ty == "check_in":
             return "monitor"
         else:
@@ -347,7 +339,7 @@ class Item:
             # if no length was specified we need to read up to the end of line
             # and remove it (if it is present, i.e. not the very last char in an eof terminated envelope)
             payload = f.readline().rstrip(b"\n")
-        if headers.get("type") in ("event", "transaction", "metric_buckets"):
+        if headers.get("type") in ("event", "transaction"):
             rv = cls(headers=headers, payload=PayloadRef(json=parse_json(payload)))
         else:
             rv = cls(headers=headers, payload=payload)

sentry_sdk/feature_flags.py

@@ -64,9 +64,9 @@ def add_feature_flag(flag, result):
     Records a flag and its value to be sent on subsequent error events.
     We recommend you do this on flag evaluations. Flags are buffered per Sentry scope.
     """
-    flags = sentry_sdk.get_current_scope().flags
+    flags = sentry_sdk.get_isolation_scope().flags
     flags.set(flag, result)
 
     span = sentry_sdk.get_current_span()
     if span:
-        span.set_flag(f"flag.evaluation.{flag}", result)
+        span.set_flag(flag, result)

sentry_sdk/integrations/__init__.py

@@ -131,10 +131,11 @@ _MIN_VERSIONS = {
     "celery": (4, 4, 7),
     "chalice": (1, 16, 0),
     "clickhouse_driver": (0, 2, 0),
+    "common": (1, 4, 0),  # opentelemetry-sdk
     "cohere": (5, 4, 0),
-    "django": (1, 8),
+    "django": (2, 0),
     "dramatiq": (1, 9),
-    "falcon": (1, 4),
+    "falcon": (3, 0),
     "fastapi": (0, 79, 0),
     "flask": (1, 1, 4),
     "gql": (3, 4, 1),
@@ -157,6 +158,7 @@ _MIN_VERSIONS = {
     "statsig": (0, 55, 3),
     "strawberry": (0, 209, 5),
     "tornado": (6, 0),
+    "trytond": (5, 0),
     "typer": (0, 15),
     "unleash": (6, 0, 1),
 }

sentry_sdk/integrations/_asgi_common.py

@@ -21,7 +21,7 @@ def _get_headers(asgi_scope):
     Extract headers from the ASGI scope, in the format that the Sentry protocol expects.
     """
     headers = {}  # type: Dict[str, str]
-    for raw_key, raw_value in asgi_scope["headers"]:
+    for raw_key, raw_value in asgi_scope.get("headers", {}):
         key = raw_key.decode("latin-1")
         value = raw_value.decode("latin-1")
         if key in headers:
@@ -32,8 +32,8 @@ def _get_headers(asgi_scope):
     return headers
 
 
-def _get_url(asgi_scope, default_scheme, host):
-    # type: (Dict[str, Any], Literal["ws", "http"], Optional[Union[AnnotatedValue, str]]) -> str
+def _get_url(asgi_scope, default_scheme=None, host=None):
+    # type: (Dict[str, Any], Optional[Literal["ws", "http"]], Optional[Union[AnnotatedValue, str]]) -> str
     """
     Extract URL from the ASGI scope, without also including the querystring.
     """

sentry_sdk/integrations/_wsgi_common.py

@@ -1,10 +1,9 @@
-from contextlib import contextmanager
 import json
 from copy import deepcopy
 
 import sentry_sdk
 from sentry_sdk.scope import should_send_default_pii
-from sentry_sdk.utils import AnnotatedValue, logger
+from sentry_sdk.utils import AnnotatedValue, SENSITIVE_DATA_SUBSTITUTE
 
 try:
     from django.http.request import RawPostDataException
@@ -16,12 +15,11 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from typing import Any
     from typing import Dict
-    from typing import Iterator
     from typing import Mapping
     from typing import MutableMapping
     from typing import Optional
     from typing import Union
-    from sentry_sdk._types import Event, HttpStatusCodeRange
+    from sentry_sdk._types import Event
 
 
 SENSITIVE_ENV_KEYS = (
@@ -52,13 +50,6 @@ DEFAULT_HTTP_METHODS_TO_CAPTURE = (
 )
 
 
-# This noop context manager can be replaced with "from contextlib import nullcontext" when we drop Python 3.6 support
-@contextmanager
-def nullcontext():
-    # type: () -> Iterator[None]
-    yield
-
-
 def request_body_within_bounds(client, content_length):
     # type: (Optional[sentry_sdk.client.BaseClient], int) -> bool
     if client is None:
@@ -237,35 +228,15 @@ def _filter_headers(headers):
     }
 
 
-def _in_http_status_code_range(code, code_ranges):
-    # type: (object, list[HttpStatusCodeRange]) -> bool
-    for target in code_ranges:
-        if isinstance(target, int):
-            if code == target:
-                return True
-            continue
-
-        try:
-            if code in target:
-                return True
-        except TypeError:
-            logger.warning(
-                "failed_request_status_codes has to be a list of integers or containers"
-            )
-
-    return False
-
+def _request_headers_to_span_attributes(headers):
+    # type: (dict[str, str]) -> dict[str, str]
+    attributes = {}
 
-class HttpCodeRangeContainer:
-    """
-    Wrapper to make it possible to use list[HttpStatusCodeRange] as a Container[int].
-    Used for backwards compatibility with the old `failed_request_status_codes` option.
-    """
+    headers = _filter_headers(headers)
 
-    def __init__(self, code_ranges):
-        # type: (list[HttpStatusCodeRange]) -> None
-        self._code_ranges = code_ranges
+    for header, value in headers.items():
+        if isinstance(value, AnnotatedValue):
+            value = SENSITIVE_DATA_SUBSTITUTE
+        attributes[f"http.request.header.{header.lower()}"] = value
 
-    def __contains__(self, item):
-        # type: (object) -> bool
-        return _in_http_status_code_range(item, self._code_ranges)
+    return attributes

sentry_sdk/integrations/aiohttp.py

@@ -3,8 +3,14 @@ import weakref
 from functools import wraps
 
 import sentry_sdk
-from sentry_sdk.api import continue_trace
-from sentry_sdk.consts import OP, SPANSTATUS, SPANDATA
+from sentry_sdk.consts import (
+    OP,
+    SPANSTATUS,
+    SPANDATA,
+    BAGGAGE_HEADER_NAME,
+    SOURCE_FOR_STYLE,
+    TransactionSource,
+)
 from sentry_sdk.integrations import (
     _DEFAULT_FAILED_REQUEST_STATUS_CODES,
     _check_minimum_version,
@@ -15,22 +21,20 @@ from sentry_sdk.integrations.logging import ignore_logger
 from sentry_sdk.sessions import track_session
 from sentry_sdk.integrations._wsgi_common import (
     _filter_headers,
+    _request_headers_to_span_attributes,
     request_body_within_bounds,
 )
-from sentry_sdk.tracing import (
-    BAGGAGE_HEADER_NAME,
-    SOURCE_FOR_STYLE,
-    TransactionSource,
-)
 from sentry_sdk.tracing_utils import should_propagate_trace
 from sentry_sdk.utils import (
     capture_internal_exceptions,
     ensure_integration_enabled,
     event_from_exception,
+    http_client_status_to_breadcrumb_level,
     logger,
     parse_url,
     parse_version,
     reraise,
+    set_thread_info_from_span,
     transaction_from_function,
     HAS_REAL_CONTEXTVARS,
     CONTEXTVARS_ERROR_MESSAGE,
@@ -67,6 +71,13 @@ if TYPE_CHECKING:
 
 TRANSACTION_STYLE_VALUES = ("handler_name", "method_and_path_pattern")
 
+REQUEST_PROPERTY_TO_ATTRIBUTE = {
+    "query_string": "url.query",
+    "method": "http.request.method",
+    "scheme": "url.scheme",
+    "path": "url.path",
+}
+
 
 class AioHttpIntegration(Integration):
     identifier = "aiohttp"
@@ -123,51 +134,38 @@ class AioHttpIntegration(Integration):
                     scope.add_event_processor(_make_request_processor(weak_request))
 
                     headers = dict(request.headers)
-                    transaction = continue_trace(
-                        headers,
-                        op=OP.HTTP_SERVER,
-                        # If this transaction name makes it to the UI, AIOHTTP's
-                        # URL resolver did not find a route or died trying.
-                        name="generic AIOHTTP request",
-                        source=TransactionSource.ROUTE,
-                        origin=AioHttpIntegration.origin,
-                    )
-                    with sentry_sdk.start_transaction(
-                        transaction,
-                        custom_sampling_context={"aiohttp_request": request},
-                    ):
-                        try:
-                            response = await old_handle(self, request)
-                        except HTTPException as e:
-                            transaction.set_http_status(e.status_code)
-
-                            if (
-                                e.status_code
-                                in integration._failed_request_status_codes
-                            ):
-                                _capture_exception()
-
-                            raise
-                        except (asyncio.CancelledError, ConnectionResetError):
-                            transaction.set_status(SPANSTATUS.CANCELLED)
-                            raise
-                        except Exception:
-                            # This will probably map to a 500 but seems like we
-                            # have no way to tell. Do not set span status.
-                            reraise(*_capture_exception())
-
-                        try:
-                            # A valid response handler will return a valid response with a status. But, if the handler
-                            # returns an invalid response (e.g. None), the line below will raise an AttributeError.
-                            # Even though this is likely invalid, we need to handle this case to ensure we don't break
-                            # the application.
-                            response_status = response.status
-                        except AttributeError:
-                            pass
-                        else:
-                            transaction.set_http_status(response_status)
-
-                        return response
+                    with sentry_sdk.continue_trace(headers):
+                        with sentry_sdk.start_span(
+                            op=OP.HTTP_SERVER,
+                            # If this transaction name makes it to the UI, AIOHTTP's
+                            # URL resolver did not find a route or died trying.
+                            name="generic AIOHTTP request",
+                            source=TransactionSource.ROUTE,
+                            origin=AioHttpIntegration.origin,
+                            attributes=_prepopulate_attributes(request),
+                        ) as span:
+                            try:
+                                response = await old_handle(self, request)
+                            except HTTPException as e:
+                                span.set_http_status(e.status_code)
+
+                                if (
+                                    e.status_code
+                                    in integration._failed_request_status_codes
+                                ):
+                                    _capture_exception()
+
+                                raise
+                            except (asyncio.CancelledError, ConnectionResetError):
+                                span.set_status(SPANSTATUS.CANCELLED)
+                                raise
+                            except Exception:
+                                # This will probably map to a 500 but seems like we
+                                # have no way to tell. Do not set span status.
+                                reraise(*_capture_exception())
+
+                            span.set_http_status(response.status)
+                            return response
 
         Application._handle = sentry_app_handle
 
@@ -238,12 +236,21 @@ def create_trace_config():
             name="%s %s"
             % (method, parsed_url.url if parsed_url else SENSITIVE_DATA_SUBSTITUTE),
             origin=AioHttpIntegration.origin,
+            only_if_parent=True,
         )
-        span.set_data(SPANDATA.HTTP_METHOD, method)
+
+        data = {
+            SPANDATA.HTTP_METHOD: method,
+        }
+        set_thread_info_from_span(data, span)
+
         if parsed_url is not None:
-            span.set_data("url", parsed_url.url)
-            span.set_data(SPANDATA.HTTP_QUERY, parsed_url.query)
-            span.set_data(SPANDATA.HTTP_FRAGMENT, parsed_url.fragment)
+            data["url"] = parsed_url.url
+            data[SPANDATA.HTTP_QUERY] = parsed_url.query
+            data[SPANDATA.HTTP_FRAGMENT] = parsed_url.fragment
+
+        for key, value in data.items():
+            span.set_attribute(key, value)
 
         client = sentry_sdk.get_client()
 
@@ -268,15 +275,28 @@ def create_trace_config():
                     params.headers[key] = value
 
         trace_config_ctx.span = span
+        trace_config_ctx.span_data = data
 
     async def on_request_end(session, trace_config_ctx, params):
         # type: (ClientSession, SimpleNamespace, TraceRequestEndParams) -> None
         if trace_config_ctx.span is None:
             return
 
+        span_data = trace_config_ctx.span_data or {}
+        status_code = int(params.response.status)
+        span_data[SPANDATA.HTTP_STATUS_CODE] = status_code
+        span_data["reason"] = params.response.reason
+
+        sentry_sdk.add_breadcrumb(
+            type="http",
+            category="httplib",
+            data=span_data,
+            level=http_client_status_to_breadcrumb_level(status_code),
+        )
+
         span = trace_config_ctx.span
         span.set_http_status(int(params.response.status))
-        span.set_data("reason", params.response.reason)
+        span.set_attribute("reason", params.response.reason)
         span.finish()
 
     trace_config = TraceConfig()
@@ -355,3 +375,30 @@ def get_aiohttp_request_data(request):
 
     # request has no body
     return None
+
+
+def _prepopulate_attributes(request):
+    # type: (Request) -> dict[str, Any]
+    """Construct initial span attributes that can be used in traces sampler."""
+    attributes = {}
+
+    for prop, attr in REQUEST_PROPERTY_TO_ATTRIBUTE.items():
+        if getattr(request, prop, None) is not None:
+            attributes[attr] = getattr(request, prop)
+
+    if getattr(request, "host", None) is not None:
+        try:
+            host, port = request.host.split(":")
+            attributes["server.address"] = host
+            attributes["server.port"] = port
+        except ValueError:
+            attributes["server.address"] = request.host
+
+    with capture_internal_exceptions():
+        url = f"{request.scheme}://{request.host}{request.path}"  # noqa: E231
+        if request.query_string:
+            attributes["url.full"] = f"{url}?{request.query_string}"
+
+    attributes.update(_request_headers_to_span_attributes(dict(request.headers)))
+
+    return attributes

sentry_sdk/integrations/anthropic.py

@@ -121,13 +121,13 @@ def _add_ai_data_to_span(
     with capture_internal_exceptions():
         if should_send_default_pii() and integration.include_prompts:
             complete_message = "".join(content_blocks)
-            span.set_data(
+            span.set_attribute(
                 SPANDATA.AI_RESPONSES,
                 [{"type": "text", "text": complete_message}],
             )
         total_tokens = input_tokens + output_tokens
         record_token_usage(span, input_tokens, output_tokens, total_tokens)
-        span.set_data(SPANDATA.AI_STREAMING, True)
+        span.set_attribute(SPANDATA.AI_STREAMING, True)
 
 
 def _sentry_patched_create_common(f, *args, **kwargs):
@@ -148,6 +148,7 @@ def _sentry_patched_create_common(f, *args, **kwargs):
         op=OP.ANTHROPIC_MESSAGES_CREATE,
         description="Anthropic messages create",
         origin=AnthropicIntegration.origin,
+        only_if_parent=True,
     )
     span.__enter__()
 
@@ -158,15 +159,17 @@ def _sentry_patched_create_common(f, *args, **kwargs):
     model = kwargs.get("model")
 
     with capture_internal_exceptions():
-        span.set_data(SPANDATA.AI_MODEL_ID, model)
-        span.set_data(SPANDATA.AI_STREAMING, False)
+        span.set_attribute(SPANDATA.AI_MODEL_ID, model)
+        span.set_attribute(SPANDATA.AI_STREAMING, False)
 
         if should_send_default_pii() and integration.include_prompts:
-            span.set_data(SPANDATA.AI_INPUT_MESSAGES, messages)
+            span.set_attribute(SPANDATA.AI_INPUT_MESSAGES, messages)
 
         if hasattr(result, "content"):
             if should_send_default_pii() and integration.include_prompts:
-                span.set_data(SPANDATA.AI_RESPONSES, _get_responses(result.content))
+                span.set_attribute(
+                    SPANDATA.AI_RESPONSES, _get_responses(result.content)
+                )
             _calculate_token_usage(result, span)
             span.__exit__(None, None, None)
 
@@ -214,7 +217,7 @@ def _sentry_patched_create_common(f, *args, **kwargs):
                 result._iterator = new_iterator()
 
         else:
-            span.set_data("unknown_response", True)
+            span.set_attribute("unknown_response", True)
             span.__exit__(None, None, None)
 
     return result