Strip out prototype only stuff

hmstepanek · hmstepanek · commit 0685a9c3e96d · 2025-10-02T13:05:18.000-07:00
diff --git a/newrelic/_version.py b/newrelic/_version.py
diff --git a/newrelic/common/streaming_utils.py b/newrelic/common/streaming_utils.py
@@ -15,7 +15,6 @@
 import collections
 import logging
 import threading
-import sys
 
 try:
     from newrelic.core.infinite_tracing_pb2 import AttributeValue, SpanBatch
@@ -26,76 +25,13 @@
 _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()
-        size = -8*3  # Subtract 8 for each of the 3 attribute lists as those don't count.
-    else:
-        size = 0
-
-    # Avoid recursion for already seen objects (handle circular references)
-    obj_id = id(obj)
-    if obj_id in seen:
-        return 0
-    seen.add(obj_id)
-
-    if isinstance(obj, str):
-        size += len(obj)
-        return size
-    elif isinstance(obj, float) or isinstance(obj, int):
-        size += 8
-        return size
-    elif isinstance(obj, bool):
-        size += 1
-        return size
-    elif 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 += 8 + sum(get_deep_size(i, seen) for i in obj)
-    else:
-        size += 8
-
-    return size
-
-
-def get_deep_size_protobuf(obj):
-    """Recursively calculates the size of an object including nested lists and dicts."""
-    size = 0
-    if hasattr(obj, "string_value"):
-        size += len(obj.string_value)
-        return size
-    elif hasattr(obj, "double_value"):
-        size += 8
-        return size
-    elif hasattr(obj, "int_value"):
-        size += 8
-        return size
-    elif hasattr(obj, "bool_value"):
-        size += 1
-        return size
-
-    if hasattr(obj, "agent_attributes"):
-        size += sum(len(k) + get_deep_size_protobuf(v) for k, v in obj.agent_attributes.items())
-    if hasattr(obj, "user_attributes"):
-        size += sum(len(k) + get_deep_size_protobuf(v) for k, v in obj.user_attributes.items())
-    if hasattr(obj, "intrinsics"):
-        size += sum(len(k) + get_deep_size_protobuf(v) for k, v in obj.intrinsics.items())
-    else:
-        size += 8
-
-    return size
-
-
 class StreamBuffer:
     def __init__(self, maxlen, batching=False):
         self._queue = collections.deque(maxlen=maxlen)
         self._notify = self.condition()
         self._shutdown = False
         self._seen = 0
         self._dropped = 0
-        self._bytes = 0
-        self._ct_processing_time = 0
         self._settings = None
 
         self.batching = batching
@@ -115,8 +51,6 @@ def put(self, item):
                 return
 
             self._seen += 1
-            _logger.debug(f"{item.intrinsics['name']} [{len(item.intrinsics)}, {len(item.user_attributes)}, {len(item.agent_attributes)}] {get_deep_size_protobuf(item)}")
-            self._bytes += get_deep_size_protobuf(item)
 
             # NOTE: dropped can be over-counted as the queue approaches
             # capacity while data is still being transmitted.
@@ -133,10 +67,8 @@ def stats(self):
         with self._notify:
             seen, dropped = self._seen, self._dropped
             self._seen, self._dropped = 0, 0
-            _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
+        return seen, dropped
 
     def __bool__(self):
         return bool(self._queue)
diff --git a/newrelic/config.py b/newrelic/config.py
@@ -409,6 +409,10 @@ def _process_configuration(section):
     _process_setting(section, "distributed_tracing.exclude_newrelic_header", "getboolean", None)
     _process_setting(section, "distributed_tracing.sampler.remote_parent_sampled", "get", None)
     _process_setting(section, "distributed_tracing.sampler.remote_parent_not_sampled", "get", None)
+    _process_setting(section, "distributed_tracing.sampler.partial_granularity.enabled", "getboolean", None)
+    _process_setting(section, "distributed_tracing.sampler.partial_granularity.type", "get", None)
+    _process_setting(section, "distributed_tracing.sampler.partial_granularity.remote_parent_sampled", "get", None)
+    _process_setting(section, "distributed_tracing.sampler.partial_granularity.remote_parent_not_sampled", "get", None)
     _process_setting(section, "span_events.enabled", "getboolean", None)
     _process_setting(section, "span_events.max_samples_stored", "getint", None)
     _process_setting(section, "span_events.attributes.enabled", "getboolean", None)
