sentry-sdk 2.30.0__py2.py3-none-any.whl → 3.0.0a2__py2.py3-none-any.whl

sentry_sdk/tracing.py

@@ -1,29 +1,58 @@
-from decimal import Decimal
-import uuid
+from datetime import datetime
+import json
 import warnings
-from datetime import datetime, timedelta, timezone
-from enum import Enum
 
-import sentry_sdk
-from sentry_sdk.consts import INSTRUMENTER, SPANSTATUS, SPANDATA
-from sentry_sdk.profiler.continuous_profiler import get_profiler_id
+from opentelemetry import trace as otel_trace, context
+from opentelemetry.trace import (
+    format_trace_id,
+    format_span_id,
+    Span as OtelSpan,
+    TraceState,
+    get_current_span,
+    INVALID_SPAN,
+)
+from opentelemetry.trace.status import Status, StatusCode
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.version import __version__ as otel_version
+
+from sentry_sdk.consts import (
+    DEFAULT_SPAN_NAME,
+    DEFAULT_SPAN_ORIGIN,
+    BAGGAGE_HEADER_NAME,
+    SENTRY_TRACE_HEADER_NAME,
+    SPANSTATUS,
+    SPANDATA,
+    TransactionSource,
+)
+from sentry_sdk.opentelemetry.consts import (
+    TRACESTATE_SAMPLE_RATE_KEY,
+    SentrySpanAttribute,
+)
+from sentry_sdk.opentelemetry.utils import (
+    baggage_from_trace_state,
+    convert_from_otel_timestamp,
+    convert_to_otel_timestamp,
+    get_trace_context,
+    get_trace_state,
+    get_sentry_meta,
+    serialize_trace_state,
+)
+from sentry_sdk.tracing_utils import get_span_status_from_http_code
 from sentry_sdk.utils import (
+    _serialize_span_attribute,
     get_current_thread_meta,
-    is_valid_sample_rate,
-    logger,
-    nanosecond_time,
+    parse_version,
     should_be_treated_as_error,
 )
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, Mapping, MutableMapping
+    from collections.abc import Callable
     from typing import Any
     from typing import Dict
     from typing import Iterator
-    from typing import List
     from typing import Optional
     from typing import overload
     from typing import ParamSpec
@@ -31,346 +60,208 @@ if TYPE_CHECKING:
     from typing import Union
     from typing import TypeVar
 
-    from typing_extensions import TypedDict, Unpack
-
     P = ParamSpec("P")
     R = TypeVar("R")
 
-    from sentry_sdk.profiler.continuous_profiler import ContinuousProfile
-    from sentry_sdk.profiler.transaction_profiler import Profile
     from sentry_sdk._types import (
-        Event,
-        MeasurementUnit,
         SamplingContext,
-        MeasurementValue,
     )
 
-    class SpanKwargs(TypedDict, total=False):
-        trace_id: str
-        """
-        The trace ID of the root span. If this new span is to be the root span,
-        omit this parameter, and a new trace ID will be generated.
-        """
-
-        span_id: str
-        """The span ID of this span. If omitted, a new span ID will be generated."""
-
-        parent_span_id: str
-        """The span ID of the parent span, if applicable."""
-
-        same_process_as_parent: bool
-        """Whether this span is in the same process as the parent span."""
-
-        sampled: bool
-        """
-        Whether the span should be sampled. Overrides the default sampling decision
-        for this span when provided.
-        """
-
-        op: str
-        """
-        The span's operation. A list of recommended values is available here:
-        https://develop.sentry.dev/sdk/performance/span-operations/
-        """
-
-        description: str
-        """A description of what operation is being performed within the span. This argument is DEPRECATED. Please use the `name` parameter, instead."""
-
-        hub: Optional["sentry_sdk.Hub"]
-        """The hub to use for this span. This argument is DEPRECATED. Please use the `scope` parameter, instead."""
-
-        status: str
-        """The span's status. Possible values are listed at https://develop.sentry.dev/sdk/event-payloads/span/"""
+    from sentry_sdk.tracing_utils import Baggage
 
-        containing_transaction: Optional["Transaction"]
-        """The transaction that this span belongs to."""
+_FLAGS_CAPACITY = 10
+_OTEL_VERSION = parse_version(otel_version)
 
-        start_timestamp: Optional[Union[datetime, float]]
-        """
-        The timestamp when the span started. If omitted, the current time
-        will be used.
-        """
+tracer = otel_trace.get_tracer(__name__)
 
-        scope: "sentry_sdk.Scope"
-        """The scope to use for this span. If not provided, we use the current scope."""
 
-        origin: str
-        """
-        The origin of the span.
-        See https://develop.sentry.dev/sdk/performance/trace-origin/
-        Default "manual".
-        """
-
-        name: str
-        """A string describing what operation is being performed within the span/transaction."""
-
-    class TransactionKwargs(SpanKwargs, total=False):
-        source: str
-        """
-        A string describing the source of the transaction name. This will be used to determine the transaction's type.
-        See https://develop.sentry.dev/sdk/event-payloads/transaction/#transaction-annotations for more information.
-        Default "custom".
-        """
+class NoOpSpan:
+    def __init__(self, **kwargs):
+        # type: (Any) -> None
+        pass
 
-        parent_sampled: bool
-        """Whether the parent transaction was sampled. If True this transaction will be kept, if False it will be discarded."""
+    def __repr__(self):
+        # type: () -> str
+        return "<%s>" % self.__class__.__name__
 
-        baggage: "Baggage"
-        """The W3C baggage header value. (see https://www.w3.org/TR/baggage/)"""
+    @property
+    def root_span(self):
+        # type: () -> Optional[Span]
+        return None
 
-    ProfileContext = TypedDict(
-        "ProfileContext",
-        {
-            "profiler_id": str,
-        },
-    )
+    def start_child(self, **kwargs):
+        # type: (**Any) -> NoOpSpan
+        return NoOpSpan()
 
-BAGGAGE_HEADER_NAME = "baggage"
-SENTRY_TRACE_HEADER_NAME = "sentry-trace"
+    def to_traceparent(self):
+        # type: () -> str
+        return ""
 
+    def to_baggage(self):
+        # type: () -> Optional[Baggage]
+        return None
 
-# 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 get_baggage(self):
+        # type: () -> Optional[Baggage]
+        return None
 
-    def __str__(self):
-        # type: () -> str
-        return self.value
+    def iter_headers(self):
+        # type: () -> Iterator[Tuple[str, str]]
+        return iter(())
 
+    def set_tag(self, key, value):
+        # type: (str, Any) -> None
+        pass
 
-# These are typically high cardinality and the server hates them
-LOW_QUALITY_TRANSACTION_SOURCES = [
-    TransactionSource.URL,
-]
+    def set_data(self, key, value):
+        # type: (str, Any) -> None
+        pass
 
-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,
-}
+    def set_status(self, value):
+        # type: (str) -> None
+        pass
 
+    def set_http_status(self, http_status):
+        # type: (int) -> None
+        pass
 
