debug etc

Author: sentrivana

sentry_sdk/_span_batcher.py

@@ -112,6 +112,7 @@ def add(self, span):
                 self.get_size() >= self.MAX_SPANS_BEFORE_FLUSH
             ):  # TODO[span-first] should this be per bucket?
                 self._flush_event.set()
+            print(self._span_buffer)
 
     def kill(self):
         # type: (...) -> None
@@ -132,19 +133,19 @@ def _span_to_transport_format(span):
         res = {
             "trace_id": span.trace_id,
             "span_id": span.span_id,
-            "name": span.name,
+            "name": span.description,  # TODO[span-first]
             "status": SPANSTATUS.OK
             if span.status in (SPANSTATUS.OK, SPANSTATUS.UNSET)
             else SPANSTATUS.ERROR,
             "is_segment": span.containing_transaction == span,
-            "start_timestamp": span.start_timestamp,
-            "end_timestamp": span.timestamp,
+            "start_timestamp": span.start_timestamp.timestamp(),  # TODO[span-first]
+            "end_timestamp": span.timestamp.timestamp(),
         }
 
         if span.parent_span_id:
             res["parent_span_id"] = span.parent_span_id
 
-        if span["attributes"]:
+        if span.attributes:
             res["attributes"] = {
                 k: format_attribute_value(v) for (k, v) in span["attributes"].items()
             }
@@ -157,7 +158,7 @@ def _flush(self):
             if len(self._span_buffer) == 0:
                 return None
 
-            for trace_id, spans in self._span_buffer:
+            for trace_id, spans in self._span_buffer.items():
                 envelope = Envelope(
                     headers={
                         "sent_at": format_timestamp(datetime.now(timezone.utc)),

sentry_sdk/tracing.py

@@ -282,6 +282,7 @@ class Span:
         "_flags",
         "_flags_capacity",
         "_mode",
+        "attributes",
     )
 
     def __init__(
@@ -300,6 +301,7 @@ def __init__(
         scope=None,  # type: Optional[sentry_sdk.Scope]
         origin="manual",  # type: str
         name=None,  # type: Optional[str]
+        attributes=None,  # type: Optional[dict]
     ):
         # type: (...) -> None
         self._trace_id = trace_id
@@ -319,6 +321,8 @@ def __init__(
         self._containing_transaction = containing_transaction
         self._flags = {}  # type: Dict[str, bool]
         self._flags_capacity = 10
+        self.attributes = attributes or {}
+        # TODO[span-first]: fill attributes
 
         if hub is not None:
             warnings.warn(
@@ -676,22 +680,7 @@ def is_success(self):
         # type: () -> bool
         return self.status == "ok"
 
-    def finish(self, scope=None, end_timestamp=None):
-        # type: (Optional[sentry_sdk.Scope], Optional[Union[float, datetime]]) -> 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`.
-        """
+    def _finish(self, scope=None, end_timestamp=None):
         if self.timestamp is not None:
             # This span is already finished, ignore.
             return None
@@ -712,12 +701,31 @@ def finish(self, scope=None, end_timestamp=None):
         scope = scope or sentry_sdk.get_current_scope()
         maybe_create_breadcrumbs_from_span(scope, self)
 
+    def finish(self, scope=None, end_timestamp=None):
+        # type: (Optional[sentry_sdk.Scope], Optional[Union[float, datetime]]) -> 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`.
+        """
+        self._finish(scope, end_timestamp)
+
         client = sentry_sdk.get_client()
         if client.is_active():
             if (
                 has_span_streaming_enabled(client.options)
                 and self.containing_transaction.sampled
             ):
+                logger.debug(f"[Tracing] Adding span {self.span_id} to buffer")
                 client._span_batcher.add(self)
 
         return None
@@ -1048,11 +1056,12 @@ def finish(
             )
             self.name = "<unlabeled transaction>"
 
-        super().finish(scope, end_timestamp)
+        super()._finish(scope, end_timestamp)
 
         status_code = self._data.get(SPANDATA.HTTP_STATUS_CODE)
         if (
-            status_code is not None
+            self._mode == "static"
+            and status_code is not None
             and status_code in client.options["trace_ignore_status_codes"]
         ):
             logger.debug(
@@ -1084,6 +1093,11 @@ def finish(
 
             return None
 
+        if self._mode == "stream" and self.containing_transaction.sampled:
+            logger.debug(f"[Tracing] Adding span {self.span_id} to buffer")
+            client._span_batcher.add(self)
+            return
+
         finished_spans = [
             span.to_json()
             for span in self._span_recorder.spans

sentry_sdk/transport.py

@@ -471,12 +471,23 @@ def _send_envelope(self, envelope):
         if content_encoding:
             headers["Content-Encoding"] = content_encoding
 
-        self._send_request(
-            body.getvalue(),
-            headers=headers,
-            endpoint_type=EndpointType.ENVELOPE,
-            envelope=envelope,
-        )
+        print("ENVELOPE")
+        print(envelope.headers)
+        for i, item in enumerate(envelope.items):
+            print("Item", i, item.type)
+            print(item.headers)
+            print(item.payload.json)
+            print()
+
+        print("-----------------------------------")
+        print()
+
+        # self._send_request(
+        #    body.getvalue(),
+        #    headers=headers,
+        #    endpoint_type=EndpointType.ENVELOPE,
+        #    envelope=envelope,
+        # )
         return None
 
     def _serialize_envelope(self, envelope):