Add tests

Author: hmstepanek

newrelic/api/transaction.py

@@ -1065,7 +1065,7 @@ def _make_sampling_decision(self):
                 remote_parent_not_sampled_setting = self.settings.distributed_tracing.sampler.full_granularity.remote_parent_not_sampled,
             )
             _logger.debug("Full granularity sampling decision was %s with priority=%s.", sampled, priority)
-            if computed_sampled:
+            if computed_sampled or not self.settings.distributed_tracing.sampler.partial_granularity.enabled:
                 self._priority = computed_priority
                 self._sampled = computed_sampled
                 self._sampling_decision_made = True
@@ -1086,6 +1086,13 @@ def _make_sampling_decision(self):
             self._sampling_decision_made = True
             if self._sampled:
                 self.partial_granularity_sampled = True
+            return
+
+        # This is only reachable if both full and partial granularity tracing are off.
+        # Set priority=0 and do not sample. This enables DT headers to still be sent
+        # even if the trace is never sampled.
+        self._priority = 0
+        self._sampled = False
 
     def _freeze_path(self):
         if self._frozen_path is None:
@@ -1237,7 +1244,6 @@ def _accept_distributed_trace_payload(self, payload, transport_type="HTTP"):
             return False
 
         try:
-            self._remote_parent_sampled = payload.get("sa")
             version = payload.get("v")
             major_version = version and int(version[0])
 
@@ -1258,7 +1264,7 @@ def _accept_distributed_trace_payload(self, payload, transport_type="HTTP"):
             if not any(k in data for k in ("id", "tx")):
                 self._record_supportability("Supportability/DistributedTrace/AcceptPayload/ParseException")
                 return False
-
+            self._remote_parent_sampled = data.get("sa")
             settings = self._settings
             account_id = data.get("ac")
             trusted_account_key = settings.trusted_account_key or (
@@ -1349,7 +1355,7 @@ def accept_distributed_trace_headers(self, headers, transport_type="HTTP"):
             try:
                 traceparent = ensure_str(traceparent).strip()
                 data = W3CTraceParent.decode(traceparent)
-                self._remote_parent_sampled = data.get("sa")
+                self._remote_parent_sampled = data.pop("sa", None)
             except:
                 data = None
 

newrelic/core/config.py

@@ -1415,7 +1415,12 @@ def simplify_distributed_tracing_sampler_granularity_settings(settings):
         settings.distributed_tracing.sampler.full_granularity.remote_parent_sampled = settings.distributed_tracing.sampler.remote_parent_sampled
     if not settings.distributed_tracing.sampler.full_granularity.remote_parent_not_sampled:
         settings.distributed_tracing.sampler.full_granularity.remote_parent_not_sampled = settings.distributed_tracing.sampler.remote_parent_not_sampled
-
+    # Partial granularity tracing is not available in infinite tracing mode.
+    if settings.infinite_tracing.enabled and settings.distributed_tracing.sampler.partial_granularity.enabled:
+        _logger.warning(
+            "Improper configuration. Infinite tracing cannot be enabled at the same time as partial granularity tracing. Setting distributed_tracing.sampler.partial_granularity.enabled=False."
+        )
+        settings.distributed_tracing.sampler.partial_granularity.enabled = False
 
 def _remove_ignored_configs(server_settings):
     if not server_settings.get("agent_config"):

newrelic/core/node_mixin.py

@@ -95,23 +95,42 @@ def span_event(self, settings, base_attrs=None, parent_guid=None, attr_class=dic
                 # If we are in essential mode return the span with minimized attributes.
                 if partial_granularity_type == "essential":
                     return [i_attrs, {}, a_minimized_attrs]
-                # If the span is an exit span but span compression (compact) is enabled, we need to check
-                # for uniqueness before returning it.
+                # If the span is an exit span but span compression (compact) is enabled,
+                # we need to check for uniqueness before returning it.
                 # Combine all the entity relationship attr values into a string to be
                 # used as the hash to check for uniqueness.
                 span_attrs = "".join([str(a_minimized_attrs[key]) for key in exit_span_attrs_present])
                 new_exit_span = span_attrs not in ct_exit_spans
-                # If this is a new exit span, add it to the known ct_exit_spans and return it.
+                # If this is a new exit span, add it to the known ct_exit_spans and
+                # return it.
                 if new_exit_span:
-                    # ids is the list of span guids that share this unqiue exit span.
+                    # nr.ids is the list of span guids that share this unqiue exit span.
                     a_minimized_attrs["nr.ids"] = []
                     a_minimized_attrs["nr.durations"] = self.duration
-                    ct_exit_spans[span_attrs] = [a_minimized_attrs]
+                    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
-                # of ids on the seen span and return None.
-                ct_exit_spans[span_attrs][0]["nr.ids"].append(self.guid)
-                ct_exit_spans[span_attrs][0]["nr.durations"] += self.duration
+                # 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)
+                # Compute the new start and end time for all compressed spans and use
+                # that to set the duration for all compressed spans.
+                current_start_time = ct_exit_spans[span_attrs][0]["timestamp"]
+                current_end_time = ct_exit_spans[span_attrs][0]["timestamp"]/1000 + ct_exit_spans[span_attrs][1]["nr.durations"]
+                new_start_time = i_attrs["timestamp"]
+                new_end_time = i_attrs["timestamp"]/1000 + i_attrs["duration"]
+                set_start_time = min(new_start_time, current_start_time)
+                # If the new span starts after the old span's end time or the new span
+                # ends before the current span starts; add the durations.
+                if current_end_time < new_start_time/1000 or new_end_time < current_start_time/1000:
+                    set_duration = ct_exit_spans[span_attrs][1]["nr.durations"] + i_attrs["duration"]
+                # Otherwise, if the new and old span's overlap in time, use the newest
+                # end time and subtract the start time from it to calculate the new
+                # duration.
+                else:
+                    set_duration = max(current_end_time, new_end_time) - set_start_time/1000
+                ct_exit_spans[span_attrs][0]["timestamp"] = set_start_time
+                ct_exit_spans[span_attrs][1]["nr.durations"] = set_duration
                 return None
 
     def span_events(self, settings, base_attrs=None, parent_guid=None, attr_class=dict, partial_granularity_sampled=False, ct_exit_spans=None):