Fixup

Author: hmstepanek

newrelic/common/streaming_utils.py

@@ -33,12 +33,8 @@ def __init__(self, maxlen, batching=False):
         self._shutdown = False
         self._seen = 0
         self._dropped = 0
-        self._ft_seen = 0
-        self._ft_dropped = 0
         self._bytes = 0
-        self._ft_bytes = 0
-        self._ct_bytes = 0
-        self.ct_processing_time = 0
+        self._ct_processing_time = 0
         self._settings = None
 
         self.batching = batching
@@ -52,30 +48,13 @@ def shutdown(self):
             self._shutdown = True
             self._notify.notify_all()
 
-    def is_ft(self, sample, entity_relationship_attrs):
-        # It's a FT span if it's an exit or entry span.
-        return entity_relationship_attrs or not sample.intrinsics.get("parentId")
-
     def put(self, item):
         with self._notify:
             if self._shutdown:
                 return
 
-            entity_relationship_attrs = item[1]
-            item = item[0]
             self._seen += 1
-            # The last index contains the set of entity synthesis attrs in the span.
-            self._bytes += objsize.get_deep_size([item.intrinsics, item.user_attributes, item.agent_attributes])
-            if self.is_ft(item, entity_relationship_attrs):
-                self._ft_seen += 1
-                # The last index contains the set of entity synthesis attrs in the span.
-                self._ft_bytes += objsize.get_deep_size([item.intrinsics, item.user_attributes, item.agent_attributes])
-
-                i_ct_attrs = {"type", "name", "guid", "parentId", "transaction.name", "traceId", "nr.entryPoint", "transactionId"}
-                i_attrs = {attr: value for attr, value in item.intrinsics.items() if attr in i_ct_attrs}
-                u_attrs = {}
-                a_attrs = {attr: value for attr, value in item.agent_attributes.items() if attr in entity_relationship_attrs}
-                self._ct_bytes += objsize.get_deep_size([i_attrs, u_attrs, a_attrs])
+            self._bytes += objsize.get_deep_size(item)
 
             # NOTE: dropped can be over-counted as the queue approaches
             # capacity while data is still being transmitted.
@@ -84,25 +63,21 @@ def put(self, item):
             # being measured.
             if len(self._queue) >= self._queue.maxlen:
                 self._dropped += 1
-                if self.is_ft(item, entity_relationship_attrs):
-                    self._ft_dropped += 1
+                print(f"dropped: {self._dropped}")
 
-            # Drop last index that contains the entity relationship attrs present on the span.
             self._queue.append(item)
             self._notify.notify_all()
+            print(f"seen: {self._seen}")
+            print(f"bytes: {self._bytes}")
 
     def stats(self):
         with self._notify:
             seen, dropped = self._seen, self._dropped
             self._seen, self._dropped = 0, 0
-            ft_seen, ft_dropped = self._ft_seen, self._ft_dropped
-            self._ft_seen, self._ft_dropped = 0, 0
-            _bytes, ft_bytes, ct_bytes = self._bytes, self._ft_bytes, self._ct_bytes
-            self._bytes, self._ft_bytes, self._ct_bytes = 0, 0, 0
-            ct_processing_time = self._ct_processing_time
-            self._ct_processing_time = 0
-
-        return seen, dropped, ft_seen, ft_dropped, _bytes, ft_bytes, ct_byte, ct_processing_times
+            _bytes, ct_processing_time = self._bytes, self._ct_processing_time
+            self._bytes, self._ct_processing_time = 0, 0
+
+        return seen, dropped, _bytes, ct_processing_time
 
     def __bool__(self):
         return bool(self._queue)

newrelic/core/application.py

@@ -1353,7 +1353,6 @@ def harvest(self, shutdown=False, flexible=False):
 
                     # Send span events
 