-def get_span_status_from_http_code(http_status_code):
-    # type: (int) -> str
-    """
-    Returns the Sentry status corresponding to the given HTTP status code.
+    def is_success(self):
+        # type: () -> bool
+        return True
 
-    See: https://develop.sentry.dev/sdk/event-payloads/contexts/#trace-context
-    """
-    if http_status_code < 400:
-        return SPANSTATUS.OK
-
-    elif 400 <= http_status_code < 500:
-        if http_status_code == 403:
-            return SPANSTATUS.PERMISSION_DENIED
-        elif http_status_code == 404:
-            return SPANSTATUS.NOT_FOUND
-        elif http_status_code == 429:
-            return SPANSTATUS.RESOURCE_EXHAUSTED
-        elif http_status_code == 413:
-            return SPANSTATUS.FAILED_PRECONDITION
-        elif http_status_code == 401:
-            return SPANSTATUS.UNAUTHENTICATED
-        elif http_status_code == 409:
-            return SPANSTATUS.ALREADY_EXISTS
-        else:
-            return SPANSTATUS.INVALID_ARGUMENT
-
-    elif 500 <= http_status_code < 600:
-        if http_status_code == 504:
-            return SPANSTATUS.DEADLINE_EXCEEDED
-        elif http_status_code == 501:
-            return SPANSTATUS.UNIMPLEMENTED
-        elif http_status_code == 503:
-            return SPANSTATUS.UNAVAILABLE
-        else:
-            return SPANSTATUS.INTERNAL_ERROR
+    def to_json(self):
+        # type: () -> Dict[str, Any]
+        return {}
 
-    return SPANSTATUS.UNKNOWN_ERROR
+    def get_trace_context(self):
+        # type: () -> Any
+        return {}
 
+    def get_profile_context(self):
+        # type: () -> Any
+        return {}
 
-class _SpanRecorder:
-    """Limits the number of spans recorded in a transaction."""
+    def finish(
+        self,
+        end_timestamp=None,  # type: Optional[Union[float, datetime]]
+    ):
+        # type: (...) -> None
+        pass
 
-    __slots__ = ("maxlen", "spans", "dropped_spans")
+    def set_context(self, key, value):
+        # type: (str, dict[str, Any]) -> None
+        pass
 
-    def __init__(self, maxlen):
+    def init_span_recorder(self, maxlen):
         # type: (int) -> None
-        # FIXME: this is `maxlen - 1` only to preserve historical behavior
-        # enforced by tests.
-        # Either this should be changed to `maxlen` or the JS SDK implementation
-        # should be changed to match a consistent interpretation of what maxlen
-        # limits: either transaction+spans or only child spans.
-        self.maxlen = maxlen - 1
-        self.spans = []  # type: List[Span]
-        self.dropped_spans = 0  # type: int
-
-    def add(self, span):
-        # type: (Span) -> None
-        if len(self.spans) > self.maxlen:
-            span._span_recorder = None
-            self.dropped_spans += 1
-        else:
-            self.spans.append(span)
+        pass
+
+    def _set_initial_sampling_decision(self, sampling_context):
+        # type: (SamplingContext) -> None
+        pass
 
 
 class Span:
-    """A span holds timing information of a block of code.
-    Spans can have multiple child spans thus forming a span tree.
-
-    :param trace_id: The trace ID of the root span. If this new span is to be the root span,
-        omit this parameter, and a new trace ID will be generated.
-    :param span_id: The span ID of this span. If omitted, a new span ID will be generated.
-    :param parent_span_id: The span ID of the parent span, if applicable.
-    :param same_process_as_parent: Whether this span is in the same process as the parent span.
-    :param sampled: Whether the span should be sampled. Overrides the default sampling decision
-        for this span when provided.
-    :param op: The span's operation. A list of recommended values is available here:
-        https://develop.sentry.dev/sdk/performance/span-operations/
-    :param description: A description of what operation is being performed within the span.
-
-        .. deprecated:: 2.15.0
-            Please use the `name` parameter, instead.
-    :param name: A string describing what operation is being performed within the span.
-    :param hub: The hub to use for this span.
-
-        .. deprecated:: 2.0.0
-            Please use the `scope` parameter, instead.
-    :param status: The span's status. Possible values are listed at
-        https://develop.sentry.dev/sdk/event-payloads/span/
-    :param containing_transaction: The transaction that this span belongs to.
-    :param start_timestamp: The timestamp when the span started. If omitted, the current time
-        will be used.
-    :param scope: The scope to use for this span. If not provided, we use the current scope.
     """
-
-    __slots__ = (
-        "trace_id",
-        "span_id",
-        "parent_span_id",
-        "same_process_as_parent",
-        "sampled",
-        "op",
-        "description",
-        "_measurements",
-        "start_timestamp",
-        "_start_timestamp_monotonic_ns",
-        "status",
-        "timestamp",
-        "_tags",
-        "_data",
-        "_span_recorder",
-        "hub",
-        "_context_manager_state",
-        "_containing_transaction",
-        "_local_aggregator",
-        "scope",
-        "origin",
-        "name",
-        "_flags",
-        "_flags_capacity",
-    )
+    OTel span wrapper providing compatibility with the old span interface.
+    """
 
     def __init__(
         self,
-        trace_id=None,  # type: Optional[str]
-        span_id=None,  # type: Optional[str]
-        parent_span_id=None,  # type: Optional[str]
-        same_process_as_parent=True,  # type: bool
-        sampled=None,  # type: Optional[bool]
+        *,
         op=None,  # type: Optional[str]
         description=None,  # type: Optional[str]
-        hub=None,  # type: Optional[sentry_sdk.Hub]  # deprecated
         status=None,  # type: Optional[str]
-        containing_transaction=None,  # type: Optional[Transaction]
+        sampled=None,  # type: Optional[bool]
         start_timestamp=None,  # type: Optional[Union[datetime, float]]
-        scope=None,  # type: Optional[sentry_sdk.Scope]
-        origin="manual",  # type: str
+        origin=None,  # type: Optional[str]
         name=None,  # type: Optional[str]
+        source=TransactionSource.CUSTOM,  # type: str
+        attributes=None,  # type: Optional[dict[str, Any]]
+        only_if_parent=False,  # type: bool
+        parent_span=None,  # type: Optional[Span]
+        otel_span=None,  # type: Optional[OtelSpan]
+        span=None,  # type: Optional[Span]
     ):
         # type: (...) -> None
-        self.trace_id = trace_id or uuid.uuid4().hex
-        self.span_id = span_id or uuid.uuid4().hex[16:]
-        self.parent_span_id = parent_span_id
-        self.same_process_as_parent = same_process_as_parent
-        self.sampled = sampled
-        self.op = op
-        self.description = name or description
-        self.status = status
-        self.hub = hub  # backwards compatibility
-        self.scope = scope
-        self.origin = origin
-        self._measurements = {}  # type: Dict[str, MeasurementValue]
-        self._tags = {}  # type: MutableMapping[str, str]
-        self._data = {}  # type: Dict[str, Any]
-        self._containing_transaction = containing_transaction
-        self._flags = {}  # type: Dict[str, bool]
-        self._flags_capacity = 10
-
-        if hub is not None:
-            warnings.warn(
-                "The `hub` parameter is deprecated. Please use `scope` instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
+        """
+        If otel_span is passed explicitly, just acts as a proxy.
 
-            self.scope = self.scope or hub.scope
+        If span is passed explicitly, use it. The only purpose of this param
+        is backwards compatibility with start_transaction(transaction=...).
 
