newrelic 13.2.0 → 13.3.0

package/lib/instrumentation/core/http.js

@@ -10,14 +10,11 @@ const logger = require('../../logger').child({ component: 'http' })
 const recordWeb = require('../../metrics/recorders/http')
 const cat = require('../../util/cat')
 const instrumentOutbound = require('./http-outbound')
-const url = require('url')
 const urltils = require('../../util/urltils')
-const headerAttributes = require('../../header-attributes')
 const headerProcessing = require('../../header-processing')
 const synthetics = require('../../synthetics')
 
 const NAMES = require('../../metrics/names')
-const DESTS = require('../../config/attribute-filter').DESTINATIONS
 const symbols = require('../../symbols')
 
 // For incoming requests this instrumentation functions by wrapping
@@ -41,14 +38,13 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
 
     transaction.nameState.setPrefix(NAMES.NODEJS.PREFIX)
     transaction.nameState.setDelimiter(NAMES.ACTION_DELIMITER)
+    if (request.method != null) {
+      transaction.nameState.setVerb(request.method)
+    }
 
     // Store the transaction information on the request and response.
     const txInfo = storeTxInfo(transaction, request, response)
 
-    if (request) {
-      initializeRequest(transaction, request)
-    }
-
     // Create the transaction segment using the request URL for now. Once a
     // better name can be determined this segment will be renamed to that.
     const segment = tracer.createSegment({
@@ -58,10 +54,7 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
       transaction
     })
     segment.start()
-
-    if (request.method != null) {
-      segment.addSpanAttribute('request.method', request.method)
-    }
+    transaction.baseSegment = segment
 
     if (txInfo) {
       // Seed segment stack to enable parenting logic leveraged by
@@ -69,8 +62,16 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
       txInfo.segmentStack.push(segment)
     }
 
-    transaction.type = 'web'
-    transaction.baseSegment = segment
+    let absoluteUrl = null
+    // handle a request that is to a proxy url
+    if (request?.url.startsWith('http://') || request?.url.startsWith('https://')) {
+      absoluteUrl = request.url
+    // attempt to construct the full URL with known attributes
+    } else {
+      absoluteUrl = `${transport}://${request.headers.host || 'localhost'}${request.url}`
+    }
+    const port = parsePort(this)
+    transaction.initializeWeb({ absoluteUrl, method: request.method, port, headers: request.headers, transport })
 
     /* Needed for Connect and Express middleware that monkeypatch request
      * and response via listeners.
@@ -78,40 +79,8 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
     tracer.bindEmitter(request, segment)
     tracer.bindEmitter(response, segment)
 
-    // the error tracer needs a URL for tracing, even though naming overwrites
-
-    transaction.parsedUrl = url.parse(request.url, true)
-    transaction.url = urltils.obfuscatePath(agent.config, transaction.parsedUrl.pathname)
-    transaction.verb = request.method
-
-    // URL is sent as an agent attribute with transaction events
-    transaction.trace.attributes.addAttribute(
-      DESTS.TRANS_EVENT | DESTS.ERROR_EVENT,
-      'request.uri',
-      transaction.url
-    )
-
-    segment.addSpanAttribute('request.uri', transaction.url)
-
-    transaction.port = parsePort(this)
-    // need to set any config-driven names early for RUM
-    logger.trace(
-      { url: request.url, transaction: transaction.id },
-      'Applying user naming rules for RUM.'
-    )
-    transaction.applyUserNamingRules(request.url)
-
-    const queueTimeStamp = headerProcessing.getQueueTime(logger, request.headers)
-    if (queueTimeStamp) {
-      transaction.queueTime = Date.now() - queueTimeStamp
-    }
-
-    synthetics.assignHeadersToTransaction(agent.config, transaction, request.headers)
-
-    maybeAddDtCatHeaders({ transaction, request, transport, agent })
-
-    response.once('finish', instrumentedFinish.bind(response, segment, transaction))
-    response.once('close', instrumentedFinish.bind(response, segment, transaction))
+    response.once('finish', instrumentedFinish.bind(response, transaction))
+    response.once('close', instrumentedFinish.bind(response, transaction))
 
     const newContext = context.enterSegment({ segment })
     return tracer.bindFunction(emit, newContext).apply(this, arguments)
@@ -136,76 +105,19 @@ function parsePort(server) {
   return serverPort
 }
 
-function maybeAddDtCatHeaders({ agent, request, transaction, transport }) {
-  if (agent.config.distributed_tracing.enabled) {
-    // Node http headers are automatically lowercase
-    transaction.acceptDistributedTraceHeaders(transport, request.headers)
-  } else if (agent.config.cross_application_tracer.enabled) {
-    const { id, transactionId } = cat.extractCatHeaders(request.headers)
-    const { externalId, externalTransaction } = cat.parseCatData(
-      id,
-      transactionId,
-      agent.config.encoding_key
-    )
-    cat.assignCatToTransaction(externalId, externalTransaction, transaction)
-  }
-}
-
 /**
  * Adds instrumentation to response on finish/close.
  * It will add `http.statusCode`, `http.statusText`
  * to the transaction trace and span.
  * It will also assign the response headers to the transaction
  *
- * @param {TraceSegment} segment active segment
  * @param {Transaction} transaction active transaction
  */
