@@ -1,5 +1,8 @@
+from unittest import mock
+
 import pytest
 
+from posthog.tracing import _limits as limits_module
 from posthog.tracing._limits import (
     bound_attributes,
     truncate_attribute_value,
@@ -19,6 +22,13 @@ class TestTruncateAttributeValue:
     def test_truncates_a_long_string(self):
         assert truncate_attribute_value("x" * 40000, 8192) == "x" * 8192
 
+    def test_never_walks_a_scalar(self):
+        with mock.patch.object(limits_module, "_truncate") as walk:
+            assert truncate_attribute_value("short", 8) == "short"
+            assert truncate_attribute_value(7, 8) == 7
+            assert truncate_attribute_value(None, 8) is None
+        assert not walk.called
+
     def test_returns_a_short_string_unchanged(self):
         assert truncate_attribute_value("short", 8192) == "short"
 
@@ -138,8 +148,10 @@ def test_bounds_each_value(self):
         attributes, _ = bound_attributes({"a": "x" * 20}, 2, 5)
         assert attributes == {"a": "xxxxx"}
 
-    def test_a_non_mapping_yields_nothing(self):
-        assert bound_attributes(["a"], 2, 5) == ({}, 0)
+    def test_an_empty_key_spends_no_slot_and_counts_no_drop(self):
+        attributes, dropped = bound_attributes({"": 1, "b": 2, "c": 3}, 2, 8)
+        assert attributes == {"b": 2, "c": 3}
+        assert dropped == 0
 
 
 class TestTruncateAttributes:
 
@@ -12,7 +12,7 @@
 
 from posthog.tracing import _span as span_module
 from posthog.tracing._config import MAX_ATTRIBUTES_PER_EVENT
-from posthog.tracing._otlp import SpanRecord, build_otlp_span
+from posthog.tracing._otlp import CIRCULAR_VALUE, SpanRecord, build_otlp_span
 from posthog.tracing._sanitize import (
     FALLBACK_SPAN_NAME,
     FUNCTION_VALUE,
@@ -793,14 +793,34 @@ def test_truncates_event_attributes_names_and_status_messages(self):
         assert record.events[0].attributes == {"k": "long"}
         assert record.status.message == "long"
 
-    def test_a_self_referencing_attribute_ends_the_span(self):
+    def test_a_self_referencing_attribute_is_stored_as_the_encoders_marker(self):
         records: list = []
         value: dict = {}
         value["self"] = value
         span = make_span(records)
         span.set_attribute("loop", value)
         span.end()
-        assert len(records) == 1
+        assert records[0].attributes["loop"] == {"self": CIRCULAR_VALUE}
+
+    def test_an_empty_key_spends_no_slot(self):
+        records: list = []
+        span = make_span(records, max_attributes=1)
+        span.set_attribute("", 1).set_attribute("real", 2)
+        span.set_attributes({"": 3})
+        span.add_event("e", {"": 1, "k": 2})
+        span.end()
+        assert records[0].attributes == {"real": 2}
+        assert records[0].dropped_attributes_count == 0
+        assert records[0].events[0].attributes == {"k": 2}
+
+    def test_add_event_with_a_non_mapping_logs_and_keeps_the_event(self, caplog):
+        records: list = []
+        span = make_span(records)
+        with caplog.at_level("DEBUG", logger="posthog"):
+            span.add_event("e", ["not", "a", "mapping"])
+        span.end()
+        assert records[0].events[0].attributes == {}
+        assert "expected a mapping" in caplog.text
 
 
 class TestExceptionStacktrace:
@@ -823,9 +843,9 @@ def test_omits_the_stack_of_an_exception_that_was_never_raised(self):
         span.end()
         assert "exception.stacktrace" not in records[0].events[0].attributes
 
-    def test_bounds_the_stack_keeping_the_crash_site(self):
-        # Python lists the most recent call last, so the tail is what matters:
-        # the raising frame and the exception line.
+    def test_bounds_the_stack_keeping_the_outermost_exception(self):
+        # Python prints a cause first and the outermost exception last, so
+        # the tail keeps the outermost raise and may cut the cause off.
         def recurse(depth):
             if depth == 0:
                 raise ValueError("the actual crash site")
 
@@ -36,6 +36,11 @@ def truncate_attribute_value(value: Any, max_length: int) -> Any:
 
     A value that cannot be walked is returned as it is.
     """
+    # The common case never allocates a walk.
+    if isinstance(value, str):
+        return truncate_string(value, max_length)
+    if value is None or isinstance(value, (bool, int, float)):
+        return value
     try:
         return _truncate(value, max_length, _WalkState(), 0)
     except Exception:
@@ -113,32 +118,20 @@ def _truncate_items(value: Any, max_length: int, state: _WalkState, depth: int)
 
 
 def bound_attributes(
-    source: Any, max_count: int, max_length: int
+    source: Mapping[str, Any], max_count: int, max_length: int
 ) -> Tuple[Dict[str, Any], int]:
-    """A copy of ``source`` with at most ``max_count`` entries, each bounded, and
-    how many entries the cap refused. A ``None`` value spends no slot."""
-    if not isinstance(source, Mapping):
-        return {}, 0
-    try:
-        keys = list(source.keys())
-    except Exception:
-        return {}, 0
+    """A copy of a ``copy_user_attributes`` result with at most ``max_count``
+    entries, each bounded, and how many entries the cap refused. An empty key
+    or a ``None`` value spends no slot."""
     attributes: Dict[str, Any] = {}
     dropped = 0
-    for key in keys:
-        key_str = attribute_key(key)
-        if key_str is None:
-            continue
-        try:
-            value = source[key]
-        except Exception:
-            value = UNSERIALIZABLE_VALUE
-        if value is None:
+    for key, value in source.items():
+        if not key or value is None:
             continue
-        if len(attributes) >= max_count and key_str not in attributes:
+        if len(attributes) >= max_count and key not in attributes:
             dropped += 1
             continue
-        attributes[key_str] = truncate_attribute_value(value, max_length)
+        attributes[key] = truncate_attribute_value(value, max_length)
     return attributes, dropped
 
 
 
@@ -193,7 +193,8 @@ def _exception_event_attributes(
         "exception.type": exc_type,
         "exception.message": message,
     }
-    # The tail is kept: Python lists the raising frame last.
+    # The tail is kept: Python lists the raising frame last. For a chained
+    # exception that is the outermost one; a cause printed above it goes first.
     stacktrace = describe_stacktrace(error)
     if stacktrace:
         attributes["exception.stacktrace"] = stacktrace[-max_length:]
@@ -277,6 +278,10 @@ def _mutable(self, operation: str) -> bool:
 
     def _write_attribute(self, key: str, value: Any) -> None:
         """Write an attribute unless the span is at its cap of distinct user keys."""
+        if not key:
+            # The encoder drops it, so it must not spend a slot.
+            log.debug("Dropping an attribute with an empty key")
+            return
         if value is None:
             # None removes the key, freeing its slot.
             if key in self._attributes and key not in self._auto_keys:
@@ -322,7 +327,7 @@ def add_event(
             dropped = 0
             if attributes is not None:
                 bounded, dropped = bound_attributes(
-                    attributes,
+                    copy_user_attributes({}, attributes),
                     MAX_ATTRIBUTES_PER_EVENT,
                     self._max_attribute_value_length,
                 )
 
@@ -84,7 +84,8 @@ def record_exception(self, exception: BaseException) -> "Span":
         Ignored after ``end()``. The event carries ``exception.type``,
         ``exception.message`` and, for a raised exception,
         ``exception.stacktrace`` (its last ``max_attribute_value_length``
-        characters). Returns the span, so calls chain. Inside
+        characters, so a chained traceback keeps the outermost exception and
+        may lose its cause). Returns the span, so calls chain. Inside
         ``with span:`` a raised ``Exception`` is recorded automatically, so
         this is for exceptions that are caught and handled.