diff --git a/newrelic/core/application.py b/newrelic/core/application.py
@@ -506,11 +506,7 @@ def connect_to_data_collector(self, activate_agent):
                 sampling_target_period = 60.0
             else:
                 sampling_target_period = configuration.sampling_target_period_in_seconds
-            sampling_target = configuration.sampling_target
-            # If span reduction is enabled double the transaction reservoir size.
-            if configuration.distributed_tracing.drop_inprocess_spans.enabled or configuration.distributed_tracing.unique_spans.enabled:
-                sampling_target = configuration.sampling_target*2
-            self.adaptive_sampler = AdaptiveSampler(sampling_target, sampling_target_period)
+            self.adaptive_sampler = AdaptiveSampler(configuration.sampling_target, sampling_target_period)
 
         active_session.connect_span_stream(self._stats_engine.span_stream, self.record_custom_metric)
 
@@ -1356,14 +1352,11 @@ 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:
-                                spans_seen, spans_dropped, _bytes, ct_processing_time = span_stream.stats()
+                                spans_seen, spans_dropped = span_stream.stats()
                                 spans_sent = spans_seen - spans_dropped
 
                                 internal_count_metric("Supportability/InfiniteTracing/Span/Seen", spans_seen)
                                 internal_count_metric("Supportability/InfiniteTracing/Span/Sent", spans_sent)
-                                print(f"spans sent: {spans_sent}")
-                                internal_count_metric("Supportability/InfiniteTracing/Bytes/Seen", _bytes)
-                                internal_count_metric("Supportability/CoreTracing/TotalTime", ct_processing_time*1000)  # Time in ms.
                         else:
                             spans = stats.span_events
                             if spans:
@@ -1380,9 +1373,6 @@ 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)
-                                print(f"spans sent: {spans_sampled}")
-                                internal_count_metric("Supportability/DistributedTracing/Bytes/Seen", spans.bytes)
-                                internal_count_metric("Supportability/SpanEvent/TotalCoreTracingTime", spans.ct_processing_time*1000)  # Time in ms.
 
                                 stats.reset_span_events()
 
diff --git a/newrelic/core/config.py b/newrelic/core/config.py
@@ -333,19 +333,11 @@ class DistributedTracingSettings(Settings):
     pass
 
 
-class DistributedTracingDropInprocessSpansSettings(Settings):
-    pass
-
-
-class DistributedTracingUniqueSpansSettings(Settings):
-    pass
-
-
-class DistributedTracingMinimizeAttributesSettings(Settings):
+class DistributedTracingSamplerSettings(Settings):
     pass
 
 
-class DistributedTracingSamplerSettings(Settings):
+class DistributedTracingSamplerPartialGranularitySettings(Settings):
     pass
 
 
@@ -522,6 +514,7 @@ class EventHarvestConfigHarvestLimitSettings(Settings):
 _settings.distributed_tracing.unique_spans = DistributedTracingUniqueSpansSettings()
 _settings.distributed_tracing.minimize_attributes = DistributedTracingMinimizeAttributesSettings()
 _settings.distributed_tracing.sampler = DistributedTracingSamplerSettings()
+_settings.distributed_tracing.sampler.partial_granularity = DistributedTracingSamplerPartialGranularitySettings()
 _settings.error_collector = ErrorCollectorSettings()
 _settings.error_collector.attributes = ErrorCollectorAttributesSettings()
 _settings.event_harvest_config = EventHarvestConfigSettings()
@@ -852,15 +845,22 @@ def default_otlp_host(host):
 _settings.ml_insights_events.enabled = False
 
 _settings.distributed_tracing.enabled = _environ_as_bool("NEW_RELIC_DISTRIBUTED_TRACING_ENABLED", default=True)
-_settings.distributed_tracing.drop_inprocess_spans.enabled = _environ_as_bool("NEW_RELIC_DISTRIBUTED_TRACING_DROP_INPROCESS_SPANS_ENABLED", default=False)
-_settings.distributed_tracing.unique_spans.enabled = _environ_as_bool("NEW_RELIC_DISTRIBUTED_TRACING_UNIQUE_SPANS_ENABLED", default=False)
-_settings.distributed_tracing.minimize_attributes.enabled = _environ_as_bool("NEW_RELIC_DISTRIBUTED_TRACING_MINIMIZE_ATTRIBUTES_ENABLED", default=False)
 _settings.distributed_tracing.sampler.remote_parent_sampled = os.environ.get(
     "NEW_RELIC_DISTRIBUTED_TRACING_SAMPLER_REMOTE_PARENT_SAMPLED", "default"
 )
 _settings.distributed_tracing.sampler.remote_parent_not_sampled = os.environ.get(
     "NEW_RELIC_DISTRIBUTED_TRACING_SAMPLER_REMOTE_PARENT_NOT_SAMPLED", "default"
 )