-function instrumentedFinish(segment, transaction) {
+function instrumentedFinish(transaction) {
   // Remove listeners so this doesn't get called twice.
   this.removeListener('finish', instrumentedFinish)
   this.removeListener('close', instrumentedFinish)
-
-  // Naming must happen before the segment and transaction are ended,
-  // because metrics recording depends on naming's side effects.
-
-  transaction.finalizeNameFromUri(transaction.parsedUrl, this.statusCode)
-
-  if (this) {
-    const { statusCode, statusMessage } = this
-
-    if (statusCode != null) {
-      const responseCode = String(statusCode)
-
-      if (/^\d+$/.test(responseCode)) {
-        transaction.trace.attributes.addAttribute(
-          DESTS.TRANS_COMMON,
-          'http.statusCode',
-          responseCode
-        )
-
-        segment.addSpanAttribute('http.statusCode', responseCode)
-      }
-    }
-
-    if (statusMessage !== undefined) {
-      transaction.trace.attributes.addAttribute(
-        DESTS.TRANS_COMMON,
-        'http.statusText',
-        statusMessage
-      )
-
-      segment.addSpanAttribute('http.statusText', statusMessage)
-    }
-
-    const headers = this.getHeaders()
-    if (headers) {
-      headerAttributes.collectResponseHeaders(headers, transaction)
-    }
-  }
-
-  // And we are done! End the segment and transaction.
-  segment.end()
-  transaction.end()
+  transaction.finalizeWeb({ end: true, statusCode: this.statusCode, statusMessage: this.statusMessage, headers: this.getHeaders() })
 }
 
 function storeTxInfo(transaction, request, response) {
@@ -227,15 +139,6 @@ function storeTxInfo(transaction, request, response) {
   return txInfo
 }
 
-function initializeRequest(transaction, request) {
-  headerAttributes.collectRequestHeaders(request.headers, transaction)
-
-  if (request.method != null) {
-    transaction.trace.attributes.addAttribute(DESTS.TRANS_COMMON, 'request.method', request.method)
-    transaction.nameState.setVerb(request.method)
-  }
-}
-
 function wrapResponseEnd(agent, proto) {
   const tracer = agent.tracer
 
@@ -419,11 +322,10 @@ function wrapRequest(agent, request) {
     const transaction = agent.tracer.getTransaction()
     if (!transaction || internalOnly) {
       if (!internalOnly && logger.traceEnabled()) {
-        const logOpts = typeof options === 'string' ? url.parse(options) : options
         logger.trace(
           'No transaction, not recording external to %s:%s',
-          logOpts.hostname || logOpts.host,
-          logOpts.port
+          options?.hostname || options?.host,
+          options?.port
         )
       }
       return request.apply(this, reqArgs)

package/lib/instrumentations.js

@@ -35,7 +35,6 @@ module.exports = function instrumentations() {
     mongodb: { type: InstrumentationDescriptor.TYPE_DATASTORE },
     mysql: { module: './instrumentation/mysql' },
     next: { module: './instrumentation/nextjs' },
-    openai: { type: InstrumentationDescriptor.TYPE_GENERIC },
     pg: { type: InstrumentationDescriptor.TYPE_DATASTORE },
     q: { type: null },
     redis: { type: InstrumentationDescriptor.TYPE_DATASTORE },
@@ -59,18 +58,5 @@ module.exports = function instrumentations() {
     knex: { type: InstrumentationDescriptor.TYPE_TRACKING },
     loglevel: { type: InstrumentationDescriptor.TYPE_TRACKING },
     npmlog: { type: InstrumentationDescriptor.TYPE_TRACKING },
-
-    /**
-     * The modules below are listed here is a temporary solution to maintaining
-     * the Supportability/Features/onRequire/<module> metrics for libraries
-     * that have been migrated to use tracing chanel instrumentation.
-     * Once orchestrion can emit the package version, these can be removed.
-     * {@link https://github.com/newrelic/node-newrelic/issues/3308 Github Issue}
-     */
-    '@elastic/elasticsearch': { type: InstrumentationDescriptor.TYPE_TRACKING },
-    '@modelcontextprotocol/sdk/client/index.js': { type: InstrumentationDescriptor.TYPE_TRACKING },
-    '@opensearch-project/opensearch': { type: InstrumentationDescriptor.TYPE_TRACKING },
-    ioredis: { type: InstrumentationDescriptor.TYPE_TRACKING },
-    pino: { type: InstrumentationDescriptor.TYPE_TRACKING }
   }
 }

package/lib/otel/logs/index.js

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const logsApi = require('@opentelemetry/api-logs')
+const logsSdk = require('@opentelemetry/sdk-logs')
+const {
+  isApplicationLoggingEnabled,
+  isLogForwardingEnabled,
+  isMetricsEnabled,
+  incrementLoggingLinesMetrics
+} = require('#agentlib/util/application-logging.js')
+
+const defaultLogger = require('../../logger').child({ component: 'opentelemetry-metrics' })
+const SetupSignal = require('../setup-signal.js')
+const NewRelicLoggerProvider = require('./proxying-provider.js')
+const NoOpExporter = require('./no-op-exporter.js')
+const normalizeTimestamp = require('./normalize-timestamp.js')
+const severityToString = require('./severity-to-string.js')
+
+class SetupLogs extends SetupSignal {
+  constructor({ agent, logger = defaultLogger } = {}) {
+    super({ agent, logger })
+
+    if (isApplicationLoggingEnabled(agent.config) === false) {
+      logger.info('application logging disabled, skipping otel logs setup')
+      return
+    }
+
+    agent.metrics
+      .getOrCreateMetric('Supportability/Nodejs/OpenTelemetryBridge/Logs')
+      .incrementCallCount()
+
+    const exporter = new NoOpExporter()
+    const processor = new logsSdk.BatchLogRecordProcessor(exporter)
+    const otelProvider = new logsSdk.LoggerProvider({
+      processors: [processor]
+    })
+    const provider = new NewRelicLoggerProvider({
+      agent,
+      provider: otelProvider,
+      emitHandler: nrEmitHandler
+    })
+    logsApi.logs.setGlobalLoggerProvider(provider)
+
+    function nrEmitHandler(record) {
+      const level = severityToString(record.severityNumber ?? 0)
+      if (isMetricsEnabled(agent.config) === true) {
+        incrementLoggingLinesMetrics(level, agent.metrics)
+      }
+
+      // TODO: if we decide to support local decorating, implement it here
+
+      if (isLogForwardingEnabled(agent.config, agent) === true) {
+        const meta = agent.getLinkingMetadata(true)
+        const timestamp = normalizeTimestamp(record.timestamp)
+        const logData = {
+          message: record.body,
+          level,
+          timestamp,
+          ...record.attributes,
+          ...meta
+        }
+
+        agent.logs.add(logData)
+      }
+    }
+
+    agent.emit('otelLogsBootstrapped')
+  }
+
+  teardown() {
+    logsApi.logs.disable()
+  }
+}
+
+module.exports = SetupLogs

package/lib/otel/metrics/index.js

@@ -0,0 +1,119 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const { resourceFromAttributes } = require('@opentelemetry/resources')
+const { OTLPMetricExporter } = require('@opentelemetry/exporter-metrics-otlp-proto')
+const {
+  AggregationTemporality,
+  InMemoryMetricExporter,
+  MeterProvider,
+  PeriodicExportingMetricReader
+} = require('@opentelemetry/sdk-metrics')
+
+const defaultLogger = require('../../logger').child({ component: 'opentelemetry-metrics' })
+const SetupSignal = require('../setup-signal.js')
+const ProxyingExporter = require('./proxying-exporter.js')
+
+class SetupMetrics extends SetupSignal {
+  constructor({ agent, logger = defaultLogger } = {}) {
+    super({ agent, logger })
+
+    const { config } = agent
+    const exportInterval = config.opentelemetry_bridge.metrics.exportInterval
+    const exportTimeout = config.opentelemetry_bridge.metrics.exportTimeout
+
+    const resource = resourceFromAttributes({ })
+    const memExporter = new InMemoryMetricExporter(AggregationTemporality.DELTA)
+    const proxyExporter = new ProxyingExporter({ exporter: memExporter })
+    const reader = new PeriodicExportingMetricReader({
+      exporter: proxyExporter,
+      exportIntervalMillis: exportInterval,
+      exportTimeoutMillis: exportTimeout
+    })
+    const provider = new MeterProvider({
+      readers: [reader],
+      resource
+    })
+
+    const getMeter = provider.getMeter
+    provider.getMeter = function nrGetMeter(...args) {
+      agent.metrics
+        .getOrCreateMetric('Supportability/Nodejs/OpenTelemetryBridge/Metrics/getMeter')
+        .incrementCallCount()
+
+      const meter = getMeter.apply(provider, args)
+      const proto = Object.getPrototypeOf(meter)
+      const methods = Object.getOwnPropertyNames(proto).filter((name) => name.startsWith('create'))
+      const originals = {}
+      for (const method of methods) {
+        originals[method] = meter[method]
+        // As of 2025-06-17:
+        // + createGauge
+        // + createHistogram
+        // + createCounter
+        // + createUpDownCounter
+        // + createObservableGauge
+        // + createObservableCounter
+        // + createObservableUpDownCounter
+        meter[method] = function nrWrappedMethod(...args) {
+          agent.metrics
+            .getOrCreateMetric(`Supportability/Nodejs/OpenTelemetryBridge/Metrics/meter/${method}`)
+            .incrementCallCount()
+          return originals[method].apply(meter, args)
+        }
+      }
+
+      return meter
+    }
+
+    this.coreApi.metrics.setGlobalMeterProvider(provider)
+
+    agent.metrics
+      .getOrCreateMetric('Supportability/Nodejs/OpenTelemetryBridge/Metrics')
+      .incrementCallCount()
+
+    // We need access to `agent.config.entity_guid` in order to attach metrics
+    // to the correct instrumentation entity. But that value is not available
+    // until either at least the first firing of `agent.config.on('change')`, or
+    // the `agent.on('started')` event. Which means that we can't finalize the
+    // metrics client configuration until after the `started` event.
+    agent.on('started', postReady)
+    function postReady() {
+      agent.removeListener('started', postReady)
+
+      reader.collect().then(({ resourceMetrics: collectedMetrics }) => {
+        proxyExporter.exporter = new OTLPMetricExporter({
+          url: `https://${config.host}:${config.port}/v1/metrics`,
+          headers: {
+            'api-key': config.license_key
+          },
+          temporalityPreference: AggregationTemporality.DELTA
+        })
+
+        const resource = resourceFromAttributes({ 'entity.guid': config.entity_guid })
+        // Assigning the resource after having received the `entity.guid` from
+        // the server is a key detail of this implementation. Unfortunately,
+        // we don't have real public access to the object that retains the
+        // resource reference. If upstream ever hides this from us, we'll be
+        // in a bit of a bind.
+        provider._sharedState.resource = resource
+
+        // Attempt to ship any metrics recorded prior to the `started` event.
+        collectedMetrics.resource = resource
+        proxyExporter.exporter.export(collectedMetrics, () => {})
+
+        agent.emit('otelMetricsBootstrapped')
+      })
+    }
+  }
+
+  teardown() {
+    this.coreApi.metrics.disable()
+  }
+}
+
+module.exports = SetupMetrics

package/lib/otel/setup-signal.js

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const defaultLogger = require('#agentlib/logger.js').child({ component: 'opentelemetry-bridge' })
+
+/**
+ * SetupSignal is an interface to standardize how we bootstrap OpenTelemetry
+ * observability signals within the OTEL bridge. Subclasses are expected to
+ * implement their setup in the constructor, and to provide a `.teardown`
+ * method that properly cleans up any created resources (i.e. unblocks the
+ * parent singleton managed by the OTEL packages from being garbage collected).
+ */
+class SetupSignal {
+  agent
+  logger
+
+  coreApi = require('@opentelemetry/api')
+
+  constructor({ agent, logger = defaultLogger } = {}) {
+    if (Object.prototype.toString.call(agent) !== '[object Agent]') {
+      throw Error('must provide an instance of the New Relic agent')
+    }
+
+    this.agent = agent
+    this.logger = logger
+  }
+
+  teardown() {
+    this.logger.warn('teardown method is not implemented')
+  }
+}
+
+module.exports = SetupSignal

package/lib/otel/setup.js

@@ -6,18 +6,17 @@
 'use strict'
 
 const opentelemetry = require('@opentelemetry/api')
-const logsApi = require('@opentelemetry/api-logs')
-const { BasicTracerProvider } = require('@opentelemetry/sdk-trace-base')
 
-const NrSpanProcessor = require('./span-processor')
-const NrSampler = require('./sampler')
+const SetupLogs = require('./logs/index.js')
+const SetupMetrics = require('./metrics/index.js')
+const SetupTraces = require('./traces/index.js')
 const ContextManager = require('./context-manager')
 const TracePropagator = require('./trace-propagator')
 const defaultLogger = require('../logger').child({ component: 'opentelemetry-bridge' })
 const createOtelLogger = require('./logger')
 const interceptSpanKey = require('./span-key-interceptor')
-const bootstrapMetrics = require('./metrics/bootstrap-metrics')
-const bootstrapLogs = require('./logs/bootstrap-logs')
+
+const signals = []
 
 function setupOtel(agent, logger = defaultLogger) {
   if (agent.config.opentelemetry_bridge.enabled !== true) {
@@ -38,19 +37,22 @@ function setupOtel(agent, logger = defaultLogger) {
   opentelemetry.propagation.setGlobalPropagator(new TracePropagator(agent))
 
   if (agent.config.opentelemetry_bridge.traces.enabled === true) {
-    bootstrapTraces(agent)
+    const signal = new SetupTraces({ agent })
+    signals.push(signal)
   } else {
     logger.debug('`opentelemetry_bridge.traces` is not enabled, skipping')
   }
 
   if (agent.config.opentelemetry_bridge.metrics.enabled === true) {
-    bootstrapMetrics(agent)
+    const signal = new SetupMetrics({ agent })
+    signals.push(signal)
   } else {
     logger.debug('`opentelemetry_bridge.metrics` is not enabled, skipping')
   }
 
   if (agent.config.opentelemetry_bridge.logs.enabled === true) {
-    bootstrapLogs({ agent })
+    const signal = new SetupLogs({ agent })
+    signals.push(signal)
   } else {
     logger.debug('`opentelemetry_bridge.logs` is not enabled, skipping')
   }
@@ -60,30 +62,18 @@ function setupOtel(agent, logger = defaultLogger) {
     .incrementCallCount()
 }
 
-function bootstrapTraces(agent) {
-  opentelemetry.trace.setGlobalTracerProvider(new BasicTracerProvider({
-    sampler: new NrSampler(),
-    spanProcessors: [new NrSpanProcessor(agent)],
-    generalLimits: {
-      attributeValueLengthLimit: 4095
-    }
-  }))
-
-  agent.metrics
-    .getOrCreateMetric('Supportability/Nodejs/OpenTelemetryBridge/Traces')
-    .incrementCallCount()
-}
-
 function teardownOtel(agent) {
   if (agent?.config?.opentelemetry_bridge?.enabled !== true) {
     return
   }
 
-  opentelemetry.trace.disable()
+  for (const signal of signals) {
+    signal.teardown()
+  }
+
   opentelemetry.context.disable()
   opentelemetry.propagation.disable()
   opentelemetry.diag.disable()
-  logsApi.logs.disable()
 }
 
 module.exports = {

package/lib/otel/{attr-reconciler.js → traces/attr-reconciler.js}

@@ -5,8 +5,8 @@
 
 'use strict'
 
-const urltils = require('../util/urltils')
-const constants = require('./constants')
+const urltils = require('#agentlib/util/urltils.js')
+const constants = require('./constants.js')
 
 const hostKeys = [
   constants.ATTR_NET_HOST_NAME,

package/lib/otel/{exception-mapping.js → traces/exception-mapping.js}

@@ -4,7 +4,7 @@
  */
 
 'use strict'
-const constants = require('./constants')
+const constants = require('./constants.js')
 const attrMappings = {
   msg: {
     attrs: [constants.EXCEPTION_MESSAGE, constants.EXCEPTION_TYPE]

package/lib/otel/traces/index.js

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const { BasicTracerProvider } = require('@opentelemetry/sdk-trace-base')
+
+const defaultLogger = require('../../logger').child({ component: 'opentelemetry-traces' })
+const SetupSignal = require('../setup-signal.js')
+const NrSampler = require('./sampler.js')
+const NrSpanProcessor = require('./span-processor.js')
+
+class SetupTraces extends SetupSignal {
+  constructor({ agent, logger = defaultLogger } = {}) {
+    super({ agent, logger })
+
+    const sampler = new NrSampler()
+    const spanProcessor = new NrSpanProcessor(agent)
+    const traceProvider = new BasicTracerProvider({
+      sampler,
+      spanProcessors: [spanProcessor],
+      generalLimits: {
+        attributeValueLengthLimit: 4_095
+      }
+    })
+    this.coreApi.trace.setGlobalTracerProvider(traceProvider)
+
+    agent.metrics
+      .getOrCreateMetric('Supportability/Nodejs/OpenTelemetryBridge/Traces')
+      .incrementCallCount()
+  }
+
+  teardown() {
+    this.coreApi.trace.disable()
+  }
+}
+
+module.exports = SetupTraces

package/lib/otel/{rules.js → traces/rules.js}

@@ -6,7 +6,7 @@
 'use strict'
 
 const { SpanKind } = require('@opentelemetry/api')
-const srcJson = require('./transformation-rules')
+const srcJson = require('./transformation-rules.json')
 
 /**
  * Mapping rules are stored, and provided to the agent, as JSON. We call these

package/lib/otel/{segment-synthesis.js → traces/segment-synthesis.js}

@@ -4,8 +4,9 @@
  */
 
 'use strict'
-const { RulesEngine } = require('./rules')
-const defaultLogger = require('../logger').child({ component: 'segment-synthesizer' })
+
+const defaultLogger = require('#agentlib/logger.js').child({ component: 'segment-synthesizer' })
+const { RulesEngine } = require('./rules.js')
 const {
   createConsumerSegment,
   createDbSegment,
@@ -13,7 +14,7 @@ const {
   createInternalSegment,
   createProducerSegment,
   createServerSegment
-} = require('./segments')
+} = require('./segments/index.js')
 
 class SegmentSynthesizer {
   constructor(agent, { logger = defaultLogger } = {}) {
@@ -43,7 +44,7 @@ class SegmentSynthesizer {
       }
 
       case 'external': {
-        return createHttpExternalSegment(this.agent, otelSpan, rule)
+        return createHttpExternalSegment(this.agent, otelSpan, rule, this.logger)
       }
 
       case 'internal': {

package/lib/otel/{segments → traces/segments}/consumer.js

@@ -7,10 +7,10 @@
 
 module.exports = createConsumerSegment
 
-const Transaction = require('../../transaction/')
-const recorder = require('../../metrics/recorders/message-transaction')
-const { propagateTraceContext } = require('./utils')
-const createInternalSegment = require('./internal')
+const Transaction = require('#agentlib/transaction/index.js')
+const recorder = require('#agentlib/metrics/recorders/message-transaction.js')
+const { propagateTraceContext } = require('./utils.js')
+const createInternalSegment = require('./internal.js')
 
 function createConsumerSegment(agent, otelSpan, rule) {
   const activeTx = agent.tracer.getTransaction()