-        if start_timestamp is None:
-            start_timestamp = datetime.now(timezone.utc)
-        elif isinstance(start_timestamp, float):
-            start_timestamp = datetime.fromtimestamp(start_timestamp, timezone.utc)
-        self.start_timestamp = start_timestamp
-        try:
-            # profiling depends on this value and requires that
-            # it is measured in nanoseconds
-            self._start_timestamp_monotonic_ns = nanosecond_time()
-        except AttributeError:
-            pass
+        If only_if_parent is True, just return an INVALID_SPAN
+        and avoid instrumentation if there's no active parent span.
+        """
+        if otel_span is not None:
+            self._otel_span = otel_span
+        elif span is not None:
+            self._otel_span = span._otel_span
+        else:
+            skip_span = False
+            if only_if_parent and parent_span is None:
+                parent_span_context = get_current_span().get_span_context()
+                skip_span = (
+                    not parent_span_context.is_valid or parent_span_context.is_remote
+                )
 
-        #: End timestamp of span
-        self.timestamp = None  # type: Optional[datetime]
+            if skip_span:
+                self._otel_span = INVALID_SPAN
+            else:
 
-        self._span_recorder = None  # type: Optional[_SpanRecorder]
-        self._local_aggregator = None  # type: Optional[LocalAggregator]
+                if start_timestamp is not None:
+                    # OTel timestamps have nanosecond precision
+                    start_timestamp = convert_to_otel_timestamp(start_timestamp)
+
+                span_name = name or description or op or DEFAULT_SPAN_NAME
+
+                # Prepopulate some attrs so that they're accessible in traces_sampler
+                attributes = attributes or {}
+                if op is not None:
+                    attributes[SentrySpanAttribute.OP] = op
+                if source is not None:
+                    attributes[SentrySpanAttribute.SOURCE] = source
+                if description is not None:
+                    attributes[SentrySpanAttribute.DESCRIPTION] = description
+                if sampled is not None:
+                    attributes[SentrySpanAttribute.CUSTOM_SAMPLED] = sampled
+
+                parent_context = None
+                if parent_span is not None:
+                    parent_context = otel_trace.set_span_in_context(
+                        parent_span._otel_span
+                    )
+
+                self._otel_span = tracer.start_span(
+                    span_name,
+                    context=parent_context,
+                    start_time=start_timestamp,
+                    attributes=attributes,
+                )
 
-        self.update_active_thread()
-        self.set_profiler_id(get_profiler_id())
+                self.origin = origin or DEFAULT_SPAN_ORIGIN
+                self.description = description
+                self.name = span_name
 
-    # TODO this should really live on the Transaction class rather than the Span
-    # class
-    def init_span_recorder(self, maxlen):
-        # type: (int) -> None
-        if self._span_recorder is None:
-            self._span_recorder = _SpanRecorder(maxlen)
+                if status is not None:
+                    self.set_status(status)
+
+                self.update_active_thread()
 
-    def _get_local_aggregator(self):
-        # type: (...) -> LocalAggregator
-        rv = self._local_aggregator
-        if rv is None:
-            rv = self._local_aggregator = LocalAggregator()
-        return rv
+    def __eq__(self, other):
+        # type: (object) -> bool
+        if not isinstance(other, Span):
+            return False
+        return self._otel_span == other._otel_span
 
     def __repr__(self):
         # type: () -> str
         return (
-            "<%s(op=%r, description:%r, trace_id=%r, span_id=%r, parent_span_id=%r, sampled=%r, origin=%r)>"
+            "<%s(op=%r, name:%r, trace_id=%r, span_id=%r, parent_span_id=%r, sampled=%r, origin=%r)>"
             % (
                 self.__class__.__name__,
                 self.op,
-                self.description,
+                self.name,
                 self.trace_id,
                 self.span_id,
                 self.parent_span_id,
@@ -379,196 +270,175 @@ class Span:
             )
         )
 
+    def activate(self):
+        # type: () -> None
+        ctx = otel_trace.set_span_in_context(self._otel_span)
+        # set as the implicit current context
+        self._ctx_token = context.attach(ctx)
+
+    def deactivate(self):
+        # type: () -> None
+        if self._ctx_token:
+            context.detach(self._ctx_token)
+            del self._ctx_token
+
     def __enter__(self):
         # type: () -> Span
-        scope = self.scope or sentry_sdk.get_current_scope()
-        old_span = scope.span
-        scope.span = self
-        self._context_manager_state = (scope, old_span)
+        self.activate()
         return self
 
     def __exit__(self, ty, value, tb):
         # type: (Optional[Any], Optional[Any], Optional[Any]) -> None
         if value is not None and should_be_treated_as_error(ty, value):
             self.set_status(SPANSTATUS.INTERNAL_ERROR)
+        else:
+            status_unset = (
+                hasattr(self._otel_span, "status")
+                and self._otel_span.status.status_code == StatusCode.UNSET
+            )
+            if status_unset:
+                self.set_status(SPANSTATUS.OK)
 
-        scope, old_span = self._context_manager_state
-        del self._context_manager_state
-        self.finish(scope)
-        scope.span = old_span
+        self.finish()
+        self.deactivate()
 
     @property
-    def containing_transaction(self):
-        # type: () -> Optional[Transaction]
-        """The ``Transaction`` that this span belongs to.
-        The ``Transaction`` is the root of the span tree,
-        so one could also think of this ``Transaction`` as the "root span"."""
-
-        # this is a getter rather than a regular attribute so that transactions
-        # can return `self` here instead (as a way to prevent them circularly
-        # referencing themselves)
-        return self._containing_transaction
-
-    def start_child(self, instrumenter=INSTRUMENTER.SENTRY, **kwargs):
-        # type: (str, **Any) -> Span
-        """
-        Start a sub-span from the current span or transaction.
-
-        Takes the same arguments as the initializer of :py:class:`Span`. The
-        trace id, sampling decision, transaction pointer, and span recorder are
-        inherited from the current span/transaction.
-
-        The instrumenter parameter is deprecated for user code, and it will
-        be removed in the next major version. Going forward, it should only
-        be used by the SDK itself.
-        """
-        if kwargs.get("description") is not None:
-            warnings.warn(
-                "The `description` parameter is deprecated. Please use `name` instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
+    def description(self):
+        # type: () -> Optional[str]
+        return self.get_attribute(SentrySpanAttribute.DESCRIPTION)
 
-        configuration_instrumenter = sentry_sdk.get_client().options["instrumenter"]
-
-        if instrumenter != configuration_instrumenter:
-            return NoOpSpan()
+    @description.setter
+    def description(self, value):
+        # type: (Optional[str]) -> None
+        self.set_attribute(SentrySpanAttribute.DESCRIPTION, value)
 
-        kwargs.setdefault("sampled", self.sampled)
+    @property
+    def origin(self):
+        # type: () -> Optional[str]
+        return self.get_attribute(SentrySpanAttribute.ORIGIN)
 
-        child = Span(
-            trace_id=self.trace_id,
-            parent_span_id=self.span_id,
-            containing_transaction=self.containing_transaction,
-            **kwargs,
-        )
+    @origin.setter
+    def origin(self, value):
+        # type: (Optional[str]) -> None
+        self.set_attribute(SentrySpanAttribute.ORIGIN, value)
 
-        span_recorder = (
-            self.containing_transaction and self.containing_transaction._span_recorder
+    @property
+    def root_span(self):
+        # type: () -> Optional[Span]
+        root_otel_span = cast(
+            "Optional[OtelSpan]", get_sentry_meta(self._otel_span, "root_span")
         )
-        if span_recorder:
-            span_recorder.add(child)
+        return Span(otel_span=root_otel_span) if root_otel_span else None
 
-        return child
+    @property
+    def is_root_span(self):
+        # type: () -> bool
+        return self.root_span == self
 
-    @classmethod
-    def continue_from_environ(
-        cls,
-        environ,  # type: Mapping[str, str]
-        **kwargs,  # type: Any
-    ):
-        # type: (...) -> Transaction
-        """
-        Create a Transaction with the given params, then add in data pulled from
-        the ``sentry-trace`` and ``baggage`` headers from the environ (if any)
-        before returning the Transaction.
+    @property
+    def parent_span_id(self):
+        # type: () -> Optional[str]
+        if (
+            not isinstance(self._otel_span, ReadableSpan)
+            or self._otel_span.parent is None
+        ):
+            return None
+        return format_span_id(self._otel_span.parent.span_id)
 
