Refactor and use new setting names

Author: hmstepanek

newrelic/core/config.py

@@ -895,9 +895,15 @@ def default_otlp_host(host):
 _settings.distributed_tracing.sampler.partial_granularity.remote_parent_sampled._sampler = os.environ.get(
     "NEW_RELIC_DISTRIBUTED_TRACING_SAMPLER_PARTIAL_GRANULARITY_REMOTE_PARENT_SAMPLED", "default"
 )
+_settings.distributed_tracing.sampler.partial_granularity.remote_parent_sampled.adaptive.sampling_target = os.environ.get(
+    "NEW_RELIC_DISTRIBUTED_TRACING_SAMPLER_PARTIAL_GRANULARITY_REMOTE_PARENT_SAMPLED_ADAPTIVE_SAMPLING_TARGET", None
+)
 _settings.distributed_tracing.sampler.partial_granularity.remote_parent_not_sampled._sampler = os.environ.get(
     "NEW_RELIC_DISTRIBUTED_TRACING_SAMPLER_PARTIAL_GRANULARITY_REMOTE_PARENT_NOT_SAMPLED", "default"
 )
+_settings.distributed_tracing.sampler.partial_granularity.remote_parent_not_sampled.adaptive.sampling_target = os.environ.get(
+    "NEW_RELIC_DISTRIBUTED_TRACING_SAMPLER_PARTIAL_GRANULARITY_REMOTE_PARENT_NOT_SAMPLED_ADAPTIVE_SAMPLING_TARGET", None
+)
 _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(

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
 
@@ -50,19 +50,13 @@ def get_trace_segment_params(self, settings, params=None):
         return _params
 
     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()
         i_attrs["type"] = "Span"
         i_attrs["name"] = i_attrs.get("name") or self.name
         i_attrs["guid"] = self.guid
         i_attrs["timestamp"] = int(self.start_time * 1000)
         i_attrs["duration"] = self.duration
         i_attrs["category"] = i_attrs.get("category") or "generic"
-        # TODO: limit intrinsic attributes but this likely requires changes in the pipeline.
-        #if settings.distributed_tracing.minimize_attributes.enabled:
-        #    i_ct_attrs = {"type", "name", "guid", "parentId", "transaction.name", "traceId", "timestamp", "duration", "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
@@ -71,51 +65,55 @@ def span_event(self, settings, base_attrs=None, parent_guid=None, attr_class=dic
             self.agent_attributes, settings.attribute_filter, DST_SPAN_EVENTS, attr_class=attr_class
         )
         u_attrs = self.processed_user_attributes
-        if settings.distributed_tracing.unique_spans.enabled:
-            # ids is the list of span guids that share this unqiue exit span.
-            u_attrs["nr.ids"] = []
 
         u_attrs = attribute.resolve_user_attributes(
             u_attrs, settings.attribute_filter, DST_SPAN_EVENTS, attr_class=attr_class
         )
+        if not hasattr(self, "partial_granularity_sampled"):
+            # intrinsics, user attrs, agent attrs
+            return [i_attrs, u_attrs, a_attrs]
+        else:
+            if ct_exit_spans is None:
+                ct_exit_spans = {}
 
-        if settings.distributed_tracing.drop_inprocess_spans.enabled or settings.distributed_tracing.unique_spans.enabled:
+            partial_granularity_type = settings.distributed_tracing.sampler.partial_granularity.type
             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"):
-                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/"):
-                return [i_attrs, u_attrs, {"llm": True}] if settings.distributed_tracing.minimize_attributes.enabled else [i_attrs, u_attrs, a_attrs]
+            # If this is the entry node or an LLM span always return it.
+            if i_attrs.get("nr.entryPoint") or i_attrs["name"].startswith("Llm/"):
+                if partial_granularity_type == "reduced":
+                    return [i_attrs, u_attrs, a_attrs]
+                else:
+                    return [i_attrs, {}, {}]
             # If the span is not an exit span, skip it by returning None.
             if not exit_span_attrs_present:
                 return None
-            # If the span is an exit span but unique spans is enabled, we need to check
-            # for uniqueness before returning it.
-            if settings.distributed_tracing.unique_spans.enabled:
+            # If the span is an exit span and we are in reduced mode (meaning no attribute dropping),
+            # just return the exit span as is.
+            if partial_granularity_type == "reduced":
+                return [i_attrs, u_attrs, a_attrs]
+            else:
                 a_minimized_attrs = attr_class({key: a_attrs[key] for key in exit_span_attrs_present})
+                # If we are in essential mode return the span with minimized attributes.
+                if partial_granularity_type == "essential":
+                    return [i_attrs, {}, a_minimized_atts]
+                # 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.
-                # TODO: use attr value name rather than str casting for infinite tracing.
                 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 new_exit_span:
-                    u_attrs["nr.durations"] = self.duration
-                    ct_exit_spans[span_attrs] = [u_attrs]
-                    return [i_attrs, u_attrs, a_minimized_attrs] if settings.distributed_tracing.minimize_attributes.enabled else [i_attrs, u_attrs, a_attrs]
+                    # 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]
+                    return [i_attrs, {}, a_minimized_atts]
                 # 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
-
                 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})
-        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):
         span = self.span_event(settings, base_attrs=base_attrs, parent_guid=parent_guid, attr_class=attr_class, ct_exit_spans=ct_exit_spans)