sentry-sdk 3.0.0a1__py2.py3-none-any.whl → 3.0.0a3__py2.py3-none-any.whl

sentry_sdk/opentelemetry/tracing.py

@@ -1,35 +1,79 @@
+from __future__ import annotations
 from opentelemetry import trace
 from opentelemetry.propagate import set_global_textmap
+from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider, Span, ReadableSpan
 
+from sentry_sdk.consts import VERSION
 from sentry_sdk.opentelemetry import (
     SentryPropagator,
     SentrySampler,
     SentrySpanProcessor,
 )
+from sentry_sdk.opentelemetry.consts import (
+    RESOURCE_SERVICE_NAME,
+    RESOURCE_SERVICE_NAMESPACE,
+    RESOURCE_SERVICE_VERSION,
+)
+from sentry_sdk.utils import logger
+
 
+READABLE_SPAN_PATCHED = False
 
-def patch_readable_span():
-    # type: () -> None
+
+def patch_readable_span() -> None:
     """
     We need to pass through sentry specific metadata/objects from Span to ReadableSpan
     to work with them consistently in the SpanProcessor.
     """
-    old_readable_span = Span._readable_span
+    global READABLE_SPAN_PATCHED
+    if not READABLE_SPAN_PATCHED:
+        old_readable_span = Span._readable_span
+
+        def sentry_patched_readable_span(self: Span) -> ReadableSpan:
+            readable_span = old_readable_span(self)
+            readable_span._sentry_meta = getattr(self, "_sentry_meta", {})  # type: ignore[attr-defined]
+            return readable_span
+
+        Span._readable_span = sentry_patched_readable_span  # type: ignore[method-assign]
+        READABLE_SPAN_PATCHED = True
+
+
+def setup_sentry_tracing() -> None:
+    # TracerProvider can only be set once. If we're the first ones setting it,
+    # there's no issue. If it already exists, we need to patch it.
+    from opentelemetry.trace import _TRACER_PROVIDER
 
-    def sentry_patched_readable_span(self):
-        # type: (Span) -> ReadableSpan
-        readable_span = old_readable_span(self)
-        readable_span._sentry_meta = getattr(self, "_sentry_meta", {})  # type: ignore[attr-defined]
-        return readable_span
+    if _TRACER_PROVIDER is not None:
+        logger.debug("[Tracing] Detected an existing TracerProvider, patching")
+        tracer_provider = _TRACER_PROVIDER
+        tracer_provider.sampler = SentrySampler()  # type: ignore[attr-defined]
 
-    Span._readable_span = sentry_patched_readable_span  # type: ignore[method-assign]
+    else:
+        logger.debug("[Tracing] No TracerProvider set, creating a new one")
+        tracer_provider = TracerProvider(
+            sampler=SentrySampler(),
+            resource=Resource.create(
+                {
+                    RESOURCE_SERVICE_NAME: "sentry-python",
+                    RESOURCE_SERVICE_VERSION: VERSION,
+                    RESOURCE_SERVICE_NAMESPACE: "sentry",
+                }
+            ),
+        )
+        trace.set_tracer_provider(tracer_provider)
 
+    try:
+        existing_span_processors = (
+            tracer_provider._active_span_processor._span_processors  # type: ignore[attr-defined]
+        )
+    except Exception:
+        existing_span_processors = []
 
-def setup_sentry_tracing():
-    # type: () -> None
-    provider = TracerProvider(sampler=SentrySampler())
-    provider.add_span_processor(SentrySpanProcessor())
-    trace.set_tracer_provider(provider)
+    for span_processor in existing_span_processors:
+        if isinstance(span_processor, SentrySpanProcessor):
+            break
+    else:
+        tracer_provider.add_span_processor(SentrySpanProcessor())  # type: ignore[attr-defined]
 
     set_global_textmap(SentryPropagator())

sentry_sdk/opentelemetry/utils.py

@@ -1,6 +1,7 @@
+from __future__ import annotations
 import re
-from typing import cast
 from datetime import datetime, timezone
+from dataclasses import dataclass
 
 from urllib3.util import parse_url as urlparse
 from urllib.parse import quote, unquote
