Almost working

Author: hmstepanek

newrelic/config.py

@@ -400,6 +400,7 @@ def _process_configuration(section):
     _process_setting(section, "distributed_tracing.enabled", "getboolean", None)
     _process_setting(section, "distributed_tracing.exclude_newrelic_header", "getboolean", None)
     _process_setting(section, "core_tracing.drop_inprocess_spans", "getboolean", None)
+    _process_setting(section, "core_tracing.enabled", "getboolean", 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)

newrelic/core/config.py

@@ -820,6 +820,7 @@ def default_otlp_host(host):
 
 _settings.distributed_tracing.enabled = _environ_as_bool("NEW_RELIC_DISTRIBUTED_TRACING_ENABLED", default=True)
 _settings.core_tracing.drop_inprocess_spans = _environ_as_bool("NEW_RELIC_CORE_TRACING_DROP_INPROCESS_SPANS", default=False)
+_settings.core_tracing.enabled = _environ_as_bool("NEW_RELIC_CORE_TRACING_ENABLED", default=True)
 _settings.distributed_tracing.exclude_newrelic_header = False
 _settings.span_events.enabled = _environ_as_bool("NEW_RELIC_SPAN_EVENTS_ENABLED", default=True)
 _settings.span_events.attributes.enabled = True

newrelic/core/node_mixin.py

@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
+import time
 from newrelic.core import attribute
 from newrelic.core.attribute_filter import DST_SPAN_EVENTS, DST_TRANSACTION_SEGMENTS
 
@@ -70,69 +70,90 @@ def span_event(self, settings, base_attrs=None, parent_guid=None, attr_class=dic
         )
 
         # 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:
-            if not parent_guid:
-                return [i_attrs, u_attrs, a_attrs]
-            set_inprocess_attrs = attribute.SPAN_ENTITY_RELATIONSHIP_ATTRIBUTES
-            set_a_attrs = set(a_attrs)
-            exit_span_attrs_present = set_inprocess_attrs & set_a_attrs
+            if self.__class__.__name__ == "RootNode":
+                return [i_attrs, u_attrs, a_attrs, exit_span_attrs_present]
             if not exit_span_attrs_present:
                 return None
         if settings.core_tracing.enabled:
-            a_attrs["ids"] = []  # This is the list of span guids that share this unqiue exit span.
-
-        set_inprocess_attrs = set(attribute.SPAN_ENTITY_RELATIONSHIP_ATTRIBUTES)
-        set_a_attrs = set(a_attrs)
-        exit_span_attrs_present = set_inprocess_attrs & set_a_attrs
-        return [i_attrs, u_attrs, a_attrs, exit_span_attrs_present]
-
-    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.drop_inprocess_spans:
-            ct_exit_spans = ct_exit_spans or {}
-            span = self.span_event(settings, base_attrs=base_attrs, parent_guid=parent_guid, attr_class=attr_class)
             start_time = time.time()
+            i_attrs["ids"] = []  # This is the list of span guids that share this unqiue exit span.
             parent_id = parent_guid
             if span:  # span will be None if the span is an inprocess 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:
-                        yield event
-        elif settings.core_tracing.enabled:
-            ct_exit_spans = ct_exit_spans or {}
+                span_attrs = "".join([span[2][key] for key in exit_spans])
+                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
+        return [i_attrs, u_attrs, a_attrs, exit_span_attrs_present]
+
+    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([value for key, value in span[2].items() if key in attribute.SPAN_ENTITY_RELATIONSHIP_ATTRIBUTES])
+                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][2]["ids"] = event[2]["guid"]
+                        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
+                    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([value for key, value in event[2].items() if key in attribute.SPAN_ENTITY_RELATIONSHIP_ATTRIBUTES])
+                        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][2]["ids"] = event[2]["guid"]
+                            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
+        elif settings.core_tracing.drop_inprocess_spans:
+            ct_exit_spans = ct_exit_spans or {}
+            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.
+                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:
+                        yield event
         else:
             yield self.span_event(settings, base_attrs=base_attrs, parent_guid=parent_guid, attr_class=attr_class)
 

newrelic/core/stats_engine.py

@@ -1270,6 +1270,7 @@ def record_transaction(self, transaction):
             elif transaction.sampled:
                 ct_processing_time = 0
                 for event in transaction.span_events(self.__settings, ct_processing_time=ct_processing_time):
+                    print(event)
                     self._span_events.add(event, priority=transaction.priority)
                 self._span_events.ct_processing_time += ct_processing_time
 

newrelic/core/transaction_node.py

@@ -622,10 +622,7 @@ def _add_call_count(source, target):
 
     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):
-            if len(span) > 3:
-                yield Span(trace_id=self.trace_id, intrinsics=span[0], user_attributes=span[1], agent_attributes=span[2]), span[3]
-            else:
-                yield Span(trace_id=self.trace_id, intrinsics=span[0], user_attributes=span[1], agent_attributes=span[2])
+            yield Span(trace_id=self.trace_id, intrinsics=span[0], user_attributes=span[1], agent_attributes=span[2]), span[3]
 
     def span_events(self, settings, attr_class=dict, ct_processing_time=0):
         base_attrs = attr_class(