build(deps): bump codecov/codecov-action from 5.1.2 to 5.3.1 (#3995)

<!-- Describe your PR here -->

---

Thank you for contributing to `sentry-python`! Please add tests to validate your changes, and lint your code using `tox -e linters`.

Running the test suite on your PR might require maintainer approval. The AWS Lambda tests additionally require a maintainer to add a special label, and they will fail until this label is added.

Author: constantinius

sentry_sdk/client.py

@@ -488,7 +488,11 @@ def _prepare_event(
 
         if scope is not None:
             is_transaction = event.get("type") == "transaction"
-            spans_before = len(event.get("spans", []))
+            spans = event.get("spans", [])
+            from sentry_sdk.utils import AnnotatedValue
+            if isinstance(spans, AnnotatedValue):
+                spans = spans.value
+            spans_before = len(spans)
             event_ = scope.apply_to_event(event, hint, self.options)
 
             # one of the event/error processors returned None
@@ -508,7 +512,10 @@ def _prepare_event(
 
             event = event_
 
-            spans_delta = spans_before - len(event.get("spans", []))
+            spans = event.get("spans", [])
+            if isinstance(spans, AnnotatedValue):
+                spans = spans.value
+            spans_delta = spans_before - len(spans)
             if is_transaction and spans_delta > 0 and self.transport is not None:
                 self.transport.record_lost_event(
                     "event_processor", data_category="span", quantity=spans_delta

sentry_sdk/serializer.py

@@ -382,6 +382,7 @@ def _serialize_node_impl(
         serialized_event = _serialize_node(event, **kwargs)
         if not is_vars and meta_stack and isinstance(serialized_event, dict):
             serialized_event["_meta"] = meta_stack[0]
+        print(serialized_event["_meta"])
 
         return serialized_event
     finally:

sentry_sdk/tracing.py

@@ -11,6 +11,7 @@
     is_valid_sample_rate,
     logger,
     nanosecond_time,
+    AnnotatedValue
 )
 
 from typing import TYPE_CHECKING
@@ -193,7 +194,7 @@ def get_span_status_from_http_code(http_status_code):
 class _SpanRecorder:
     """Limits the number of spans recorded in a transaction."""
 
-    __slots__ = ("maxlen", "spans")
+    __slots__ = ("maxlen", "spans", "dropped_spans")
 
     def __init__(self, maxlen):
         # type: (int) -> None
@@ -203,15 +204,53 @@ def __init__(self, maxlen):
         # 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.spans = []  # type: Union[List[Span], AnnotatedValue]
+        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)
 
+    
+
+
+
+
+
+    # __slots__ = ("maxlen", "_spans")
+
+    # def __init__(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: Union[List[Span], AnnotatedValue]
+
+    # def add(self, span):
+    #     # type: (Span) -> None
+    #     if isinstance(self._spans, AnnotatedValue):
+    #         self._spans.metadata["len"] += 1
+    #     else:
+    #         if len(self._spans) > self.maxlen:
+    #             span._span_recorder = None
+    #             self._spans = AnnotatedValue(self._spans, {"len": self.maxlen}) # TODO!
+    #         else:
+    #             self._spans.append(span)
+
+    # @property
+    # def spans(self):
+    #     # type: () -> List[Span]
+    #     if isinstance(self._spans, AnnotatedValue):
+    #         return self._spans.value
+    #     return self._spans
+
 
 class Span:
     """A span holds timing information of a block of code.
@@ -972,6 +1011,10 @@ def finish(
             if span.timestamp is not None
         ]
 
+        len_diff = len(self._span_recorder.spans) - len(finished_spans)
+        if len_diff or self._span_recorder.dropped_spans:
+            finished_spans = AnnotatedValue(finished_spans, {"len": 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