@@ -30,8 +31,10 @@ from sentry_sdk.tracing_utils import Baggage, get_span_status_from_http_code
 from sentry_sdk._types import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import Any, Optional, Mapping, Sequence, Union
-    from sentry_sdk._types import OtelExtractedSpanData
+    from typing import Any, Optional, Union, Type, TypeVar
+    from opentelemetry.util.types import Attributes
+
+    T = TypeVar("T")
 
 
 GRPC_ERROR_MAP = {
@@ -54,8 +57,7 @@ GRPC_ERROR_MAP = {
 }
 
 
-def is_sentry_span(span):
-    # type: (ReadableSpan) -> bool
+def is_sentry_span(span: ReadableSpan) -> bool:
     """
     Break infinite loop:
     HTTP requests to Sentry are caught by OTel and send again to Sentry.
@@ -65,10 +67,8 @@ def is_sentry_span(span):
     if not span.attributes:
         return False
 
-    span_url = span.attributes.get(SpanAttributes.HTTP_URL, None)
-    span_url = cast("Optional[str]", span_url)
-
-    if not span_url:
+    span_url = get_typed_attribute(span.attributes, SpanAttributes.HTTP_URL, str)
+    if span_url is None:
         return False
 
     dsn_url = None
@@ -89,201 +89,184 @@ def is_sentry_span(span):
     return False
 
 
-def convert_from_otel_timestamp(time):
-    # type: (int) -> datetime
+def convert_from_otel_timestamp(time: int) -> datetime:
     """Convert an OTel nanosecond-level timestamp to a datetime."""
     return datetime.fromtimestamp(time / 1e9, timezone.utc)
 
 
-def convert_to_otel_timestamp(time):
-    # type: (Union[datetime, float]) -> int
+def convert_to_otel_timestamp(time: Union[datetime, float]) -> int:
     """Convert a datetime to an OTel timestamp (with nanosecond precision)."""
     if isinstance(time, datetime):
         return int(time.timestamp() * 1e9)
     return int(time * 1e9)
 
 
-def extract_transaction_name_source(span):
-    # type: (ReadableSpan) -> tuple[Optional[str], Optional[str]]
+def extract_transaction_name_source(
+    span: ReadableSpan,
+) -> tuple[Optional[str], Optional[str]]:
     if not span.attributes:
         return (None, None)
     return (
-        cast("Optional[str]", span.attributes.get(SentrySpanAttribute.NAME)),
-        cast("Optional[str]", span.attributes.get(SentrySpanAttribute.SOURCE)),
+        get_typed_attribute(span.attributes, SentrySpanAttribute.NAME, str),
+        get_typed_attribute(span.attributes, SentrySpanAttribute.SOURCE, str),
     )
 
 
-def extract_span_data(span):
-    # type: (ReadableSpan) -> OtelExtractedSpanData
-    op = span.name
-    description = span.name
-    status, http_status = extract_span_status(span)
-    origin = None
-    if span.attributes is None:
-        return (op, description, status, http_status, origin)
+@dataclass
+class ExtractedSpanData:
+    description: str
+    op: Optional[str] = None
+    status: Optional[str] = None
+    http_status: Optional[int] = None
+    origin: Optional[str] = None
 
-    attribute_op = cast("Optional[str]", span.attributes.get(SentrySpanAttribute.OP))
-    op = attribute_op or op
-    description = cast(
-        "str", span.attributes.get(SentrySpanAttribute.DESCRIPTION) or description
+
+def extract_span_data(span: ReadableSpan) -> ExtractedSpanData:
+    """
+    Try to populate sane values for op, description and statuses based on what we have.
+    The op and description mapping is fundamentally janky because otel only has a single `name`.
+
+    Priority is given first to attributes explicitly defined by us via the SDK.
+    Otherwise we try to infer sane values from other attributes.
+    """
+    op = get_typed_attribute(span.attributes, SentrySpanAttribute.OP, str) or infer_op(
+        span
     )
-    origin = cast("Optional[str]", span.attributes.get(SentrySpanAttribute.ORIGIN))
-
-    http_method = span.attributes.get(SpanAttributes.HTTP_METHOD)
-    http_method = cast("Optional[str]", http_method)
-    if http_method:
-        return span_data_for_http_method(span)
-
-    db_query = span.attributes.get(SpanAttributes.DB_SYSTEM)
-    if db_query:
-        return span_data_for_db_query(span)
-
-    rpc_service = span.attributes.get(SpanAttributes.RPC_SERVICE)
-    if rpc_service:
-        return (
-            attribute_op or "rpc",
-            description,
-            status,
-            http_status,
-            origin,
-        )
 
-    messaging_system = span.attributes.get(SpanAttributes.MESSAGING_SYSTEM)
-    if messaging_system:
-        return (
-            attribute_op or "message",
-            description,
-            status,
-            http_status,
-            origin,
-        )
+    description = (
+        get_typed_attribute(span.attributes, SentrySpanAttribute.DESCRIPTION, str)
+        or get_typed_attribute(span.attributes, SentrySpanAttribute.NAME, str)
+        or infer_description(span)
+    )
 
-    faas_trigger = span.attributes.get(SpanAttributes.FAAS_TRIGGER)
-    if faas_trigger:
-        return (str(faas_trigger), description, status, http_status, origin)
+    origin = get_typed_attribute(span.attributes, SentrySpanAttribute.ORIGIN, str)
 
-    return (op, description, status, http_status, origin)
+    (status, http_status) = extract_span_status(span)
 
+    return ExtractedSpanData(
+        description=description or span.name,
+        op=op,
+        status=status,
+        http_status=http_status,
+        origin=origin,
+    )
 
-def span_data_for_http_method(span):
-    # type: (ReadableSpan) -> OtelExtractedSpanData
-    span_attributes = span.attributes or {}
 
-    op = cast("Optional[str]", span_attributes.get(SentrySpanAttribute.OP))
-    if op is None:
-        op = "http"
+def infer_op(span: ReadableSpan) -> Optional[str]:
+    """
+    Try to infer op for the various types of instrumentation.
+    """
+    if span.attributes is None:
+        return None
 
+    if SpanAttributes.HTTP_METHOD in span.attributes:
         if span.kind == SpanKind.SERVER:
-            op += ".server"
+            return OP.HTTP_SERVER
         elif span.kind == SpanKind.CLIENT:
-            op += ".client"
+            return OP.HTTP_CLIENT
+        else:
+            return OP.HTTP
+    elif SpanAttributes.DB_SYSTEM in span.attributes:
+        return OP.DB
+    elif SpanAttributes.RPC_SERVICE in span.attributes:
+        return OP.RPC
+    elif SpanAttributes.MESSAGING_SYSTEM in span.attributes:
+        return OP.MESSAGE
+    elif SpanAttributes.FAAS_TRIGGER in span.attributes:
+        return get_typed_attribute(span.attributes, SpanAttributes.FAAS_TRIGGER, str)
+    else:
+        return None
 
-    http_method = span_attributes.get(SpanAttributes.HTTP_METHOD)
-    route = span_attributes.get(SpanAttributes.HTTP_ROUTE)
-    target = span_attributes.get(SpanAttributes.HTTP_TARGET)
-    peer_name = span_attributes.get(SpanAttributes.NET_PEER_NAME)
 
-    # TODO-neel-potel remove description completely
-    description = span_attributes.get(
-        SentrySpanAttribute.DESCRIPTION
-    ) or span_attributes.get(SentrySpanAttribute.NAME)
-    description = cast("Optional[str]", description)
-    if description is None:
-        description = f"{http_method}"
+def infer_description(span: ReadableSpan) -> Optional[str]:
+    if span.attributes is None:
+        return None
+
+    if SpanAttributes.HTTP_METHOD in span.attributes:
+        http_method = get_typed_attribute(
+            span.attributes, SpanAttributes.HTTP_METHOD, str
+        )
+        route = get_typed_attribute(span.attributes, SpanAttributes.HTTP_ROUTE, str)
+        target = get_typed_attribute(span.attributes, SpanAttributes.HTTP_TARGET, str)
+        peer_name = get_typed_attribute(
+            span.attributes, SpanAttributes.NET_PEER_NAME, str
+        )
+        url = get_typed_attribute(span.attributes, SpanAttributes.HTTP_URL, str)
 
         if route:
-            description = f"{http_method} {route}"
+            return f"{http_method} {route}"
         elif target:
-            description = f"{http_method} {target}"
+            return f"{http_method} {target}"
         elif peer_name:
-            description = f"{http_method} {peer_name}"
+            return f"{http_method} {peer_name}"
+        elif url:
+            parsed_url = urlparse(url)
+            url = "{}://{}{}".format(
+                parsed_url.scheme, parsed_url.netloc, parsed_url.path
+            )
+            return f"{http_method} {url}"
         else:
-            url = span_attributes.get(SpanAttributes.HTTP_URL)
-            url = cast("Optional[str]", url)
-
-            if url:
-                parsed_url = urlparse(url)
-                url = "{}://{}{}".format(
-                    parsed_url.scheme, parsed_url.netloc, parsed_url.path
-                )
-                description = f"{http_method} {url}"
-
-    status, http_status = extract_span_status(span)
-
-    origin = cast("Optional[str]", span_attributes.get(SentrySpanAttribute.ORIGIN))
-
-    return (op, description, status, http_status, origin)
-
-
-def span_data_for_db_query(span):
-    # type: (ReadableSpan) -> OtelExtractedSpanData
-    span_attributes = span.attributes or {}
-
-    op = cast("str", span_attributes.get(SentrySpanAttribute.OP, OP.DB))
-
-    statement = span_attributes.get(SpanAttributes.DB_STATEMENT, None)
-    statement = cast("Optional[str]", statement)
-
-    description = statement or span.name
-    origin = cast("Optional[str]", span_attributes.get(SentrySpanAttribute.ORIGIN))
-
-    return (op, description, None, None, origin)
-
-
-def extract_span_status(span):
-    # type: (ReadableSpan) -> tuple[Optional[str], Optional[int]]
-    span_attributes = span.attributes or {}
-    status = span.status or None
-
-    if status:
-        inferred_status, http_status = infer_status_from_attributes(span_attributes)
-
-        if status.status_code == StatusCode.OK:
-            return (SPANSTATUS.OK, http_status)
-        elif status.status_code == StatusCode.ERROR:
-            if status.description is None:
-                if inferred_status:
-                    return (inferred_status, http_status)
-
-            if http_status is not None:
-                return (inferred_status, http_status)
-
-            if (
-                status.description is not None
-                and status.description in GRPC_ERROR_MAP.values()
-            ):
-                return (status.description, None)
-            else:
-                return (SPANSTATUS.UNKNOWN_ERROR, None)
+            return http_method
+    elif SpanAttributes.DB_SYSTEM in span.attributes:
+        return get_typed_attribute(span.attributes, SpanAttributes.DB_STATEMENT, str)
+    else:
+        return None
 
-    inferred_status, http_status = infer_status_from_attributes(span_attributes)
-    if inferred_status:
-        return (inferred_status, http_status)
 
-    if status and status.status_code == StatusCode.UNSET:
-        return (None, None)
+def extract_span_status(span: ReadableSpan) -> tuple[Optional[str], Optional[int]]:
+    """
+    Extract a reasonable Sentry SPANSTATUS and a HTTP status code from the otel span.
+    OKs are simply OKs.
+    ERRORs first try to map to HTTP/GRPC statuses via attributes otherwise fallback
+    on the description if it is a valid status for Sentry.
+    In the final UNSET case, we try to infer HTTP/GRPC.
+    """
+    status = span.status
+    http_status = get_http_status_code(span.attributes)
+    final_status = None
+
+    if status.status_code == StatusCode.OK:
+        final_status = SPANSTATUS.OK
+    elif status.status_code == StatusCode.ERROR:
+        inferred_status = infer_status_from_attributes(span.attributes, http_status)
+
+        if inferred_status is not None:
+            final_status = inferred_status
+        elif (
+            status.description is not None
+            and status.description in GRPC_ERROR_MAP.values()
+        ):
+            final_status = status.description
+        else:
+            final_status = SPANSTATUS.UNKNOWN_ERROR
     else:
-        return (SPANSTATUS.UNKNOWN_ERROR, None)
+        # UNSET case
+        final_status = infer_status_from_attributes(span.attributes, http_status)
 
+    return (final_status, http_status)
 
-def infer_status_from_attributes(span_attributes):
-    # type: (Mapping[str, str | bool | int | float | Sequence[str] | Sequence[bool] | Sequence[int] | Sequence[float]]) -> tuple[Optional[str], Optional[int]]
-    http_status = get_http_status_code(span_attributes)
+
+def infer_status_from_attributes(
+    span_attributes: Attributes, http_status: Optional[int]
+) -> Optional[str]:
+    if span_attributes is None:
+        return None
 
     if http_status:
-        return (get_span_status_from_http_code(http_status), http_status)
+        return get_span_status_from_http_code(http_status)
 
     grpc_status = span_attributes.get(SpanAttributes.RPC_GRPC_STATUS_CODE)
     if grpc_status:
-        return (GRPC_ERROR_MAP.get(str(grpc_status), SPANSTATUS.UNKNOWN_ERROR), None)
+        return GRPC_ERROR_MAP.get(str(grpc_status), SPANSTATUS.UNKNOWN_ERROR)
 
-    return (None, None)
+    return None
 
 
-def get_http_status_code(span_attributes):
-    # type: (Mapping[str, str | bool | int | float | Sequence[str] | Sequence[bool] | Sequence[int] | Sequence[float]]) -> Optional[int]
+def get_http_status_code(span_attributes: Attributes) -> Optional[int]:
     try:
-        http_status = span_attributes.get(SpanAttributes.HTTP_RESPONSE_STATUS_CODE)
+        http_status = get_typed_attribute(
+            span_attributes, SpanAttributes.HTTP_RESPONSE_STATUS_CODE, int
+        )
     except AttributeError:
         # HTTP_RESPONSE_STATUS_CODE was added in 1.21, so if we're on an older
         # OTel version SpanAttributes.HTTP_RESPONSE_STATUS_CODE will throw an
@@ -292,19 +275,18 @@ def get_http_status_code(span_attributes):
 
     if http_status is None:
         # Fall back to the deprecated attribute
-        http_status = span_attributes.get(SpanAttributes.HTTP_STATUS_CODE)
-
-    http_status = cast("Optional[int]", http_status)
+        http_status = get_typed_attribute(
+            span_attributes, SpanAttributes.HTTP_STATUS_CODE, int
+        )
 
     return http_status
 
 
-def extract_span_attributes(span, namespace):
-    # type: (ReadableSpan, str) -> dict[str, Any]
+def extract_span_attributes(span: ReadableSpan, namespace: str) -> dict[str, Any]:
     """
     Extract Sentry-specific span attributes and make them look the way Sentry expects.
     """
-    extracted_attrs = {}  # type: dict[str, Any]
+    extracted_attrs: dict[str, Any] = {}
 
     for attr, value in (span.attributes or {}).items():
         if attr.startswith(namespace):
@@ -314,8 +296,9 @@ def extract_span_attributes(span, namespace):
     return extracted_attrs
 
 
-def get_trace_context(span, span_data=None):
-    # type: (ReadableSpan, Optional[OtelExtractedSpanData]) -> dict[str, Any]
+def get_trace_context(
+    span: ReadableSpan, span_data: Optional[ExtractedSpanData] = None
+) -> dict[str, Any]:
     if not span.context:
         return {}
 
@@ -326,32 +309,27 @@ def get_trace_context(span, span_data=None):
     if span_data is None:
         span_data = extract_span_data(span)
 
-    (op, _, status, _, origin) = span_data
-
-    trace_context = {
+    trace_context: dict[str, Any] = {
         "trace_id": trace_id,
         "span_id": span_id,
         "parent_span_id": parent_span_id,
-        "op": op,
-        "origin": origin or DEFAULT_SPAN_ORIGIN,
-    }  # type: dict[str, Any]
-
-    if status:
-        trace_context["status"] = status
+        "origin": span_data.origin or DEFAULT_SPAN_ORIGIN,
+    }
 
+    if span_data.op:
+        trace_context["op"] = span_data.op
+    if span_data.status:
+        trace_context["status"] = span_data.status
     if span.attributes:
         trace_context["data"] = dict(span.attributes)
 
     trace_state = get_trace_state(span)
     trace_context["dynamic_sampling_context"] = dsc_from_trace_state(trace_state)
 
-    # TODO-neel-potel profiler thread_id, thread_name
-
     return trace_context
 
 
-def trace_state_from_baggage(baggage):
-    # type: (Baggage) -> TraceState
+def trace_state_from_baggage(baggage: Baggage) -> TraceState:
     items = []
     for k, v in baggage.sentry_items.items():
         key = Baggage.SENTRY_PREFIX + quote(k)
@@ -360,13 +338,11 @@ def trace_state_from_baggage(baggage):
     return TraceState(items)
 
 
-def baggage_from_trace_state(trace_state):
-    # type: (TraceState) -> Baggage
+def baggage_from_trace_state(trace_state: TraceState) -> Baggage:
     return Baggage(dsc_from_trace_state(trace_state))
 
 
-def serialize_trace_state(trace_state):
-    # type: (TraceState) -> str
+def serialize_trace_state(trace_state: TraceState) -> str:
     sentry_items = []
     for k, v in trace_state.items():
         if Baggage.SENTRY_PREFIX_REGEX.match(k):
@@ -374,8 +350,7 @@ def serialize_trace_state(trace_state):
     return ",".join(key + "=" + value for key, value in sentry_items)
 
 
-def dsc_from_trace_state(trace_state):
-    # type: (TraceState) -> dict[str, str]
+def dsc_from_trace_state(trace_state: TraceState) -> dict[str, str]:
     dsc = {}
     for k, v in trace_state.items():
         if Baggage.SENTRY_PREFIX_REGEX.match(k):
@@ -384,16 +359,14 @@ def dsc_from_trace_state(trace_state):
     return dsc
 
 
-def has_incoming_trace(trace_state):
-    # type: (TraceState) -> bool
+def has_incoming_trace(trace_state: TraceState) -> bool:
     """
     The existence of a sentry-trace_id in the baggage implies we continued an upstream trace.
     """
     return (Baggage.SENTRY_PREFIX + "trace_id") in trace_state
 
 
-def get_trace_state(span):
-    # type: (Union[AbstractSpan, ReadableSpan]) -> TraceState
+def get_trace_state(span: Union[AbstractSpan, ReadableSpan]) -> TraceState:
     """
     Get the existing trace_state with sentry items
     or populate it if we are the head SDK.
@@ -451,26 +424,45 @@ def get_trace_state(span):
         return trace_state
 
 
-def get_sentry_meta(span, key):
-    # type: (Union[AbstractSpan, ReadableSpan], str) -> Any
+def get_sentry_meta(span: Union[AbstractSpan, ReadableSpan], key: str) -> Any:
     sentry_meta = getattr(span, "_sentry_meta", None)
     return sentry_meta.get(key) if sentry_meta else None
 
 
-def set_sentry_meta(span, key, value):
-    # type: (Union[AbstractSpan, ReadableSpan], str, Any) -> None
+def set_sentry_meta(
+    span: Union[AbstractSpan, ReadableSpan], key: str, value: Any
+) -> None:
     sentry_meta = getattr(span, "_sentry_meta", {})
     sentry_meta[key] = value
     span._sentry_meta = sentry_meta  # type: ignore[union-attr]
 
 
-def get_profile_context(span):
-    # type: (ReadableSpan) -> Optional[dict[str, str]]
+def delete_sentry_meta(span: Union[AbstractSpan, ReadableSpan]) -> None:
+    try:
+        del span._sentry_meta  # type: ignore[union-attr]
+    except AttributeError:
+        pass
+
+
+def get_profile_context(span: ReadableSpan) -> Optional[dict[str, str]]:
     if not span.attributes:
         return None
 
-    profiler_id = cast("Optional[str]", span.attributes.get(SPANDATA.PROFILER_ID))
+    profiler_id = get_typed_attribute(span.attributes, SPANDATA.PROFILER_ID, str)
     if profiler_id is None:
         return None
 
     return {"profiler_id": profiler_id}
+
+
+def get_typed_attribute(attributes: Attributes, key: str, type: Type[T]) -> Optional[T]:
+    """
+    helper method to coerce types of attribute values
+    """
+    if attributes is None:
+        return None
+    value = attributes.get(key)
+    if value is not None and isinstance(value, type):
+        return value
+    else:
+        return None