Add tracking metric, nr.pg & error attrs

Author: hmstepanek

newrelic/core/attribute.py

@@ -125,6 +125,12 @@
     "span.kind",
 }
 
+SPAN_ERROR_ATTRIBUTES = {
+    "error.class",
+    "error.message",
+    "error.expected",
+}
+
 
 MAX_NUM_USER_ATTRIBUTES = 128
 MAX_ATTRIBUTE_LENGTH = 255

newrelic/core/node_mixin.py

@@ -84,7 +84,13 @@ def span_event(
                 ct_exit_spans = {}
 
             partial_granularity_type = settings.distributed_tracing.sampler.partial_granularity.type
-            exit_span_attrs_present = attribute.SPAN_ENTITY_RELATIONSHIP_ATTRIBUTES & set(a_attrs)
+            a_attrs_set = set(a_attrs)
+            exit_span_attrs_present = attribute.SPAN_ENTITY_RELATIONSHIP_ATTRIBUTES & a_attrs_set
+            exit_span_error_attrs_present = attribute.SPAN_ERROR_ATTRIBUTES & a_attrs_set
+            # If this is an entry span, add `nr.pg` to indicate transaction is partial
+            # granularity sampled.
+            if i_attrs.get("nr.entryPoint"):
+                a_attrs["nr.pg"] = True
             # If this is the entry node or an LLM span always return it.
             if i_attrs.get("nr.entryPoint") or i_attrs["name"].startswith("Llm/"):
                 if partial_granularity_type == "reduced":
@@ -99,7 +105,7 @@ def span_event(
             if partial_granularity_type == "reduced":
                 return [i_attrs, u_attrs, a_attrs]
             else:
-                a_minimized_attrs = attr_class({key: a_attrs[key] for key in exit_span_attrs_present})
+                a_minimized_attrs = attr_class({key: a_attrs[key] for key in (exit_span_attrs_present | exit_span_error_attrs_present)})
                 # If we are in essential mode return the span with minimized attributes.
                 if partial_granularity_type == "essential":
                     return [i_attrs, {}, a_minimized_attrs]
@@ -117,11 +123,17 @@ def span_event(
                     a_minimized_attrs["nr.durations"] = self.duration
                     ct_exit_spans[span_attrs] = [i_attrs, a_minimized_attrs]
                     return [i_attrs, {}, a_minimized_attrs]
-                # If this is an exit span we've already seen, add it's guid to the list
+                # If this is an exit span we've already seen, add the error attributes
+                # (last occurring error takes precedence), add it's guid to the list
                 # of ids on the seen span, compute the new duration & start time, and
                 # return None.
-                ct_exit_spans[span_attrs][1]["nr.ids"].append(self.guid)
+                ct_exit_spans[span_attrs][1].update(attr_class({key: a_minimized_attrs[key] for key in a_error_attrs}))
                 # Max size for `nr.ids` = 1024. Max length = 63 (each span id is 16 bytes + 8 bytes for list type).
+                if len(ct_exit_spans[span_attrs][1]["nr.ids"]) < 63:
+                    ct_exit_spans[span_attrs][1]["nr.ids"].append(self.guid)
+                else:
+                    ct_exit_spans["dropped_ids"] += 1
+
                 ct_exit_spans[span_attrs][1]["nr.ids"] = ct_exit_spans[span_attrs][1]["nr.ids"][:63]
                 # Compute the new start and end time for all compressed spans and use
                 # that to set the duration for all compressed spans.

newrelic/core/stats_engine.py

@@ -1196,11 +1196,15 @@ def record_transaction(self, transaction):
                         [
                             (
                                 f"Supportability/DistributedTrace/PartialGranularity/{partial_gran_type}/Span/Instrumented",
-                                {"count": transaction.instrumented},
+                                {"count": getattr(transaction, "instrumented", 0)},
                             ),
                             (
                                 f"Supportability/DistributedTrace/PartialGranularity/{partial_gran_type}/Span/Kept",
-                                {"count": transaction.kept},
+                                {"count": getattr(transaction, "kept", 0)},
+                            ),
+                            (
+                                "Supportability/Python/PartialGranularity/NrIds/Dropped",
+                                {"count": getattr(transaction, "dropped_ids", 0)},
                             ),
                         ]
                     )

newrelic/core/transaction_node.py

@@ -634,7 +634,7 @@ def span_events(self, settings, attr_class=dict):
                 ("priority", self.priority),
             )
         )
-        ct_exit_spans = {"instrumented": 0, "kept": 0}
+        ct_exit_spans = {"instrumented": 0, "kept": 0, "dropped_ids": 0}
         yield from self.root.span_events(
             settings,
             base_attrs,
@@ -646,6 +646,8 @@ def span_events(self, settings, attr_class=dict):
         # If this transaction is partial granularity sampled, record the number of spans
         # instrumented and the number of spans kept to monitor cost savings of partial
         # granularity tracing.
+        # Also record the number of span ids dropped (fragmentation) in compact mode.
         if self.partial_granularity_sampled:
             self.instrumented = ct_exit_spans["instrumented"]
             self.kept = ct_exit_spans["kept"]
+            self.dropped_ids = ct_exit_spans["dropped_ids"]