-        This is different from :py:meth:`~sentry_sdk.tracing.Span.continue_from_headers`
-        in that it assumes header names in the form ``HTTP_HEADER_NAME`` -
-        such as you would get from a WSGI/ASGI environ -
-        rather than the form ``header-name``.
+    @property
+    def trace_id(self):
+        # type: () -> str
+        return format_trace_id(self._otel_span.get_span_context().trace_id)
 
-        :param environ: The ASGI/WSGI environ to pull information from.
-        """
-        if cls is Span:
-            logger.warning(
-                "Deprecated: use Transaction.continue_from_environ "
-                "instead of Span.continue_from_environ."
-            )
-        return Transaction.continue_from_headers(EnvironHeaders(environ), **kwargs)
+    @property
+    def span_id(self):
+        # type: () -> str
+        return format_span_id(self._otel_span.get_span_context().span_id)
 
-    @classmethod
-    def continue_from_headers(
-        cls,
-        headers,  # type: Mapping[str, str]
-        *,
-        _sample_rand=None,  # type: Optional[str]
-        **kwargs,  # type: Any
-    ):
-        # type: (...) -> Transaction
-        """
-        Create a transaction with the given params (including any data pulled from
-        the ``sentry-trace`` and ``baggage`` headers).
+    @property
+    def is_valid(self):
+        # type: () -> bool
+        return self._otel_span.get_span_context().is_valid and isinstance(
+            self._otel_span, ReadableSpan
+        )
 
-        :param headers: The dictionary with the HTTP headers to pull information from.
-        :param _sample_rand: If provided, we override the sample_rand value from the
-            incoming headers with this value. (internal use only)
-        """
-        # TODO move this to the Transaction class
-        if cls is Span:
-            logger.warning(
-                "Deprecated: use Transaction.continue_from_headers "
-                "instead of Span.continue_from_headers."
-            )
+    @property
+    def sampled(self):
+        # type: () -> Optional[bool]
+        return self._otel_span.get_span_context().trace_flags.sampled
 
-        # TODO-neel move away from this kwargs stuff, it's confusing and opaque
-        # make more explicit
-        baggage = Baggage.from_incoming_header(
-            headers.get(BAGGAGE_HEADER_NAME), _sample_rand=_sample_rand
+    @property
+    def sample_rate(self):
+        # type: () -> Optional[float]
+        sample_rate = self._otel_span.get_span_context().trace_state.get(
+            TRACESTATE_SAMPLE_RATE_KEY
         )
-        kwargs.update({BAGGAGE_HEADER_NAME: baggage})
+        return float(sample_rate) if sample_rate is not None else None
 
-        sentrytrace_kwargs = extract_sentrytrace_data(
-            headers.get(SENTRY_TRACE_HEADER_NAME)
-        )
+    @property
+    def op(self):
+        # type: () -> Optional[str]
+        return self.get_attribute(SentrySpanAttribute.OP)
 
-        if sentrytrace_kwargs is not None:
-            kwargs.update(sentrytrace_kwargs)
+    @op.setter
+    def op(self, value):
+        # type: (Optional[str]) -> None
+        self.set_attribute(SentrySpanAttribute.OP, value)
 
-            # If there's an incoming sentry-trace but no incoming baggage header,
-            # for instance in traces coming from older SDKs,
-            # baggage will be empty and immutable and won't be populated as head SDK.
-            baggage.freeze()
+    @property
+    def name(self):
+        # type: () -> Optional[str]
+        return self.get_attribute(SentrySpanAttribute.NAME)
 
-        transaction = Transaction(**kwargs)
-        transaction.same_process_as_parent = False
+    @name.setter
+    def name(self, value):
+        # type: (Optional[str]) -> None
+        self.set_attribute(SentrySpanAttribute.NAME, value)
 
-        return transaction
+    @property
+    def source(self):
+        # type: () -> str
+        return (
+            self.get_attribute(SentrySpanAttribute.SOURCE) or TransactionSource.CUSTOM
+        )
 
-    def iter_headers(self):
-        # type: () -> Iterator[Tuple[str, str]]
-        """
-        Creates a generator which returns the span's ``sentry-trace`` and ``baggage`` headers.
-        If the span's containing transaction doesn't yet have a ``baggage`` value,
-        this will cause one to be generated and stored.
-        """
-        if not self.containing_transaction:
-            # Do not propagate headers if there is no containing transaction. Otherwise, this
-            # span ends up being the root span of a new trace, and since it does not get sent
-            # to Sentry, the trace will be missing a root transaction. The dynamic sampling
-            # context will also be missing, breaking dynamic sampling & traces.
-            return
+    @source.setter
+    def source(self, value):
+        # type: (str) -> None
+        self.set_attribute(SentrySpanAttribute.SOURCE, value)
 
-        yield SENTRY_TRACE_HEADER_NAME, self.to_traceparent()
+    @property
+    def start_timestamp(self):
+        # type: () -> Optional[datetime]
+        if not isinstance(self._otel_span, ReadableSpan):
+            return None
 
-        baggage = self.containing_transaction.get_baggage().serialize()
-        if baggage:
-            yield BAGGAGE_HEADER_NAME, baggage
+        start_time = self._otel_span.start_time
+        if start_time is None:
+            return None
 
-    @classmethod
-    def from_traceparent(
-        cls,
-        traceparent,  # type: Optional[str]
-        **kwargs,  # type: Any
-    ):
-        # type: (...) -> Optional[Transaction]
-        """
-        DEPRECATED: Use :py:meth:`sentry_sdk.tracing.Span.continue_from_headers`.
+        return convert_from_otel_timestamp(start_time)
 
