wip

Author: sentrivana

sentry_sdk/api.py

@@ -70,6 +70,7 @@ def overload(x):
     "set_tags",
     "set_user",
     "start_span",
+    "start_inactive_span",
     "start_transaction",
 ]
 

sentry_sdk/tracing.py

@@ -3,7 +3,7 @@
 from datetime import datetime, timedelta, timezone
 
 from opentelemetry import trace as otel_trace, context
-from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.trace.status import StatusCode
 
 import sentry_sdk
 from sentry_sdk.consts import INSTRUMENTER, SPANDATA
@@ -153,6 +153,8 @@ class TransactionKwargs(SpanKwargs, total=False):
     "url": TRANSACTION_SOURCE_ROUTE,
 }
 
+tracer = otel_trace.get_tracer(__name__)
+
 
 class _SpanRecorder:
     """Limits the number of spans recorded in a transaction."""
@@ -1160,32 +1162,158 @@ def _set_initial_sampling_decision(self, sampling_context):
         pass
 
 
-class OTelSpanWrapper:
+class POTelSpan:
     """
-    Light-weight OTel span wrapper.
-
-    Meant for providing some level of compatibility with the old span interface.
+    OTel span wrapper providing compatibility with the old span interface.
     """
 
-    def __init__(self, otel_span=None, **kwargs):
-        # type: (Optional[ReadableSpan]) -> None
-        self.description = kwargs.get("description")
-        self._otel_span = otel_span
+    # XXX Maybe it makes sense to repurpose the existing Span class for this.
+    # For now I'm keeping this class separate to have a clean slate.
+
+    # XXX The wrapper itself should have as little state as possible.
+
+    def __init__(
+        self,
+        active=True,  # type: bool
+        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]
+        status=None,  # type: Optional[str]
+        containing_transaction=None,  # type: Optional[Transaction]
+        start_timestamp=None,  # type: Optional[Union[datetime, float]]
+        scope=None,  # type: Optional[sentry_sdk.Scope]
+        origin="manual",  # type: str
+    ):
+        # type: (...) -> None
+        self._otel_span = tracer.start_span(description or "")
+        self._active = active
+        # XXX
 
     def __enter__(self):
-        # type: () -> OTelSpanWrapper
-        # Creates a Context object with parent set as current span
-        ctx = otel_trace.set_span_in_context(self._otel_span)
-        # Set as the implicit current context
-        self._ctx_token = context.attach(ctx)
+        # type: () -> POTelSpan
+        # create a Context object with parent set as current span
+        if self._active:
+            ctx = otel_trace.set_span_in_context(self._otel_span)
+            # set as the implicit current context
+            self._ctx_token = context.attach(ctx)
+
         return self
 
     def __exit__(self, ty, value, tb):
         # type: (Optional[Any], Optional[Any], Optional[Any]) -> None
         self._otel_span.end()
-        context.detach(self._ctx_token)
+
+        if self._active:
+            context.detach(self._ctx_token)
+
+    @property
+    def containing_transaction(self):
+        # type: () -> Optional[Transaction]
+        pass
 
     def start_child(self, **kwargs):
+        # type: (str, **Any) -> POTelSpan
+        pass
+
+    @classmethod
+    def continue_from_environ(
+        cls,
+        environ,  # type: Mapping[str, str]
+        **kwargs,  # type: Any
+    ):
+        # type: (...) -> POTelSpan
+        pass
+
+    @classmethod
+    def continue_from_headers(
+        cls,
+        headers,  # type: Mapping[str, str]
+        **kwargs,  # type: Any
+    ):
+        # type: (...) -> POTelSpan
+        pass
+
+    def iter_headers(self):
+        # type: () -> Iterator[Tuple[str, str]]
+        pass
+
+    @classmethod
+    def from_traceparent(
+        cls,
+        traceparent,  # type: Optional[str]
+        **kwargs,  # type: Any
+    ):
+        # type: (...) -> Optional[Transaction]
+        pass
+
+    def to_traceparent(self):
+        # type: () -> str
+        pass
+
+    def to_baggage(self):
+        # type: () -> Optional[Baggage]
+        pass
+
+    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, status):
+        # type: (str) -> None
+        pass
+
+    def set_measurement(self, name, value, unit=""):
+        # type: (str, float, MeasurementUnit) -> None
+        pass
+
+    def set_thread(self, thread_id, thread_name):
+        # type: (Optional[int], Optional[str]) -> None
+        pass
+
+    def set_profiler_id(self, profiler_id):
+        # type: (Optional[str]) -> None
+        pass
+
+    def set_http_status(self, http_status):
+        # type: (int) -> None
+        pass
+
+    def is_success(self):
+        # type: () -> bool
+        return self._otel_span.status.code == StatusCode.OK
+
+    def finish(self, scope=None, end_timestamp=None):
+        # type: (Optional[sentry_sdk.Scope], Optional[Union[float, datetime]]) -> Optional[str]
+        pass
+
+    def to_json(self):
+        # type: () -> dict[str, Any]
+        pass
+
+    def get_trace_context(self):
+        # type: () -> Any
+        pass
+
+    def get_profile_context(self):
+        # type: () -> Optional[ProfileContext]
+        pass
+
+    # transaction/root span methods
+
+    def set_context(self, key, value):
+        # type: (str, Any) -> None
+        pass
+
+    def get_baggage(self):
+        # type: () -> Baggage
         pass
 
 
@@ -1232,18 +1360,16 @@ async def my_async_function():
 
 
 def start_span(**kwargs):
-    otel_span = otel_trace.get_tracer(__name__).start_span()
-    span = OTelSpanWrapper(otel_span=otel_span, **kwargs)
-    return span
+    return POTelSpan(active=True, **kwargs)
 
 
 def start_inactive_span(**kwargs):
-    pass
+    return POTelSpan(active=False, **kwargs)
 
 
 def start_transaction(**kwargs):
     # XXX force_transaction?
-    pass
+    return POTelSpan(active=True, **kwargs)
 
 
 # Circular imports