refactor: Updated when partial granularity rules are applied (newrelic#3553)

Author: bizob2828

lib/spans/span-event.js

@@ -12,33 +12,24 @@ const { DESTINATIONS } = require('../config/attribute-filter')
 const { addSpanKind, isEntryPointSpan, reparentSpan, shouldCreateSpan, HTTP_LIBRARY, REGEXS, SPAN_KIND, CATEGORIES } = require('./helpers')
 const EMPTY_USER_ATTRS = Object.freeze(Object.create(null))
 const SERVER_ADDRESS = 'server.address'
+const logger = require('../logger').child({ component: 'span-event' })
+
 /**
  * This keeps a static list of attributes that are used by
  * one or more entity relationship rules to synthesize an entity relationship.
- * Note: These attributes also have corresponding TraceSegment attributes
- * as this list is checked before a span is made.  The ones that are TraceSegment
- * attributes are noted in the comments. Any new span attributes being added must
- * be checked to ensure those are what is getting assigned to the TraceSegment as well.
  */
 const SPAN_ENTITY_RELATIONSHIP_ATTRIBUTES = [
   'cloud.account.id',
   'cloud.platform',
   'cloud.region',
   'cloud.resource_id',
-  'database_name', // gets mapped to `db.instance`
   'db.instance',
-  'product', // gets mapped to `db.system`
   'db.system',
   'http.url',
-  'url', // gets mapped to `http.url`
   'messaging.destination.name',
   'messaging.system',
   'peer.hostname',
-  'host', // gets mapped to `server.address`
-  'hostname', // gets mapped to `server.address`
   'server.address',
-  'port', // gets mapped to `server.port`
-  'port_path_or_id', // gets mapped to `server.port`
   'server.port',
   'span.kind',
 ]
@@ -147,63 +138,74 @@ class SpanEvent {
     return HttpSpanEvent
   }
 
-  static isExitSpan(segment) {
-    return REGEXS.CLIENT.EXTERNAL.test(segment.name) || REGEXS.CLIENT.DATASTORE.test(segment.name) || REGEXS.PRODUCER.test(segment.name)
+  static isExitSpan(span) {
+    const name = span.intrinsics?.name
+    return REGEXS.CLIENT.EXTERNAL.test(name) || REGEXS.CLIENT.DATASTORE.test(name) || REGEXS.PRODUCER.test(name)
   }
 
-  static isLlmSpan(segment) {
-    return segment.name.startsWith('Llm/')
+  static isLlmSpan(span) {
+    return span.intrinsics?.name?.startsWith('Llm/')
   }
 
   /**
-   * Filters attributes for partial trace span events based on a given mode.
+   * Drops span or filters attributes based on partial trace rules for a given mode.
    * The rules are as such:
-   *  - If not a partial trace, return all attributes.
-   *  - If an entry point span, return all attributes.
-   *  - If an LLM span, return all attributes.
-   *  - If not an exit span, return no attributes.
-   *  - If mode is 'reduced' and there are entity relationship attributes, return all attributes.
-   *  - Otherwise, return no attributes.
+   *  - If not a partial trace, return span untouched
+   *  - If an entry point span, return span untouched
+   *  - If an LLM span, return span untouched
+   *  - If not an exit span, return null(aka drop span)
+   *  - If mode is 'reduced' and there are entity relationship attributes, return span untouched
+   *  - If mode is 'essential' and there are entity relationship attributes or error attributes, return span with only those attributes, drop custom attributes
+   *  - Otherwise return null(aka drop span)
    *
    *  @param {object} params to function
-   *  @param {TraceSegment} params.segment segment to filter attributes from
-   *  @param {SpanContext} params.spanContext span context to filter attributes from
+   *  @param {SpanEvent} params.span span to apply rules to
    *  @param {boolean} params.entryPoint whether the span is an entry point
    *  @param {string} params.partialGranularityMode mode of partial trace ('reduced', 'essential', 'compact')
    *  @param {boolean} params.isPartialTrace whether the trace is a partial trace
-   *  @returns {object} { attributes, customAttributes, dropSpan: boolean }
+   *  @returns {SpanEvent|null} the span after applying the rules, or null if dropped
    */
-  static filterPartialTraceAttributes({ segment, spanContext, entryPoint, partialGranularityMode, isPartialTrace }) {
-    const attributes = segment.attributes.get(DESTINATIONS.SPAN_EVENT)
-    const customAttributes = spanContext.customAttributes.get(DESTINATIONS.SPAN_EVENT)
-    if (!isPartialTrace || entryPoint || SpanEvent.isLlmSpan(segment)) {
-      return { attributes, customAttributes, dropSpan: false }
+  static applyPartialTraceRules({ span, entryPoint, partialGranularityMode, isPartialTrace }) {
+    const isLlmSpan = SpanEvent.isLlmSpan(span)
+
+    if (!isPartialTrace || entryPoint || isLlmSpan) {
+      logger.trace('Span %s is either not a partial trace: %s, an entry point: %s, or an LLM span: %s, keeping span unchanged.', span.intrinsics.name, isPartialTrace, entryPoint, isLlmSpan)
+      return span
     }
 
-    if (!SpanEvent.isExitSpan(segment)) {
-      return { dropSpan: true }
+    if (!SpanEvent.isExitSpan(span)) {
+      logger.trace('Span %s is not an exit span and trace is partial granularity mode: %s.', span.intrinsics.name, partialGranularityMode)
+      return null
     }
 
+    const attributes = span.attributes
     const attrKeys = Object.keys(attributes)
     const entityRelationshipAttrs = SPAN_ENTITY_RELATIONSHIP_ATTRIBUTES.filter((item) => attrKeys.includes(item))
     if (partialGranularityMode === 'reduced') {
-      if (entityRelationshipAttrs.length > 0) {
-        return { attributes, customAttributes, dropSpan: false }
+      if (entityRelationshipAttrs.length === 0) {
+        logger.trace('Span %s does not contain any entity relationship attributes %j and trace is partial granularity mode: %s, dropping span.', span.intrinsics.name, span.attributes, partialGranularityMode)
+        return null
       }
+      logger.trace('Span %s contains entity relationship attributes and trace is partial granularity mode: %s, keeping span unchanged.', span.intrinsics.name, partialGranularityMode)
     } else if (partialGranularityMode === 'essential') {
-      const attributesToKeep = {}
+      const attributesToKeep = Object.create(null)
       for (const item in attributes) {
         if (entityRelationshipAttrs.includes(item) || item.startsWith('error.')) {
           attributesToKeep[item] = attributes[item]
         }
       }
 
-      if (Object.keys(attributesToKeep).length > 0) {
-        return { attributes: attributesToKeep, customAttributes: {}, dropSpan: false }
+      if (Object.keys(attributesToKeep).length === 0) {
+        logger.trace('Span %s does not contain any entity relationship attributes %j and trace is partial granularity mode: %s, dropping span.', span.intrinsics.name, span.attributes, partialGranularityMode)
+        return null
       }
+
+      span.attributes = attributesToKeep
+      span.customAttributes = Object.create(null)
+      logger.trace('Span %s contains entity relationship attributes and trace is partial granularity mode: %s, only keeping entity relationship attributes and removing custom attributes.', span.intrinsics.name, partialGranularityMode)
     }
 
-    return { dropSpan: true }
+    return span
   }
 
   static createSpan({ segment, attributes, customAttributes }) {
@@ -252,17 +254,13 @@ class SpanEvent {
       }
     }
 
-    const { attributes, customAttributes, dropSpan } = SpanEvent.filterPartialTraceAttributes({ spanContext, entryPoint, segment, partialGranularityMode, isPartialTrace: transaction.isPartialTrace })
-    // If attributes were stripped out due to partial trace filtering, do not create span.
-    if (dropSpan) {
-      return null
-    }
-
+    const attributes = segment.attributes.get(DESTINATIONS.SPAN_EVENT)
+    const customAttributes = spanContext.customAttributes.get(DESTINATIONS.SPAN_EVENT)
     const span = SpanEvent.createSpan({ segment, attributes, customAttributes })
     span.addIntrinsics({ segment, spanContext, transaction, parentId, isRoot, inProcessSpans, entryPoint })
 
     addSpanKind({ segment, span })
-    return span
+    return SpanEvent.applyPartialTraceRules({ span, entryPoint, partialGranularityMode, isPartialTrace: transaction.isPartialTrace })
   }
 
   toJSON() {