-        Create a ``Transaction`` with the given params, then add in data pulled from
-        the given ``sentry-trace`` header value before returning the ``Transaction``.
-        """
-        logger.warning(
-            "Deprecated: Use Transaction.continue_from_headers(headers, **kwargs) "
-            "instead of from_traceparent(traceparent, **kwargs)"
-        )
+    @property
+    def timestamp(self):
+        # type: () -> Optional[datetime]
+        if not isinstance(self._otel_span, ReadableSpan):
+            return None
 
-        if not traceparent:
+        end_time = self._otel_span.end_time
+        if end_time is None:
             return None
 
-        return cls.continue_from_headers(
-            {SENTRY_TRACE_HEADER_NAME: traceparent}, **kwargs
-        )
+        return convert_from_otel_timestamp(end_time)
+
+    def start_child(self, **kwargs):
+        # type: (**Any) -> Span
+        return Span(parent_span=self, **kwargs)
+
+    def iter_headers(self):
+        # type: () -> Iterator[Tuple[str, str]]
+        yield SENTRY_TRACE_HEADER_NAME, self.to_traceparent()
+        yield BAGGAGE_HEADER_NAME, serialize_trace_state(self.trace_state)
 
     def to_traceparent(self):
         # type: () -> str
@@ -585,748 +455,149 @@ class Span:
 
         return traceparent
 
+    @property
+    def trace_state(self):
+        # type: () -> TraceState
+        return get_trace_state(self._otel_span)
+
     def to_baggage(self):
-        # type: () -> Optional[Baggage]
-        """Returns the :py:class:`~sentry_sdk.tracing_utils.Baggage`
-        associated with this ``Span``, if any. (Taken from the root of the span tree.)
-        """
-        if self.containing_transaction:
-            return self.containing_transaction.get_baggage()
-        return None
+        # type: () -> Baggage
+        return self.get_baggage()
+
+    def get_baggage(self):
+        # type: () -> Baggage
+        return baggage_from_trace_state(self.trace_state)
 
     def set_tag(self, key, value):
         # type: (str, Any) -> None
-        self._tags[key] = value
+        self.set_attribute(f"{SentrySpanAttribute.TAG}.{key}", value)
 
     def set_data(self, key, value):
         # type: (str, Any) -> None
-        self._data[key] = value
-
-    def set_flag(self, flag, result):
-        # type: (str, bool) -> None
-        if len(self._flags) < self._flags_capacity:
-            self._flags[flag] = result
-
-    def set_status(self, value):
-        # type: (str) -> None
-        self.status = value
-
-    def set_measurement(self, name, value, unit=""):
-        # type: (str, float, MeasurementUnit) -> None
-        """
-        .. deprecated:: 2.28.0
-            This function is deprecated and will be removed in the next major release.
-        """
-
         warnings.warn(
-            "`set_measurement()` is deprecated and will be removed in the next major version. Please use `set_data()` instead.",
+            "`Span.set_data` is deprecated. Please use `Span.set_attribute` instead.",
             DeprecationWarning,
             stacklevel=2,
         )
-        self._measurements[name] = {"value": value, "unit": unit}
 
-    def set_thread(self, thread_id, thread_name):
-        # type: (Optional[int], Optional[str]) -> None
-
-        if thread_id is not None:
-            self.set_data(SPANDATA.THREAD_ID, str(thread_id))
+        # TODO-neel-potel we cannot add dicts here
+        self.set_attribute(key, value)
 
-            if thread_name is not None:
-                self.set_data(SPANDATA.THREAD_NAME, thread_name)
-
-    def set_profiler_id(self, profiler_id):
-        # type: (Optional[str]) -> None
-        if profiler_id is not None:
-            self.set_data(SPANDATA.PROFILER_ID, profiler_id)
+    def get_attribute(self, name):
+        # type: (str) -> Optional[Any]
+        if (
+            not isinstance(self._otel_span, ReadableSpan)
+            or not self._otel_span.attributes
+        ):
+            return None
+        return self._otel_span.attributes.get(name)
 
-    def set_http_status(self, http_status):
-        # type: (int) -> None
-        self.set_tag(
-            "http.status_code", str(http_status)
-        )  # we keep this for backwards compatibility
-        self.set_data(SPANDATA.HTTP_STATUS_CODE, http_status)
-        self.set_status(get_span_status_from_http_code(http_status))
+    def set_attribute(self, key, value):
+        # type: (str, Any) -> None
+        # otel doesn't support None as values, preferring to not set the key
+        # at all instead
+        if value is None:
+            return
+        serialized_value = _serialize_span_attribute(value)
+        if serialized_value is None:
+            return
 
-    def is_success(self):
-        # type: () -> bool
-        return self.status == "ok"
+        self._otel_span.set_attribute(key, serialized_value)
 
-    def finish(self, scope=None, end_timestamp=None):
-        # type: (Optional[sentry_sdk.Scope], Optional[Union[float, datetime]]) -> Optional[str]
+    @property
+    def status(self):
+        # type: () -> Optional[str]
         """