-                    print(f"\n\r\n\r\n\r{configuration.span_events.enabled} {configuration.collect_span_events} {configuration.distributed_tracing.enabled} {configuration.infinite_tracing.enabled} \n\r\n\r\n\r")
                     if (
                         configuration.span_events.enabled
                         and configuration.collect_span_events
@@ -1363,18 +1362,12 @@ def harvest(self, shutdown=False, flexible=False):
                             span_stream = stats.span_stream
                             # Only merge stats as part of default harvest
                             if span_stream is not None and not flexible:
-                                print("\n\r\n\r\n\rSending Supportability metrics for inifinte tracing\n\r\n\r\n\r")
-                                spans_seen, spans_dropped, spans_ft_seen, spans_ft_dropped, _bytes, ft_bytes, ct_bytes, ct_processing_time = span_stream.stats()
+                                spans_seen, spans_dropped, _bytes, ct_processing_time = span_stream.stats()
                                 spans_sent = spans_seen - spans_dropped
-                                spans_ft_sent = spans_ft_seen - spans_ft_dropped
 
                                 internal_count_metric("Supportability/InfiniteTracing/Span/Seen", spans_seen)
                                 internal_count_metric("Supportability/InfiniteTracing/Span/Sent", spans_sent)
-                                internal_count_metric("Supportability/FullTracing/Span/Seen", spans_ft_seen)
-                                internal_count_metric("Supportability/FullTracing/Span/Sent", spans_ft_sent)
                                 internal_count_metric("Supportability/InfiniteTracing/Bytes/Seen", _bytes)
-                                internal_count_metric("Supportability/FullTracing/Bytes/Seen", ft_bytes)
-                                internal_count_metric("Supportability/CoreTracing/Bytes/Seen", ct_bytes)
                                 internal_count_metric("Supportability/CoreTracing/TotalTime", ct_processing_time*1000)  # Time in ms.
                         else:
                             spans = stats.span_events
@@ -1392,11 +1385,7 @@ def harvest(self, shutdown=False, flexible=False):
                                 spans_sampled = spans.num_samples
                                 internal_count_metric("Supportability/SpanEvent/TotalEventsSeen", spans_seen)
                                 internal_count_metric("Supportability/SpanEvent/TotalEventsSent", spans_sampled)
-                                internal_count_metric("Supportability/SpanEvent/FullTracing/TotalEventsSeen", spans.ft_seen)
-                                internal_count_metric("Supportability/SpanEvent/FullTracing/TotalEventsSent", spans.ft_sent)
                                 internal_count_metric("Supportability/DistributedTracing/Bytes/Seen", spans.bytes)
-                                internal_count_metric("Supportability/FullTracing/Bytes/Seen", spans.ft_bytes)
-                                internal_count_metric("Supportability/CoreTracing/Bytes/Seen", spans.ct_bytes)
                                 internal_count_metric("Supportability/SpanEvent/TotalCoreTracingTime", spans.ct_processing_time*1000)  # Time in ms.
 
                                 stats.reset_span_events()

newrelic/core/node_mixin.py

@@ -62,36 +62,35 @@ def span_event(self, settings, base_attrs=None, parent_guid=None, attr_class=dic
         i_attrs["timestamp"] = int(self.start_time * 1000)
         i_attrs["duration"] = self.duration
         i_attrs["category"] = "generic"
+        #if settings.core_tracing.enabled:
+            #i_ct_attrs = {"type", "name", "guid", "parentId", "transaction.name", "traceId", "nr.entryPoint", "transactionId"}
+            #i_attrs = {key: value for key, value in i_attrs.items() if key in i_ct_attrs}
 
         if parent_guid:
             i_attrs["parentId"] = parent_guid
 
         a_attrs = attribute.resolve_agent_attributes(
             self.agent_attributes, settings.attribute_filter, DST_SPAN_EVENTS, attr_class=attr_class
         )
+        u_attrs = self.processed_user_attributes
+        if settings.core_tracing.enabled:
+            # ids is the list of span guids that share this unqiue exit span.
+            u_attrs = {"ids": self.ids}
 
         u_attrs = attribute.resolve_user_attributes(
-            self.processed_user_attributes, settings.attribute_filter, DST_SPAN_EVENTS, attr_class=attr_class
+            u_attrs, settings.attribute_filter, DST_SPAN_EVENTS, attr_class=attr_class
         )
 
-        # intrinsics, user attrs, agent attrs
-
-        exit_span_attrs_present = attribute.SPAN_ENTITY_RELATIONSHIP_ATTRIBUTES & set(a_attrs)
         if settings.core_tracing.drop_inprocess_spans or settings.core_tracing.enabled:
+            exit_span_attrs_present = attribute.SPAN_ENTITY_RELATIONSHIP_ATTRIBUTES & set(a_attrs)
             if self.__class__.__name__ == "RootNode":
-                if settings.core_tracing.enabled:
-                    #i_ct_attrs = {"type", "name", "guid", "parentId", "transaction.name", "traceId", "nr.entryPoint", "transactionId"}
-                    #i_attrs = {key: value for key, value in i_attrs.items() if key in i_ct_attrs}
-                    u_attrs = {}
-                return [i_attrs, u_attrs, a_attrs, exit_span_attrs_present]
+                return [i_attrs, u_attrs, a_attrs]
             if not exit_span_attrs_present:
                 return None
         if settings.core_tracing.enabled:
             start_time = time.time()
-            parent_id = parent_guid
-            # ids is the list of span guids that share this unqiue exit span.
-            span = [i_attrs, {"ids": self.ids}, a_attrs, exit_span_attrs_present]
-            span_attrs = "".join([span[2][key] for key in exit_span_attrs_present])
+            # TODO: use attr value name rather than str casting.
+            span_attrs = "".join([str(a_attrs[key]) for key in exit_span_attrs_present])
             new_exit_span = span_attrs not in ct_exit_spans
             if new_exit_span:
                 ct_exit_spans[span_attrs] = self.ids
@@ -100,52 +99,11 @@ def span_event(self, settings, base_attrs=None, parent_guid=None, attr_class=dic
                 ct_exit_spans[span_attrs].append(self.guid)
             ct_processing_time += (time.time() - start_time)
             if new_exit_span:
-                return span
+                return [i_attrs, u_attrs, a_attrs]
             return None
-        return [i_attrs, u_attrs, a_attrs, exit_span_attrs_present]
+        return [i_attrs, u_attrs, a_attrs]
 
     def span_events(self, settings, base_attrs=None, parent_guid=None, attr_class=dict, ct_exit_spans=None, ct_processing_time=0):
-        #if settings.core_tracing.enabled:
-        #    if ct_exit_spans is None:
-        #        ct_exit_spans = {}
-        #    span = self.span_event(settings, base_attrs=base_attrs, parent_guid=parent_guid, attr_class=attr_class)
-        #    start_time = time.time()
-        #    parent_id = parent_guid
-        #    if span:  # span will be None if the span is an inprocess span.
-        #        span_attrs = "".join([span[2][key] for key in span[3]])
-        #        new_exit_span = span_attrs not in ct_exit_spans
-        #        if parent_id:  # If this is not the entry span.
-        #            if new_exit_span:
-        #                ct_exit_spans[span_attrs] = span
-        #            else:
-        #                ct_exit_spans[span_attrs][0]["ids"].append(span[0]["guid"])
-        #        ct_processing_time += (time.time() - start_time)
-        #        #print(f"parent {span[0]['traceId']} {parent_id} {span[0]['name']} {new_exit_span}")
-        #        if not parent_id or new_exit_span:
-        #            #print(f"{span}")
-        #            import traceback
-        #            traceback.print_stack()
-        #            yield span
-        #            parent_id = self.guid
-        #    for child in self.children:
-        #        for event in child.span_events(  # noqa: UP028
-        #            settings, base_attrs=base_attrs, parent_guid=parent_id, attr_class=attr_class, ct_exit_spans=ct_exit_spans, ct_processing_time=ct_processing_time
-        #        ):
-        #            if event:
-        #                start_time = time.time()
-        #                span_attrs = "".join([event[2][key] for key in event[3]])
-        #                new_exit_span = span_attrs not in ct_exit_spans
-        #                if new_exit_span:
-        #                    ct_exit_spans[span_attrs] = event
-        #                else:
-        #                    ct_exit_spans[span_attrs][0]["ids"].append(event[0]["guid"])
-        #                ct_processing_time += (time.time() - start_time)
-        #                #print(f"child {event[0]['traceId']} {parent_id} {event[0]['name']} {new_exit_span}")
-        #                if new_exit_span:
-        #                    #print(f"{event}")
-        #                    import traceback
-        #                    traceback.print_stack()
-        #                    yield event
         if settings.core_tracing.drop_inprocess_spans or settings.core_tracing.enabled:
             span = self.span_event(settings, base_attrs=base_attrs, parent_guid=parent_guid, attr_class=attr_class, ct_exit_spans=ct_exit_spans, ct_processing_time=ct_processing_time)
             start_time = time.time()

newrelic/core/root_node.py

@@ -39,8 +39,8 @@
 class RootNode(_RootNode, GenericNodeMixin):
     def span_event(self, *args, **kwargs):
         span = super().span_event(*args, **kwargs)
-        if not span:
-            return None
+        #if not span:
+        #    return None
         i_attrs = span[0]
         i_attrs["transaction.name"] = self.path
         i_attrs["nr.entryPoint"] = True

newrelic/core/stats_engine.py

@@ -453,11 +453,7 @@ def __init__(self, capacity=100):
         self.heap = False
         self.capacity = capacity
         self.num_seen = 0
-        self.ft_seen = 0
-        self.ft_sent = 0
         self.bytes = 0
-        self.ft_bytes = 0
-        self.ct_bytes = 0
         self.ct_processing_time = 0
 
         if capacity <= 0:
@@ -467,29 +463,9 @@ def add(*args, **kwargs):
 
             self.add = add
 
-    @property
-    def ft_samples(self):
-        return (x[-1] for x in self.pq if is_ft(x[-1]))
-
-    def is_ft(self, sample):
-        # It's a FT span if it's an exit or entry span.
-        return (len(sample) > 3 and sample[3]) or not sample[0].get("parentId")
-
     def add(self, sample, priority=None):
         self.num_seen += 1
         self.bytes += objsize.get_deep_size(sample[:-1])
-        is_ft = self.is_ft(sample)
-        entity_relationship_attrs = sample[3] if len(sample) > 3 else {}
-        if is_ft:
-            self.ft_seen += 1
-            # The last index contains the set of entity synthesis attrs in the span.
-            self.ft_bytes += objsize.get_deep_size([sample[0], sample[1], sample[2]])
-
-            i_ct_attrs = {"type", "name", "guid", "parentId", "transaction.name", "traceId", "nr.entryPoint", "transactionId"}
-            i_attrs = {attr: value for attr, value in sample[0].items() if attr in sample[0]}
-            u_attrs = {}
-            a_attrs = {attr: value for attr, value in sample[2].items() if attr in entity_relationship_attrs}
-            self.ct_bytes += objsize.get_deep_size([i_attrs, u_attrs, a_attrs])
 
         if priority is None:
             priority = random.random()  # noqa: S311
@@ -498,12 +474,8 @@ def add(self, sample, priority=None):
         if self.num_seen == self.capacity:
             self.pq.append(entry)
             self.heap = self.heap or heapify(self.pq) or True
-            if is_ft:
-                self.ft_sent += 1
         elif not self.heap:
             self.pq.append(entry)
-            if is_ft:
-                self.ft_sent += 1
         else:
             sampled = self.should_sample(priority)
             if not sampled:
@@ -1265,12 +1237,13 @@ def record_transaction(self, transaction):
             if settings.infinite_tracing.enabled:
                 ct_processing_time = 0
                 for event in transaction.span_protos(settings, ct_processing_time=ct_processing_time):
+                    print(event.intrinsics["name"])
                     self._span_stream.put(event)
                 self._span_stream._ct_processing_time += ct_processing_time
             elif transaction.sampled:
                 ct_processing_time = 0
                 for event in transaction.span_events(self.__settings, ct_processing_time=ct_processing_time):
-                    print(event)
+                    print(event[0]["name"])
                     self._span_events.add(event, priority=transaction.priority)
                 self._span_events.ct_processing_time += ct_processing_time
 

newrelic/core/transaction_node.py

@@ -620,9 +620,9 @@ def _add_call_count(source, target):
 
         return intrinsics
 
-    def span_protos(self, settings, ct_process_time=0):
-        for span in self.span_events(settings, attr_class=SpanProtoAttrs, ct_process_time=ct_process_time):
-            yield Span(trace_id=self.trace_id, intrinsics=span[0], user_attributes=span[1], agent_attributes=span[2]), span[3]
+    def span_protos(self, settings, ct_processing_time=0):
+        for span in self.span_events(settings, attr_class=SpanProtoAttrs, ct_processing_time=ct_processing_time):
+            yield Span(trace_id=self.trace_id, intrinsics=span[0], user_attributes=span[1], agent_attributes=span[2])
 
     def span_events(self, settings, attr_class=dict, ct_processing_time=0):
         base_attrs = attr_class(