Fixup

Author: hmstepanek

newrelic/common/streaming_utils.py

@@ -15,7 +15,6 @@
 import collections
 import logging
 import threading
-from newrelic.packages import objsize
 
 try:
     from newrelic.core.infinite_tracing_pb2 import AttributeValue, SpanBatch
@@ -26,6 +25,27 @@
 _logger = logging.getLogger(__name__)
 
 
+def get_deep_size(obj, seen=None):
+    """Recursively calculates the size of an object including nested lists and dicts."""
+    if seen is None:
+        seen = set()
+
+    # Avoid recursion for already seen objects (handle circular references)
+    obj_id = id(obj)
+    if obj_id in seen:
+        return 0
+    seen.add(obj_id)
+
+    size = sys.getsizeof(obj)
+
+    if isinstance(obj, dict):
+        size += sum(get_deep_size(k, seen) + get_deep_size(v, seen) for k, v in obj.items())
+    elif isinstance(obj, (list, tuple, set, frozenset)):
+        size += sum(get_deep_size(i, seen) for i in obj)
+
+    return size
+
+
 class StreamBuffer:
     def __init__(self, maxlen, batching=False):
         self._queue = collections.deque(maxlen=maxlen)
@@ -54,7 +74,7 @@ def put(self, item):
                 return
 
             self._seen += 1
-            self._bytes += objsize.get_deep_size(item)
+            self._bytes += get_deep_size(item)
 
             # NOTE: dropped can be over-counted as the queue approaches
             # capacity while data is still being transmitted.

newrelic/core/application.py

@@ -1384,13 +1384,9 @@ def harvest(self, shutdown=False, flexible=False):
                                 spans_seen = spans.num_seen
                                 spans_sampled = spans.num_samples
                                 internal_count_metric("Supportability/SpanEvent/TotalEventsSeen", spans_seen)
-                                print(f"Supportability/SpanEvent/TotalEventsSeen: {spans_seen}")
                                 internal_count_metric("Supportability/SpanEvent/TotalEventsSent", spans_sampled)
-                                print(f"Supportability/SpanEvent/TotalEventsSent: {spans_sampled}")
                                 internal_count_metric("Supportability/DistributedTracing/Bytes/Seen", spans.bytes)
-                                print(f"Supportability/DistributedTracing/Bytes/Seen: {spans.bytes}")
                                 internal_count_metric("Supportability/SpanEvent/TotalCoreTracingTime", spans.ct_processing_time*1000)  # Time in ms.
-                                print(f"Supportability/SpanEvent/TotalCoreTracingTime: {spans.ct_processing_time*1000}")  # Time in ms.
 
                                 stats.reset_span_events()
 

newrelic/core/node_mixin.py

@@ -86,12 +86,8 @@ def span_event(self, settings, base_attrs=None, parent_guid=None, attr_class=dic
         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:
-                    ct_processing_time[0] += (time.time() - start_time)
-                    return [i_attrs, {}, {}]
-                else:
-                    ct_processing_time[0] += (time.time() - start_time)
-                    return [i_attrs, u_attrs, a_attrs]
+                ct_processing_time[0] += (time.time() - start_time)
+                return [i_attrs, {}, {}] if settings.core_tracing.enabled else [i_attrs, u_attrs, a_attrs]
             if not exit_span_attrs_present:
                 ct_processing_time[0] += (time.time() - start_time)
                 return None
@@ -114,26 +110,16 @@ def span_event(self, settings, base_attrs=None, parent_guid=None, attr_class=dic
         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=None):
-        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)
-            parent_id = parent_guid
-            if span:  # span will be None if the span is an inprocess span or repeated exit span.
-                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:  # event will be None if the span is an inprocess span or repeated exit span.
-                        yield event
-        else:
-            span = self.span_event(settings, base_attrs=base_attrs, parent_guid=parent_guid, attr_class=attr_class, ct_processing_time=ct_processing_time)
+        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)
+        parent_id = parent_guid
+        if span:  # span will be None if the span is an inprocess span or repeated exit span.
             yield span
-
-            for child in self.children:
-                for event in child.span_events(  # noqa: UP028
-                    settings, base_attrs=base_attrs, parent_guid=self.guid, attr_class=attr_class, ct_processing_time=ct_processing_time
-                ):
+            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:  # event will be None if the span is an inprocess span or repeated exit span.
                     yield event
 
 

newrelic/core/root_node.py

@@ -39,8 +39,6 @@
 class RootNode(_RootNode, GenericNodeMixin):
     def span_event(self, *args, **kwargs):
         span = super().span_event(*args, **kwargs)
-        #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

@@ -31,13 +31,12 @@
 import zlib
 from heapq import heapify, heapreplace
 
-from newrelic.packages import objsize
 from newrelic.api.settings import STRIP_EXCEPTION_MESSAGE
 from newrelic.api.time_trace import get_linking_metadata
 from newrelic.common.encoding_utils import json_encode
 from newrelic.common.metric_utils import create_metric_identity
 from newrelic.common.object_names import parse_exc_info
-from newrelic.common.streaming_utils import StreamBuffer
+from newrelic.common.streaming_utils import StreamBuffer, get_deep_size
 from newrelic.core.attribute import (
     MAX_LOG_MESSAGE_LENGTH,
     create_agent_attributes,
@@ -55,26 +54,6 @@
 from newrelic.core.metric import TimeMetric
 from newrelic.core.stack_trace import exception_stack
 
-def get_deep_size(obj, seen=None):
-    """Recursively calculates the size of an object including nested lists and dicts."""
-    if seen is None:
-        seen = set()
-
-    # Avoid recursion for already seen objects (handle circular references)
-    obj_id = id(obj)
-    if obj_id in seen:
-        return 0
-    seen.add(obj_id)
-
-    size = sys.getsizeof(obj)
-
-    if isinstance(obj, dict):
-        size += sum(get_deep_size(k, seen) + get_deep_size(v, seen) for k, v in obj.items())
-    elif isinstance(obj, (list, tuple, set, frozenset)):
-        size += sum(get_deep_size(i, seen) for i in obj)
-
-    return size
-
 _logger = logging.getLogger(__name__)
 
 EVENT_HARVEST_METHODS = {
@@ -1236,12 +1215,12 @@ def record_transaction(self, transaction):
 
         if settings.distributed_tracing.enabled and settings.span_events.enabled and settings.collect_span_events:
             if settings.infinite_tracing.enabled:
-                ct_processing_time = [0]
+                ct_processing_time = [0]  # Hack for getting Python to create a non mutable number.
                 for event in transaction.span_protos(settings, ct_processing_time=ct_processing_time):
                     self._span_stream.put(event)
                 self._span_stream._ct_processing_time += ct_processing_time[0]
             elif transaction.sampled:
-                ct_processing_time = [0]
+                ct_processing_time = [0]  # Hack for getting Python to create a non mutable number.
                 for event in transaction.span_events(self.__settings, ct_processing_time=ct_processing_time):
                     self._span_events.add(event, priority=transaction.priority)
                 self._span_events.ct_processing_time += ct_processing_time[0]