-        Sets the end timestamp of the span.
-
-        Additionally it also creates a breadcrumb from the span,
-        if the span represents a database or HTTP request.
-
-        :param scope: The scope to use for this transaction.
-            If not provided, the current scope will be used.
-        :param end_timestamp: Optional timestamp that should
-            be used as timestamp instead of the current time.
-
-        :return: Always ``None``. The type is ``Optional[str]`` to match
-            the return value of :py:meth:`sentry_sdk.tracing.Transaction.finish`.
+        Return the Sentry `SPANSTATUS` corresponding to the underlying OTel status.
+        Because differences in possible values in OTel `StatusCode` and
+        Sentry `SPANSTATUS` it can not be guaranteed that the status
+        set in `set_status()` will be the same as the one returned here.
         """
-        if self.timestamp is not None:
-            # This span is already finished, ignore.
+        if not isinstance(self._otel_span, ReadableSpan):
             return None
 
-        try:
-            if end_timestamp:
-                if isinstance(end_timestamp, float):
-                    end_timestamp = datetime.fromtimestamp(end_timestamp, timezone.utc)
-                self.timestamp = end_timestamp
-            else:
-                elapsed = nanosecond_time() - self._start_timestamp_monotonic_ns
-                self.timestamp = self.start_timestamp + timedelta(
-                    microseconds=elapsed / 1000
-                )
-        except AttributeError:
-            self.timestamp = datetime.now(timezone.utc)
-
-        scope = scope or sentry_sdk.get_current_scope()
-        maybe_create_breadcrumbs_from_span(scope, self)
-
-        return None
-
-    def to_json(self):
-        # type: () -> Dict[str, Any]
-        """Returns a JSON-compatible representation of the span."""
-
-        rv = {
-            "trace_id": self.trace_id,
-            "span_id": self.span_id,
-            "parent_span_id": self.parent_span_id,
-            "same_process_as_parent": self.same_process_as_parent,
-            "op": self.op,
-            "description": self.description,
-            "start_timestamp": self.start_timestamp,
-            "timestamp": self.timestamp,
-            "origin": self.origin,
-        }  # type: Dict[str, Any]
-
-        if self.status:
-            self._tags["status"] = self.status
-
-        if self._local_aggregator is not None:
-            metrics_summary = self._local_aggregator.to_json()
-            if metrics_summary:
-                rv["_metrics_summary"] = metrics_summary
-
-        if len(self._measurements) > 0:
-            rv["measurements"] = self._measurements
-
-        tags = self._tags
-        if tags:
-            rv["tags"] = tags
-
-        data = {}
-        data.update(self._flags)
-        data.update(self._data)
-        if data:
-            rv["data"] = data
-
-        return rv
+        if self._otel_span.status.status_code == StatusCode.UNSET:
+            return None
+        elif self._otel_span.status.status_code == StatusCode.OK:
+            return SPANSTATUS.OK
+        else:
+            return SPANSTATUS.UNKNOWN_ERROR
 
-    def get_trace_context(self):
-        # type: () -> Any
-        rv = {
-            "trace_id": self.trace_id,
-            "span_id": self.span_id,
-            "parent_span_id": self.parent_span_id,
-            "op": self.op,
-            "description": self.description,
-            "origin": self.origin,
-        }  # type: Dict[str, Any]
-        if self.status:
-            rv["status"] = self.status
-
-        if self.containing_transaction:
-            rv["dynamic_sampling_context"] = (
-                self.containing_transaction.get_baggage().dynamic_sampling_context()
-            )
+    def set_status(self, status):
+        # type: (str) -> None
+        if status == SPANSTATUS.OK:
+            otel_status = StatusCode.OK
+            otel_description = None
+        else:
+            otel_status = StatusCode.ERROR
+            otel_description = status
 
-        data = {}
+        if _OTEL_VERSION is None or _OTEL_VERSION >= (1, 12, 0):
+            self._otel_span.set_status(otel_status, otel_description)
+        else:
+            self._otel_span.set_status(Status(otel_status, otel_description))
 
-        thread_id = self._data.get(SPANDATA.THREAD_ID)
+    def set_thread(self, thread_id, thread_name):
+        # type: (Optional[int], Optional[str]) -> None
         if thread_id is not None:
-            data["thread.id"] = thread_id
-
-        thread_name = self._data.get(SPANDATA.THREAD_NAME)
-        if thread_name is not None:
-            data["thread.name"] = thread_name
-
-        if data:
-            rv["data"] = data
+            self.set_attribute(SPANDATA.THREAD_ID, str(thread_id))
 
-        return rv
-
-    def get_profile_context(self):
-        # type: () -> Optional[ProfileContext]
-        profiler_id = self._data.get(SPANDATA.PROFILER_ID)
-        if profiler_id is None:
-            return None
-
-        return {
-            "profiler_id": profiler_id,
-        }
+            if thread_name is not None:
+                self.set_attribute(SPANDATA.THREAD_NAME, thread_name)
 
     def update_active_thread(self):
         # type: () -> None
         thread_id, thread_name = get_current_thread_meta()
         self.set_thread(thread_id, thread_name)
 
-
-class Transaction(Span):
-    """The Transaction is the root element that holds all the spans
-    for Sentry performance instrumentation.
-
-    :param name: Identifier of the transaction.
-        Will show up in the Sentry UI.
-    :param parent_sampled: Whether the parent transaction was sampled.
-        If True this transaction will be kept, if False it will be discarded.
-    :param baggage: The W3C baggage header value.
-        (see https://www.w3.org/TR/baggage/)
-    :param source: A string describing the source of the transaction name.
-        This will be used to determine the transaction's type.
-        See https://develop.sentry.dev/sdk/event-payloads/transaction/#transaction-annotations
-        for more information. Default "custom".
-    :param kwargs: Additional arguments to be passed to the Span constructor.
-        See :py:class:`sentry_sdk.tracing.Span` for available arguments.
-    """
-
-    __slots__ = (
-        "name",
-        "source",
-        "parent_sampled",
-        # used to create baggage value for head SDKs in dynamic sampling
-        "sample_rate",
-        "_measurements",
-        "_contexts",
-        "_profile",
-        "_continuous_profile",
-        "_baggage",
-        "_sample_rand",
-    )
-
-    def __init__(  # type: ignore[misc]
-        self,
-        name="",  # type: str
-        parent_sampled=None,  # type: Optional[bool]
-        baggage=None,  # type: Optional[Baggage]
-        source=TransactionSource.CUSTOM,  # type: str
-        **kwargs,  # type: Unpack[SpanKwargs]
-    ):
-        # type: (...) -> None
-
-        super().__init__(**kwargs)
-
-        self.name = name
-        self.source = source
-        self.sample_rate = None  # type: Optional[float]
-        self.parent_sampled = parent_sampled
-        self._measurements = {}  # type: Dict[str, MeasurementValue]
-        self._contexts = {}  # type: Dict[str, Any]
-        self._profile = None  # type: Optional[Profile]
-        self._continuous_profile = None  # type: Optional[ContinuousProfile]
-        self._baggage = baggage
-
-        baggage_sample_rand = (
-            None if self._baggage is None else self._baggage._sample_rand()
-        )
-        if baggage_sample_rand is not None:
-            self._sample_rand = baggage_sample_rand
-        else:
-            self._sample_rand = _generate_sample_rand(self.trace_id)
-
-    def __repr__(self):
-        # type: () -> str
-        return (
-            "<%s(name=%r, op=%r, trace_id=%r, span_id=%r, parent_span_id=%r, sampled=%r, source=%r, origin=%r)>"
-            % (
-                self.__class__.__name__,
-                self.name,
-                self.op,
-                self.trace_id,
-                self.span_id,
-                self.parent_span_id,
-                self.sampled,
-                self.source,
-                self.origin,
-            )
-        )
-
-    def _possibly_started(self):
-        # type: () -> bool
-        """Returns whether the transaction might have been started.
-
-        If this returns False, we know that the transaction was not started
-        with sentry_sdk.start_transaction, and therefore the transaction will
-        be discarded.
-        """
-
-        # We must explicitly check self.sampled is False since self.sampled can be None
-        return self._span_recorder is not None or self.sampled is False
-
-    def __enter__(self):
-        # type: () -> Transaction
-        if not self._possibly_started():
-            logger.debug(
-                "Transaction was entered without being started with sentry_sdk.start_transaction."
-                "The transaction will not be sent to Sentry. To fix, start the transaction by"
-                "passing it to sentry_sdk.start_transaction."
-            )
-
-        super().__enter__()
-
-        if self._profile is not None:
-            self._profile.__enter__()
-
-        return self
-
-    def __exit__(self, ty, value, tb):
-        # type: (Optional[Any], Optional[Any], Optional[Any]) -> None
-        if self._profile is not None:
-            self._profile.__exit__(ty, value, tb)
-
-        if self._continuous_profile is not None:
-            self._continuous_profile.stop()
-
-        super().__exit__(ty, value, tb)
-
-    @property
-    def containing_transaction(self):
-        # type: () -> Transaction
-        """The root element of the span tree.
-        In the case of a transaction it is the transaction itself.
-        """
-
-        # Transactions (as spans) belong to themselves (as transactions). This
-        # is a getter rather than a regular attribute to avoid having a circular
-        # reference.
-        return self
-
-    def _get_scope_from_finish_args(
-        self,
-        scope_arg,  # type: Optional[Union[sentry_sdk.Scope, sentry_sdk.Hub]]
-        hub_arg,  # type: Optional[Union[sentry_sdk.Scope, sentry_sdk.Hub]]
-    ):
-        # type: (...) -> Optional[sentry_sdk.Scope]
-        """
-        Logic to get the scope from the arguments passed to finish. This
-        function exists for backwards compatibility with the old finish.
-
-        TODO: Remove this function in the next major version.
-        """
-        scope_or_hub = scope_arg
-        if hub_arg is not None:
-            warnings.warn(
-                "The `hub` parameter is deprecated. Please use the `scope` parameter, instead.",
-                DeprecationWarning,
-                stacklevel=3,
-            )
-
-            scope_or_hub = hub_arg
-
-        if isinstance(scope_or_hub, sentry_sdk.Hub):
-            warnings.warn(
-                "Passing a Hub to finish is deprecated. Please pass a Scope, instead.",
-                DeprecationWarning,
-                stacklevel=3,
-            )
-
-            return scope_or_hub.scope
-
-        return scope_or_hub
-
-    def finish(
-        self,
-        scope=None,  # type: Optional[sentry_sdk.Scope]
-        end_timestamp=None,  # type: Optional[Union[float, datetime]]
-        *,
-        hub=None,  # type: Optional[sentry_sdk.Hub]
-    ):
-        # type: (...) -> Optional[str]
-        """Finishes the transaction and sends it to Sentry.
-        All finished spans in the transaction will also be sent to Sentry.
-
-        :param scope: The Scope to use for this transaction.
-            If not provided, the current Scope will be used.
-        :param end_timestamp: Optional timestamp that should
-            be used as timestamp instead of the current time.
-        :param hub: The hub to use for this transaction.
-            This argument is DEPRECATED. Please use the `scope`
-            parameter, instead.
-
-        :return: The event ID if the transaction was sent to Sentry,
-            otherwise None.
-        """
-        if self.timestamp is not None:
-            # This transaction is already finished, ignore.
-            return None
-
-        # For backwards compatibility, we must handle the case where `scope`
-        # or `hub` could both either be a `Scope` or a `Hub`.
-        scope = self._get_scope_from_finish_args(
-            scope, hub
-        )  # type: Optional[sentry_sdk.Scope]
-
-        scope = scope or self.scope or sentry_sdk.get_current_scope()
-        client = sentry_sdk.get_client()
-
-        if not client.is_active():
-            # We have no active client and therefore nowhere to send this transaction.
-            return None
-
-        if self._span_recorder is None:
-            # Explicit check against False needed because self.sampled might be None
-            if self.sampled is False:
-                logger.debug("Discarding transaction because sampled = False")
-            else:
-                logger.debug(
-                    "Discarding transaction because it was not started with sentry_sdk.start_transaction"
-                )
-
-            # This is not entirely accurate because discards here are not
-            # exclusively based on sample rate but also traces sampler, but
-            # we handle this the same here.
-            if client.transport and has_tracing_enabled(client.options):
-                if client.monitor and client.monitor.downsample_factor > 0:
-                    reason = "backpressure"
-                else:
-                    reason = "sample_rate"
-
-                client.transport.record_lost_event(reason, data_category="transaction")
-
-                # Only one span (the transaction itself) is discarded, since we did not record any spans here.
-                client.transport.record_lost_event(reason, data_category="span")
-            return None
-
-        if not self.name:
-            logger.warning(
-                "Transaction has no name, falling back to `<unlabeled transaction>`."
-            )
-            self.name = "<unlabeled transaction>"
-
-        super().finish(scope, end_timestamp)
-
-        if not self.sampled:
-            # At this point a `sampled = None` should have already been resolved
-            # to a concrete decision.
-            if self.sampled is None:
-                logger.warning("Discarding transaction without sampling decision.")
-
-            return None
-
-        finished_spans = [
-            span.to_json()
-            for span in self._span_recorder.spans
-            if span.timestamp is not None
-        ]
-
-        len_diff = len(self._span_recorder.spans) - len(finished_spans)
-        dropped_spans = len_diff + self._span_recorder.dropped_spans
-
-        # we do this to break the circular reference of transaction -> span
-        # recorder -> span -> containing transaction (which is where we started)
-        # before either the spans or the transaction goes out of scope and has
-        # to be garbage collected
-        self._span_recorder = None
-
-        contexts = {}
-        contexts.update(self._contexts)
-        contexts.update({"trace": self.get_trace_context()})
-        profile_context = self.get_profile_context()
-        if profile_context is not None:
-            contexts.update({"profile": profile_context})
-
-        event = {
-            "type": "transaction",
-            "transaction": self.name,
-            "transaction_info": {"source": self.source},
-            "contexts": contexts,
-            "tags": self._tags,
-            "timestamp": self.timestamp,
-            "start_timestamp": self.start_timestamp,
-            "spans": finished_spans,
-        }  # type: Event
-
-        if dropped_spans > 0:
-            event["_dropped_spans"] = dropped_spans
-
-        if self._profile is not None and self._profile.valid():
-            event["profile"] = self._profile
-            self._profile = None
-
-        event["measurements"] = self._measurements
-
-        # This is here since `to_json` is not invoked.  This really should
-        # be gone when we switch to onlyspans.
-        if self._local_aggregator is not None:
-            metrics_summary = self._local_aggregator.to_json()
-            if metrics_summary:
-                event["_metrics_summary"] = metrics_summary
-
-        return scope.capture_event(event)
-
-    def set_measurement(self, name, value, unit=""):
-        # type: (str, float, MeasurementUnit) -> None
-        """
-        .. deprecated:: 2.28.0
-            This function is deprecated and will be removed in the next major release.
-        """
-
-        warnings.warn(
-            "`set_measurement()` is deprecated and will be removed in the next major version. Please use `set_data()` instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        self._measurements[name] = {"value": value, "unit": unit}
-
-    def set_context(self, key, value):
-        # type: (str, dict[str, Any]) -> None
-        """Sets a context. Transactions can have multiple contexts
-        and they should follow the format described in the "Contexts Interface"
-        documentation.
-
-        :param key: The name of the context.
-        :param value: The information about the context.
-        """
-        self._contexts[key] = value
-
     def set_http_status(self, http_status):
         # type: (int) -> None
-        """Sets the status of the Transaction according to the given HTTP status.
-
-        :param http_status: The HTTP status code."""
-        super().set_http_status(http_status)
-        self.set_context("response", {"status_code": http_status})
-
-    def to_json(self):
-        # type: () -> Dict[str, Any]
-        """Returns a JSON-compatible representation of the transaction."""
-        rv = super().to_json()
-
-        rv["name"] = self.name
-        rv["source"] = self.source
-        rv["sampled"] = self.sampled
-
-        return rv
-
-    def get_trace_context(self):
-        # type: () -> Any
-        trace_context = super().get_trace_context()
-
-        if self._data:
-            trace_context["data"] = self._data
-
-        return trace_context
-
-    def get_baggage(self):
-        # type: () -> Baggage
-        """Returns the :py:class:`~sentry_sdk.tracing_utils.Baggage`
-        associated with the Transaction.
-
-        The first time a new baggage with Sentry items is made,
-        it will be frozen."""
-        if not self._baggage or self._baggage.mutable:
-            self._baggage = Baggage.populate_from_transaction(self)
-
-        return self._baggage
-
-    def _set_initial_sampling_decision(self, sampling_context):
-        # type: (SamplingContext) -> None
-        """
-        Sets the transaction's sampling decision, according to the following
-        precedence rules:
-
-        1. If a sampling decision is passed to `start_transaction`
-        (`start_transaction(name: "my transaction", sampled: True)`), that
-        decision will be used, regardless of anything else
-
-        2. If `traces_sampler` is defined, its decision will be used. It can
-        choose to keep or ignore any parent sampling decision, or use the
-        sampling context data to make its own decision or to choose a sample
-        rate for the transaction.
-
-        3. If `traces_sampler` is not defined, but there's a parent sampling
-        decision, the parent sampling decision will be used.
-
-        4. If `traces_sampler` is not defined and there's no parent sampling
-        decision, `traces_sample_rate` will be used.
-        """
-        client = sentry_sdk.get_client()
-
-        transaction_description = "{op}transaction <{name}>".format(
-            op=("<" + self.op + "> " if self.op else ""), name=self.name
-        )
-
-        # nothing to do if tracing is disabled
-        if not has_tracing_enabled(client.options):
-            self.sampled = False
-            return
-
-        # if the user has forced a sampling decision by passing a `sampled`
-        # value when starting the transaction, go with that
-        if self.sampled is not None:
-            self.sample_rate = float(self.sampled)
-            return
-
-        # we would have bailed already if neither `traces_sampler` nor
-        # `traces_sample_rate` were defined, so one of these should work; prefer
-        # the hook if so
-        sample_rate = (
-            client.options["traces_sampler"](sampling_context)
-            if callable(client.options.get("traces_sampler"))
-            else (
-                # default inheritance behavior
-                sampling_context["parent_sampled"]
-                if sampling_context["parent_sampled"] is not None
-                else client.options["traces_sample_rate"]
-            )
-        )
-
-        # Since this is coming from the user (or from a function provided by the
-        # user), who knows what we might get. (The only valid values are
-        # booleans or numbers between 0 and 1.)
-        if not is_valid_sample_rate(sample_rate, source="Tracing"):
-            logger.warning(
-                "[Tracing] Discarding {transaction_description} because of invalid sample rate.".format(
-                    transaction_description=transaction_description,
-                )
-            )
-            self.sampled = False
-            return
-
-        self.sample_rate = float(sample_rate)
-
-        if client.monitor:
-            self.sample_rate /= 2**client.monitor.downsample_factor
-
-        # if the function returned 0 (or false), or if `traces_sample_rate` is
-        # 0, it's a sign the transaction should be dropped
-        if not self.sample_rate:
-            logger.debug(
-                "[Tracing] Discarding {transaction_description} because {reason}".format(
-                    transaction_description=transaction_description,
-                    reason=(
-                        "traces_sampler returned 0 or False"
-                        if callable(client.options.get("traces_sampler"))
-                        else "traces_sample_rate is set to 0"
-                    ),
-                )
-            )
-            self.sampled = False
-            return
-
-        # Now we roll the dice.
-        self.sampled = self._sample_rand < Decimal.from_float(self.sample_rate)
-
-        if self.sampled:
-            logger.debug(
-                "[Tracing] Starting {transaction_description}".format(
-                    transaction_description=transaction_description,
-                )
-            )
-        else:
-            logger.debug(
-                "[Tracing] Discarding {transaction_description} because it's not included in the random sample (sampling rate = {sample_rate})".format(
-                    transaction_description=transaction_description,
-                    sample_rate=self.sample_rate,
-                )
-            )
-
-
-class NoOpSpan(Span):
-    def __repr__(self):
-        # type: () -> str
-        return "<%s>" % self.__class__.__name__
-
-    @property
-    def containing_transaction(self):
-        # type: () -> Optional[Transaction]
-        return None
-
-    def start_child(self, instrumenter=INSTRUMENTER.SENTRY, **kwargs):
-        # type: (str, **Any) -> NoOpSpan
-        return NoOpSpan()
-
-    def to_traceparent(self):
-        # type: () -> str
-        return ""
-
-    def to_baggage(self):
-        # type: () -> Optional[Baggage]
-        return None
-
-    def get_baggage(self):
-        # type: () -> Optional[Baggage]
-        return None
-
-    def iter_headers(self):
-        # type: () -> Iterator[Tuple[str, str]]
-        return iter(())
-
-    def set_tag(self, key, value):
-        # type: (str, Any) -> None
-        pass
-
-    def set_data(self, key, value):
-        # type: (str, Any) -> None
-        pass
-
-    def set_status(self, value):
-        # type: (str) -> None
-        pass
-
-    def set_http_status(self, http_status):
-        # type: (int) -> None
-        pass
+        self.set_attribute(SPANDATA.HTTP_STATUS_CODE, http_status)
+        self.set_status(get_span_status_from_http_code(http_status))
 
     def is_success(self):
         # type: () -> bool
-        return True
+        return self.status == SPANSTATUS.OK
+
+    def finish(self, end_timestamp=None):
+        # type: (Optional[Union[float, datetime]]) -> None
+        if end_timestamp is not None:
+            self._otel_span.end(convert_to_otel_timestamp(end_timestamp))
+        else:
+            self._otel_span.end()
 
     def to_json(self):
-        # type: () -> Dict[str, Any]
-        return {}
+        # type: () -> dict[str, Any]
+        """
+        Only meant for testing. Not used internally anymore.
+        """
+        if not isinstance(self._otel_span, ReadableSpan):
+            return {}
+        return json.loads(self._otel_span.to_json())
 
     def get_trace_context(self):
-        # type: () -> Any
-        return {}
+        # type: () -> dict[str, Any]
+        if not isinstance(self._otel_span, ReadableSpan):
+            return {}
 
-    def get_profile_context(self):
-        # type: () -> Any
-        return {}
+        return get_trace_context(self._otel_span)
 
-    def finish(
-        self,
-        scope=None,  # type: Optional[sentry_sdk.Scope]
-        end_timestamp=None,  # type: Optional[Union[float, datetime]]
-        *,
-        hub=None,  # type: Optional[sentry_sdk.Hub]
-    ):
-        # type: (...) -> Optional[str]
-        """
-        The `hub` parameter is deprecated. Please use the `scope` parameter, instead.
-        """
-        pass
+    def set_context(self, key, value):
+        # type: (str, Any) -> None
+        # TODO-neel-potel we cannot add dicts here
 
-    def set_measurement(self, name, value, unit=""):
-        # type: (str, float, MeasurementUnit) -> None
-        pass
+        self.set_attribute(f"{SentrySpanAttribute.CONTEXT}.{key}", value)
 
-    def set_context(self, key, value):
-        # type: (str, dict[str, Any]) -> None
-        pass
+    def set_flag(self, flag, value):
+        # type: (str, bool) -> None
+        flag_count = self.get_attribute("_flag.count") or 0
+        if flag_count < _FLAGS_CAPACITY:
+            self.set_attribute(f"flag.evaluation.{flag}", value)
+            self.set_attribute("_flag.count", flag_count + 1)
 
-    def init_span_recorder(self, maxlen):
-        # type: (int) -> None
-        pass
 
-    def _set_initial_sampling_decision(self, sampling_context):
-        # type: (SamplingContext) -> None
-        pass
+# TODO-neel-potel add deprecation
+Transaction = Span
 
 
 if TYPE_CHECKING:
@@ -1369,20 +640,3 @@ def trace(func=None):
         return start_child_span_decorator(func)
     else:
         return start_child_span_decorator
-
-
-# Circular imports
-
-from sentry_sdk.tracing_utils import (
-    Baggage,
-    EnvironHeaders,
-    extract_sentrytrace_data,
-    _generate_sample_rand,
-    has_tracing_enabled,
-    maybe_create_breadcrumbs_from_span,
-)
-
-with warnings.catch_warnings():
-    # The code in this file which uses `LocalAggregator` is only called from the deprecated `metrics` module.
-    warnings.simplefilter("ignore", DeprecationWarning)
-    from sentry_sdk.metrics import LocalAggregator