+_settings.distributed_tracing.sampler.partial_granularity.enabled = _environ_as_bool("NEW_RELIC_DISTRIBUTED_TRACING_SAMPLER_PARTIAL_GRANULARITY_ENABLED", default=False)
+_settings.distributed_tracing.sampler.partial_granularity.type = os.environ.get(
+    "NEW_RELIC_DISTRIBUTED_TRACING_SAMPLER_PARTIAL_GRANULARITY_TYPE", "essential"
+)
+_settings.distributed_tracing.sampler.partial_granularity.remote_parent_sampled = os.environ.get(
+    "NEW_RELIC_DISTRIBUTED_TRACING_SAMPLER_PARTIAL_GRANULARITY_REMOTE_PARENT_SAMPLED", "default"
+)
+_settings.distributed_tracing.sampler.partial_granularity.remote_parent_not_sampled = os.environ.get(
+    "NEW_RELIC_DISTRIBUTED_TRACING_SAMPLER_PARTIAL_GRANULARITY_REMOTE_PARENT_NOT_SAMPLED", "default"
+)
 _settings.distributed_tracing.exclude_newrelic_header = False
 _settings.span_events.enabled = _environ_as_bool("NEW_RELIC_SPAN_EVENTS_ENABLED", default=True)
 _settings.span_events.max_samples_stored = _environ_as_int(
diff --git a/newrelic/core/node_mixin.py b/newrelic/core/node_mixin.py
@@ -49,7 +49,7 @@ def get_trace_segment_params(self, settings, params=None):
         _params["exclusive_duration_millis"] = 1000.0 * self.exclusive
         return _params
 
-    def span_event(self, settings, base_attrs=None, parent_guid=None, attr_class=dict, ct_exit_spans=None, ct_processing_time=None):
+    def span_event(self, settings, base_attrs=None, parent_guid=None, attr_class=dict, ct_exit_spans=None):
         if ct_exit_spans is None:
             ct_exit_spans = {}
         i_attrs = (base_attrs and base_attrs.copy()) or attr_class()
@@ -79,20 +79,16 @@ def span_event(self, settings, base_attrs=None, parent_guid=None, attr_class=dic
             u_attrs, settings.attribute_filter, DST_SPAN_EVENTS, attr_class=attr_class
         )
 
-        start_time = time.time()
         if settings.distributed_tracing.drop_inprocess_spans.enabled or settings.distributed_tracing.unique_spans.enabled:
             exit_span_attrs_present = attribute.SPAN_ENTITY_RELATIONSHIP_ATTRIBUTES & set(a_attrs)
             # If this is the entry node, always return it.
             if i_attrs.get("nr.entryPoint"):
-                ct_processing_time[0] += (time.time() - start_time)
                 return [i_attrs, u_attrs, {}] if settings.distributed_tracing.minimize_attributes.enabled else [i_attrs, u_attrs, a_attrs]
             # If this is the an LLM node, always return it.
             if a_attrs.get("llm") or i_attrs["name"].startswith("Llm/"):
-                ct_processing_time[0] += (time.time() - start_time)
                 return [i_attrs, u_attrs, {"llm": True}] if settings.distributed_tracing.minimize_attributes.enabled else [i_attrs, u_attrs, a_attrs]
             # If the span is not an exit span, skip it by returning None.
             if not exit_span_attrs_present:
-                ct_processing_time[0] += (time.time() - start_time)
                 return None
             # If the span is an exit span but unique spans is enabled, we need to check
             # for uniqueness before returning it.
@@ -107,25 +103,22 @@ def span_event(self, settings, base_attrs=None, parent_guid=None, attr_class=dic
                 if new_exit_span:
                     u_attrs["nr.durations"] = self.duration
                     ct_exit_spans[span_attrs] = [u_attrs]
-                    ct_processing_time[0] += (time.time() - start_time)
                     return [i_attrs, u_attrs, a_minimized_attrs] if settings.distributed_tracing.minimize_attributes.enabled else [i_attrs, u_attrs, a_attrs]
                 # If this is an exit span we've already seen, add it's guid to the list
                 # of ids on the seen span and return None.
                 # For now add ids to user attributes list
                 ct_exit_spans[span_attrs][0]["nr.ids"].append(self.guid)
                 ct_exit_spans[span_attrs][0]["nr.durations"] += self.duration
 
-                ct_processing_time[0] += (time.time() - start_time)
                 return None
         elif settings.distributed_tracing.minimize_attributes.enabled:
             # Drop all non-entity relationship attributes from the span.
             exit_span_attrs_present = attribute.SPAN_ENTITY_RELATIONSHIP_ATTRIBUTES & set(a_attrs)
             a_attrs = attr_class({key: a_attrs[key] for key in exit_span_attrs_present})
-        ct_processing_time[0] += (time.time() - start_time)
         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):
-        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)
+    def span_events(self, settings, base_attrs=None, parent_guid=None, attr_class=dict, ct_exit_spans=None):
+        span = self.span_event(settings, base_attrs=base_attrs, parent_guid=parent_guid, attr_class=attr_class, ct_exit_spans=ct_exit_spans)
         parent_id = parent_guid
         if span:  # span will be None if the span is an inprocess span or repeated exit span.
             yield span
