newrelic 13.8.0 → 13.9.0

package/lib/otel/traces/span-processor.js

@@ -11,8 +11,17 @@ const urltils = require('#agentlib/util/urltils.js')
 
 const AttributeReconciler = require('./attr-reconciler.js')
 const SegmentSynthesizer = require('./segment-synthesis.js')
+const SpanLink = require('#agentlib/spans/span-link.js')
+const TimedEvent = require('#agentlib/spans/timed-event.js')
+const normalizeTimestamp = require('../normalize-timestamp.js')
 const { otelSynthesis } = require('#agentlib/symbols.js')
-const { assignToTarget, buildRuleMappings, extractAttributeValue, processRegex, transformTemplate } = require('./utils.js')
+const {
+  assignToTarget,
+  buildRuleMappings,
+  extractAttributeValue,
+  processRegex,
+  transformTemplate
+} = require('./utils.js')
 const defaultLogger = require('#agentlib/logger.js').child({ component: 'span-processor' })
 
 const {
@@ -44,15 +53,30 @@ module.exports = class NrSpanProcessor {
   }
 
   /**
-   * Update the segment duration from span, handle errors and
-   * map and reconcile any attributes that were added to the span.
-   * @param {object} span otel span getting updated
+   * Finalize the mapping of the OTEL span to the NR `TraceSegment`
+   * by copying final attributes over, updating the duration, handling
+   * any errors, and ending the transaction if necessary.
+   *
+   * @param {object} span source otel span
    */
   onEnd(span) {
     if (span[otelSynthesis] && span[otelSynthesis].segment) {
       const { segment, transaction, rule } = span[otelSynthesis]
       const { instrumentationScope } = span
 
+      // OTEL spans have a status attribute. We copy this information over
+      // to our agent attributes as informational metadata.
+      let code
+      switch (span.status.code) {
+        case 0: { code = 'unset'; break }
+        case 1: { code = 'ok'; break }
+        case 2: { code = 'error'; break }
+      }
+      segment.addAttribute('status.code', code)
+      if (code === 'error') {
+        segment.addAttribute('status.description', span.status.message)
+      }
+
       // We always attach the instrumentation scope data as agent attributes
       // if the OTEL span has them set.
       // See https://opentelemetry.io/docs/specs/otel/common/mapping-to-non-otlp/#instrumentationscope
@@ -67,8 +91,14 @@ module.exports = class NrSpanProcessor {
 
       this.updateDuration(segment, span)
       this.handleError({ segment, transaction, span })
+      this.reconcileLinks({ otelSpan: span, segment })
+      this.reconcileEvents({ segment, span })
       this.reconcileAttributes({ segment, span, transaction, rule })
       delete span[otelSynthesis]
+
+      if (span.kind === SpanKind.SERVER || span.kind === SpanKind.CONSUMER) {
+        this.finalizeTransaction({ segment, span, transaction, rule, config: this.agent.config })
+      }
     }
   }
 
@@ -106,20 +136,52 @@ module.exports = class NrSpanProcessor {
   }
 
   /**
-   * Adds attributes to the segment, transaction or trace based on the
-   * transformation rule. If the span is a server or consumer span,
-   * it will also finalize the transaction.
-   * @param {object} params - The parameters for the reconciliation.
-   * @param {object} params.segment - The segment to add attributes to.
-   * @param {object} params.span - The span to add attributes from.
-   * @param {object} params.transaction - The transaction to add attributes to.
-   * @param {object} params.rule - The transformation rule to use.
+   * Iterates the span events that have been added to the span and attaches
+   * them to the `TraceSegment` in the format expected by the New Relic
+   * collector.
+   *
+   * @param {object} params Function parameters
+   * @param {object} params.span The OTEL span that may contain events.
+   * @param {object} params.segment The target segment to attach the events to.
    */
-  reconcileAttributes({ segment, span, transaction, rule = {} }) {
-    this.mapAttributes({ segment, span, transaction, rule })
+  reconcileEvents({ segment, span }) {
+    if (span.events.length < 1) {
+      return
+    }
+
+    const spanContext = span.spanContext()
+    for (let i = 0; i < span.events.length; i++) {
+      const event = new TimedEvent({
+        event: span.events[i],
+        spanContext
+      })
+      segment.addTimedEvent(event)
+    }
+  }
+
+  /**
+   * Iterates the span links that have been added to the span and attaches
+   * them to the `TraceSegment` in the format expected by the New Relic
+   * collector.
+   *
+   * @param {object} params Function parameters
+   * @param {object} params.otelSpan The OTEL span that may contain links.
+   * @param {object} params.segment The target segment to attach the links to.
+   */
+  reconcileLinks({ otelSpan, segment }) {
+    if (otelSpan.links.length < 1) {
+      return
+    }
 
-    if (span.kind === SpanKind.SERVER || span.kind === SpanKind.CONSUMER) {
-      this.finalizeTransaction({ segment, span, transaction, rule, config: this.agent.config })
+    const spanContext = otelSpan.spanContext()
+    const timestamp = normalizeTimestamp(otelSpan.startTime)
+    for (let i = 0; i < otelSpan.links.length; i += 1) {
+      const link = new SpanLink({
+        link: otelSpan.links.at(i),
+        spanContext,
+        timestamp
+      })
+      segment.addSpanLink(link)
     }
   }
 
@@ -130,9 +192,9 @@ module.exports = class NrSpanProcessor {
    * @param {object} params.segment - The segment to add attributes to.
    * @param {object} params.span - The span to add attributes from.
    * @param {object} params.transaction - The transaction to add attributes to.
-   * @param {object} params.rule - The transformation rule to use.
+   * @param {object} [params.rule] - The transformation rule to use.
    */
-  mapAttributes({ segment, span, transaction, rule }) {
+  reconcileAttributes({ segment, span, transaction, rule = {} }) {
     const excludeAttributes = new Set()
     for (const attribute of rule.attributes) {
       const { key, target, name, highSecurity, regex } = attribute

package/lib/samplers/adaptive-sampler.js

@@ -108,19 +108,25 @@ class AdaptiveSampler extends Sampler {
   applySamplingDecision({ transaction, tracestate, partialType }) {
     if (!transaction) return
     transaction.partialType = partialType
-    if (tracestate) {
+    if (tracestate?.intrinsics) {
       // Explicitly set sampled and priority from tracestate intrinsics if available
-      transaction.sampled = tracestate?.intrinsics ? tracestate.isSampled : null
-      transaction.priority = tracestate?.intrinsics ? tracestate.priority : null
+      transaction.sampled = tracestate.isSampled
+      let initPriority = tracestate.priority
+      // If tracestate has intrinsics but lacks a priority we must generate a random priority
+      // if sampled, we also have to increment accordingly based on full/partial traces
+      if (!initPriority && tracestate.isSampled) {
+        initPriority = Sampler.generatePriority()
+        initPriority = Sampler.incrementPriority(initPriority, partialType)
+      }
+
+      transaction.priority = initPriority
       return
     }
 
     // If a tracestate is not defined, then do our normal priority calculation.
-
     const initPriority = Sampler.generatePriority()
     transaction.sampled = this.shouldSample(initPriority)
-    // only add 1 to priority when doing a full trace
-    transaction.priority = transaction.sampled && !partialType ? Sampler.incrementPriority(initPriority, 1) : initPriority
+    transaction.priority = transaction.sampled ? Sampler.incrementPriority(initPriority, partialType) : initPriority
   }
 
   /**

package/lib/samplers/index.js

@@ -11,6 +11,7 @@ const AlwaysOnSampler = require('./always-on-sampler')
 const TraceIdRatioBasedSampler = require('./ratio-based-sampler')
 const logger = require('../logger').child({ component: 'samplers' })
 const { PARTIAL_TYPES } = require('../transaction')
+const { SAMPLERS } = require('#agentlib/metrics/names.js')
 
 /**
  * Manages the different samplers used for distributed tracing sampling decisions.
@@ -19,7 +20,8 @@ const { PARTIAL_TYPES } = require('../transaction')
  * @typedef {object} Samplers
  * @property {boolean} fullEnabled Whether full granularity sampling is enabled.
  * @property {boolean} partialEnabled Whether partial granularity sampling is enabled.
- * @property {AdaptiveSampler|null} adaptiveSampler The global adaptive sampler instance, this is shared if `sampling_target` is not defined for a sampler type of `adaptive`.
+ * @property {AdaptiveSampler|null} adaptiveSampler The global adaptive sampler instance;
+ * this is shared if `sampling_target` is not defined for a sampler type of `adaptive`.
  * @property {Sampler} root The root sampler for traces originating in application.
  * @property {Sampler} remoteParentSampled The sampler for traces with a remote parent that is sampled.
  * @property {Sampler} remoteParentNotSampled The sampler for traces with a remote parent that is not sampled.
@@ -39,6 +41,40 @@ class Samplers {
     this.partialRoot = this.determineSampler({ agent, sampler: 'root', isPartial: true })
     this.partialRemoteParentSampled = this.determineSampler({ agent, sampler: 'remote_parent_sampled', isPartial: true })
     this.partialRemoteParentNotSampled = this.determineSampler({ agent, sampler: 'remote_parent_not_sampled', isPartial: true })
+    this.#sendCoreTracingMetrics(agent)
+  }
+
+  /**
+   * Sends relevant Core Tracing metrics on startup in the form:
+   * `Supportability/Nodejs/<granularity type>/<sampler section>/<sampler type>`
+   * @param {Agent} agent agent instance with these `Samplers`
+   */
+  #sendCoreTracingMetrics(agent) {
+    const metrics = agent.metrics
+    if (this.partialEnabled) {
+      // Supportability/Nodejs/PartialGranularity/<sampler section>/<sampler type>
+      metrics.getOrCreateMetric(`${SAMPLERS.PARTIAL.ROOT}/${this.#determineSamplerType(this.partialRoot)}`)
+      metrics.getOrCreateMetric(`${SAMPLERS.PARTIAL.PARENT_SAMPLED}/${this.#determineSamplerType(this.partialRemoteParentSampled)}`)
+      metrics.getOrCreateMetric(`${SAMPLERS.PARTIAL.PARENT_NOT_SAMPLED}/${this.#determineSamplerType(this.partialRemoteParentNotSampled)}`)
+    }
+    if (this.fullEnabled) {
+      // Supportability/Nodejs/PartialGranularity/<sampler section>/<sampler type>
+      metrics.getOrCreateMetric(`${SAMPLERS.FULL.ROOT}/${this.#determineSamplerType(this.root)}`)
+      metrics.getOrCreateMetric(`${SAMPLERS.FULL.PARENT_SAMPLED}/${this.#determineSamplerType(this.remoteParentSampled)}`)
+      metrics.getOrCreateMetric(`${SAMPLERS.FULL.PARENT_NOT_SAMPLED}/${this.#determineSamplerType(this.remoteParentNotSampled)}`)
+    }
+  }
+
+  /**
+   *
+   * @param {Sampler} sampler an instance of a Sampler
+   * @returns {string} 'Adaptive/Shared', 'Adaptive', 'AlwaysOn', 'AlwaysOff', or 'TraceIdRatioBased'
+   */
+  #determineSamplerType(sampler) {
+    if (sampler === this.adaptiveSampler) {
+      return 'Adaptive/Shared'
+    }
+    return sampler.toString().replace('Sampler', '')
   }
 
   /**

package/lib/samplers/ratio-based-sampler.js

@@ -26,8 +26,7 @@ class TraceIdRatioBasedSampler extends Sampler {
     transaction.partialType = partialType
     const initPriority = Sampler.generatePriority()
     transaction.sampled = this.shouldSample(transaction.traceId)
-    // only add 1 to priority when doing a full trace
-    transaction.priority = transaction.sampled && !partialType ? Sampler.incrementPriority(initPriority, 1) : initPriority
+    transaction.priority = transaction.sampled ? Sampler.incrementPriority(initPriority, partialType) : initPriority
   }
 
   /**

package/lib/samplers/sampler.js

@@ -45,11 +45,13 @@ class Sampler {
 
   /**
    * Used to increment priority and truncate to 6 decimal places.
+   * Full traces are incremented by 2 and partial traces are incremented by 1
    * @param {number} priority the current priority
-   * @param {number} increment the amount to increment by
+   * @param {string|null} partialType if a partial trace
    * @returns {number} the incremented priority
    */
-  static incrementPriority(priority, increment) {
+  static incrementPriority(priority, partialType) {
+    const increment = partialType ? 1 : 2
     const newPriority = priority + increment
     return ((newPriority * 1e6) | 0) / 1e6
   }

package/lib/serverless/aws-lambda.js

@@ -200,14 +200,13 @@ class AwsLambda {
         return handler.apply(this, args)
       }
 
-      const event = args[0]
-      const context = args[2]
+      const [event, responseStream, context] = args
       logger.trace('In stream handler, lambda function name', context?.functionName)
       const { segment, txnEnder } = awsLambda.createSegment({ context, event, transaction, recorder: recordBackground })
       args[1] = awsLambda.wrapStreamAndCaptureError(
         transaction,
         txnEnder,
-        args[1]
+        responseStream
       )
 
       let res
@@ -238,8 +237,7 @@ class AwsLambda {
         return handler.apply(this, args)
       }
 
-      const event = args[0]
-      const context = args[1]
+      const [event, context, callback] = args
       logger.trace('Lambda function name', context?.functionName)
       const isApiGatewayLambdaProxy = apiGateway.isLambdaProxyEvent(event)
       logger.trace('Is this Lambda event an API Gateway or ALB web proxy?', isApiGatewayLambdaProxy)
@@ -256,16 +254,24 @@ class AwsLambda {
         setWebRequest(transaction, webRequest)
         resultProcessor = getApiGatewayLambdaProxyResultProcessor(transaction)
       }
-      const cbIndex = args.length - 1
-      args[cbIndex] = awsLambda.wrapCallbackAndCaptureError(
-        transaction,
-        txnEnder,
-        args[cbIndex],
-        resultProcessor
-      )
+
+      if (typeof callback === 'function') {
+        logger.trace('Wrapping Lambda handler callback')
+        const cbIndex = args.length - 1
+        args[cbIndex] = awsLambda.wrapCallbackAndCaptureError(
+          transaction,
+          txnEnder,
+          callback,
+          resultProcessor
+        )
+      } else {
+        logger.trace('Lambda handler callback not present, skip wrapping')
+      }
 
       // context.{done,fail,succeed} are all considered deprecated by
       // AWS, but are considered functional.
+      // TODO: Remove when we drop Node.js 22
+      // see: https://aws.amazon.com/blogs/compute/node-js-24-runtime-now-available-in-aws-lambda/
       context.done = awsLambda.wrapCallbackAndCaptureError(transaction, txnEnder, context.done)
       context.fail = awsLambda.wrapCallbackAndCaptureError(transaction, txnEnder, context.fail)
       shim.wrap(context, 'succeed', function wrapSucceed(shim, original) {

package/lib/spans/helpers.js

@@ -60,72 +60,10 @@ function addSpanKind({ segment, span }) {
   }
 }
 
-/**
- * Checks if the segment is an entry point span.
- * An entry point span is defined as the base segment of a transaction.
- * @param {object} params to function
- * @param {Transaction} params.transaction active transaction
- * @param {TraceSegment} params.segment segment that is creating span
- * @returns {boolean} true if the segment is an entry point span
- */
-function isEntryPointSpan({ transaction, segment }) {
-  return transaction?.baseSegment === segment
-}
-
-/**
- * Checks if the segment is an exit span.
- * An exit span is defined as a segment that is an external call,
- * datastore operation, or message broker operation.
- * @param {TraceSegment} segment segment that is creating span
- * @returns {boolean} true if the segment is an exit span
- */
-function isExitSpan(segment) {
-  return REGEXS.CLIENT.EXTERNAL.test(segment.name) || REGEXS.CLIENT.DATASTORE.test(segment.name) || REGEXS.PRODUCER.test(segment.name)
-}
-
-/**
- * Determines if a span should be created based on the segment and transaction.
- * If the segment is an entry point span or an exit span, a span should be created.
- * @param {object} params to function
- * @param {boolean} params.entryPoint true if the segment is an entry point span
- * @param {TraceSegment} params.segment segment that is creating span
- * @returns {boolean} true if a span should be created
- */
-function shouldCreateSpan({ entryPoint, segment }) {
-  return entryPoint ||
-         isExitSpan(segment)
-}
-
-/**
- * Reparents a span based on the transaction and inProcessSpans.
- * If inProcessSpans is true or the transaction has accepted distributed trace and it's the root segment,
- * the parentId is not changed.
- * If there is a parentId and the transaction has a base segment, the span is reparented to the base segment.
- * If there is no parentId, the span is not reparented(indicates an entry root span for a DT trace).
- * @param {object} params to function
- * @param {boolean} params.inProcessSpans true if in-process spans are enabled
- * @param {boolean} params.isRoot true if the segment is the root segment
- * @param {string} params.parentId the parent id of the segment
- * @param {Transaction} params.transaction active transaction
- * @returns {string|null} the new parentId for the span
- */
-function reparentSpan({ inProcessSpans, isRoot, parentId, transaction }) {
-  if (inProcessSpans || (transaction.acceptedDistributedTrace && isRoot)) {
-    return parentId
-  } else if (parentId && transaction?.baseSegment?.id) {
-    return transaction.baseSegment.id
-  } else {
-    return null
-  }
-}
-
 module.exports = {
   HTTP_LIBRARY,
   CATEGORIES,
   SPAN_KIND,
   REGEXS,
-  addSpanKind,
-  isEntryPointSpan,
-  reparentSpan,
-  shouldCreateSpan
+  addSpanKind
 }

package/lib/spans/span-event-aggregator.js

@@ -21,7 +21,6 @@ class SpanEventAggregator extends EventAggregator {
     opts.metricNames = opts.metricNames || NAMES.SPAN_EVENTS
 
     super(opts, agent)
-    this.inProcessSpans = agent.config.distributed_tracing.in_process_spans.enabled
   }
 
   _toPayloadSync() {
@@ -45,6 +44,11 @@ class SpanEventAggregator extends EventAggregator {
         Array.prototype.push.apply(eventsPayload, event.spanLinks)
         delete event.spanLinks
       }
+
+      if (event.timedEvents.length > 0) {
+        Array.prototype.push.apply(eventsPayload, event.timedEvents)
+        delete event.timedEvents
+      }
     }
 
     return [this.runId, metrics, eventsPayload]
@@ -80,8 +84,9 @@ class SpanEventAggregator extends EventAggregator {
    * @param {Transaction} params.transaction active transaction
    * @param {string} [params.parentId] GUID of the parent span.
    * @param {boolean} params.isRoot if segment is root segment
+   * @param {boolean} params.isEntry if segment is entry point
    */
-  addSegment({ segment, transaction, parentId, isRoot }) {
+  addSegment({ segment, transaction, parentId, isRoot, isEntry }) {
     // Check if the priority would be accepted before creating the event object.
 
     if (transaction.priority < this._items.getMinimumPriority()) {
@@ -91,19 +96,11 @@ class SpanEventAggregator extends EventAggregator {
       return false
     }
 
-    const span = SpanEvent.fromSegment({ segment, transaction, parentId, isRoot, inProcessSpans: this.inProcessSpans })
+    const span = SpanEvent.fromSegment({ segment, transaction, parentId, isRoot, isEntry })
 
     // Do not add span to aggregator if it is part of a partial trace
-    // We need to reparent spans or in the case of `compact`, associate
-    // all exit spans dropped to the same entity as `nr.ids` and `nr.durations`
-    if (transaction.partialType) {
-      const prefix = `${this._metricNames.PARTIAL_PREFIX}/${transaction.partialType}`
-      this._metrics.getOrCreateMetric(prefix).incrementCallCount()
-      this._metrics.getOrCreateMetric(`${prefix}${this._metricNames.INSTRUMENTED}`).incrementCallCount()
-      transaction.trace.addSpan({ span, id: segment.id, parentId })
-      if (span) {
-        this._metrics.getOrCreateMetric(`${prefix}${this._metricNames.KEPT}`).incrementCallCount()
-      }
+    if (transaction.partialTrace) {
+      transaction.partialTrace.addSpan({ span, isEntry })
     } else if (span) {
       this.add(span, transaction.priority)
     }