@@ -134,7 +127,7 @@ def span_events(self, settings, base_attrs=None, parent_guid=None, attr_class=di
                 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
+                settings, base_attrs=base_attrs, parent_guid=parent_id, attr_class=attr_class, ct_exit_spans=ct_exit_spans
             ):
                 if event:  # event will be None if the span is an inprocess span or repeated exit span.
                     yield event
diff --git a/newrelic/core/stats_engine.py b/newrelic/core/stats_engine.py
@@ -35,7 +35,7 @@
 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, get_deep_size
+from newrelic.common.streaming_utils import StreamBuffer
 from newrelic.core.attribute import (
     MAX_LOG_MESSAGE_LENGTH,
     create_agent_attributes,
@@ -445,26 +445,6 @@ def merge(self, other_data_set, priority=None):
         self.num_seen += other_data_set.num_seen - other_data_set.num_samples
 
 
-class SpanSampledDataSet(SampledDataSet):
-    def __init__(self, capacity=100):
-        super().__init__(capacity=capacity)
-        self.ct_processing_time = 0
-        self.bytes = 0
-
-    def add(self, sample, priority=None):
-        super().add(sample=sample, priority=priority)
-        _logger.debug(f"{sample[0]['name']} [{len(sample[0])}, {len(sample[1])}, {len(sample[2])}] {get_deep_size(sample)}")
-        self.bytes += get_deep_size(sample)
-
-    def reset(self):
-        super().reset()
-        self.ct_processing_time = 0
-
-    def merge(self, other_data_set, priority=None):
-        super().merge(other_data_set=other_data_set, priority=priority)
-        self.ct_processing_time += other_data_set.ct_processing_time
-
-
 class LimitedDataSet(list):
     def __init__(self, capacity=200):
         super().__init__()
@@ -548,7 +528,7 @@ def __init__(self):
         self._error_events = SampledDataSet()
         self._custom_events = SampledDataSet()
         self._ml_events = SampledDataSet()
-        self._span_events = SpanSampledDataSet()
+        self._span_events = SampledDataSet()
         self._log_events = SampledDataSet()
         self._span_stream = None
         self.__sql_stats_table = {}
@@ -1205,16 +1185,11 @@ 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]  # Hack for getting Python to create a non mutable number.
-                for event in transaction.span_protos(settings, ct_processing_time=ct_processing_time):
+                for event in transaction.span_protos(settings):
                     self._span_stream.put(event)
-                self._span_stream._ct_processing_time += ct_processing_time[0]
             elif transaction.sampled:
-                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):
+                for event in transaction.span_events(self.__settings):
                     self._span_events.add(event, priority=transaction.priority)
-                self._span_events.ct_processing_time += ct_processing_time[0]
-
 
         # Merge in log events
 
@@ -1753,9 +1728,9 @@ def reset_ml_events(self):
 
     def reset_span_events(self):
         if self.__settings is not None:
-            self._span_events = SpanSampledDataSet(self.__settings.event_harvest_config.harvest_limits.span_event_data)
+            self._span_events = SampledDataSet(self.__settings.span_events.max_samples_stored)
         else:
-            self._span_events = SpanSampledDataSet()
+            self._span_events = SampledDataSet()
 
     def reset_log_events(self):
         if self.__settings is not None:
diff --git a/newrelic/core/transaction_node.py b/newrelic/core/transaction_node.py
