newrelic 13.2.1 → 13.3.0

package/NEWS.md

@@ -1,13 +1,45 @@
-### v13.2.1 (2025-08-21)
-
-#### Code refactoring
-
-* Updated agent to use `@apm-js-collab/tracing-hooks` for the CJS/ESM registration for tracing channel based instrumentation ([#3324](https://github.com/newrelic/node-newrelic/pull/3324)) ([4b2c14f](https://github.com/newrelic/node-newrelic/commit/4b2c14f35d5c658160ad9420ca562f73ae55bbc0))
-
-#### Documentation
-
-* Updated compatibility report ([#3330](https://github.com/newrelic/node-newrelic/pull/3330)) ([2831a89](https://github.com/newrelic/node-newrelic/commit/2831a895e0278a05bed8e9f81245c7f9ae515eca))
-
+### v13.3.0 (2025-09-08)
+
+#### Features
+
+* Added MCP `StreamableHTTPClientTransport` support ([#3337](https://github.com/newrelic/node-newrelic/pull/3337)) ([7189a35](https://github.com/newrelic/node-newrelic/commit/7189a35d0676a01d995420b2c6f27a54f8eb0307))
+
+#### Code refactoring
+
+* Removed instances of `url.parse`. Streamlined how http instrumentation creates relevant attributes. ([#3340](https://github.com/newrelic/node-newrelic/pull/3340)) ([1fc1e1a](https://github.com/newrelic/node-newrelic/commit/1fc1e1a4086200bd3fd76081913498d7ca344a3a))
+* Updated `openai` instrumentation to subscribe to events emitted ([#3331](https://github.com/newrelic/node-newrelic/pull/3331)) ([04dd677](https://github.com/newrelic/node-newrelic/commit/04dd6774df87489cce41b0bb2b60c56b79e2265d))
+
+#### Documentation
+
+* Updated compatibility report ([#3344](https://github.com/newrelic/node-newrelic/pull/3344)) ([e422919](https://github.com/newrelic/node-newrelic/commit/e4229195318b2d2e33cc753b7898357daf72a372))
+
+#### Miscellaneous chores
+
+* Refactored OTEL bridge signals setup ([#3244](https://github.com/newrelic/node-newrelic/pull/3244)) ([ec8edef](https://github.com/newrelic/node-newrelic/commit/ec8edefdc49de276f30a1fc778f09b0d3042c392))
+
+#### Tests
+
+* Added more cassandra-driver tests ([#3323](https://github.com/newrelic/node-newrelic/pull/3323)) ([d2e9d10](https://github.com/newrelic/node-newrelic/commit/d2e9d103ee74358e88e53ab89c498f261f387ae5))
+* Fixed long running benchmark test and add `shimmer.subscribers` benchmark test ([#3349](https://github.com/newrelic/node-newrelic/pull/3349)) ([15253c0](https://github.com/newrelic/node-newrelic/commit/15253c08f6d8381f516040e339a0aedaf04e365e))
+* Fixed langchain openai streaming tests by explicitly passing `streaming: true` to chat model ([#3346](https://github.com/newrelic/node-newrelic/pull/3346)) ([4f12499](https://github.com/newrelic/node-newrelic/commit/4f12499c2c9248b7f510c76f19cc8d54eb53da2e))
+* Fixed openai test after migration to tracing channel ([#3336](https://github.com/newrelic/node-newrelic/pull/3336)) ([0d01e29](https://github.com/newrelic/node-newrelic/commit/0d01e299cb84c9715f3136ab458534c72eea3145))
+* Hardened `batch-span-streamer.test.js` to avoid random failures in CI ([#3338](https://github.com/newrelic/node-newrelic/pull/3338)) ([2077ce3](https://github.com/newrelic/node-newrelic/commit/2077ce35db319d0128337faed0ff77b00f76d8f1))
+
+#### Continuous integration
+
+* Set benchmark host default to staging ([#3332](https://github.com/newrelic/node-newrelic/pull/3332)) ([55f6b8d](https://github.com/newrelic/node-newrelic/commit/55f6b8d757afc1632f1be1c0ef1a4ccab23ca3c4))
+* Updated the redis container to use the official `redis` image as `bitnami/redis` is moving and no reason to use a 3rd party image ([#3342](https://github.com/newrelic/node-newrelic/pull/3342)) ([8ffb393](https://github.com/newrelic/node-newrelic/commit/8ffb393ef5e84b188d899580061b2b57171e8166))
+
+### v13.2.1 (2025-08-21)
+
+#### Code refactoring
+
+* Updated agent to use `@apm-js-collab/tracing-hooks` for the CJS/ESM registration for tracing channel based instrumentation ([#3324](https://github.com/newrelic/node-newrelic/pull/3324)) ([4b2c14f](https://github.com/newrelic/node-newrelic/commit/4b2c14f35d5c658160ad9420ca562f73ae55bbc0))
+
+#### Documentation
+
+* Updated compatibility report ([#3330](https://github.com/newrelic/node-newrelic/pull/3330)) ([2831a89](https://github.com/newrelic/node-newrelic/commit/2831a895e0278a05bed8e9f81245c7f9ae515eca))
+
 ### v13.2.0 (2025-08-20)
 
 #### Features
@@ -7823,3 +7855,5 @@ Special thanks to Ryan Copley (@RyanCopley) for the contribution.
 [mdn-async-function]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function
 
 
+
+

package/api.js

@@ -1133,7 +1133,7 @@ API.prototype.endTransaction = function endTransaction() {
   if (tx) {
     if (tx.baseSegment) {
       if (tx.type === 'web') {
-        tx.finalizeNameFromUri(tx.url, 0)
+        tx.finalizeNameFromWeb(0)
       }
       tx.baseSegment.end()
     }

package/lib/instrumentation/@azure/functions.js

@@ -6,9 +6,6 @@
 'use strict'
 
 const defaultLogger = require('../../logger').child({ component: 'azure-functions' })
-const urltils = require('../../util/urltils')
-const headerProcessing = require('../../header-processing')
-const synthetics = require('../../synthetics')
 const { Transform } = require('node:stream')
 
 const backgroundRecorder = require('../../metrics/recorders/other.js')
@@ -29,12 +26,8 @@ const RESOURCE_GROUP_NAME = WEBSITE_RESOURCE_GROUP ?? WEBSITE_OWNER_NAME?.split(
 const AZURE_FUNCTION_APP_NAME = WEBSITE_SITE_NAME
 
 let coldStart = true
-let _agent
-let _logger
 
-module.exports = function initialize(agent, azureFunctions, _moduleName, shim, { logger = defaultLogger } = {}) {
-  _agent = agent
-  _logger = logger
+module.exports = function initialize(_agent, azureFunctions, _moduleName, shim, { logger = defaultLogger } = {}) {
   if (!SUBSCRIPTION_ID || !RESOURCE_GROUP_NAME || !AZURE_FUNCTION_APP_NAME) {
     logger.warn(
       {
@@ -91,7 +84,6 @@ function wrapAzureHttpMethods(shim, appMethod) {
       // Set the transaction name according to our spec (category + function name).
       tx.setPartialName(`AzureFunction/${context.functionName}`)
 
-      const url = new URL(request.url)
       const segment = tracer.createSegment({
         name: request.url,
         recorder: recordWeb,
@@ -100,56 +92,26 @@ function wrapAzureHttpMethods(shim, appMethod) {
       })
       segment.start()
 
+      const absoluteUrl = request.url
+      const url = new URL(absoluteUrl)
       const transport = url.protocol === 'https:' ? 'HTTPS' : 'HTTP'
-      tx.type = TYPES.WEB
+      const port = url.port || (transport === 'HTTPS' ? 443 : 80)
       tx.baseSegment = segment
-      tx.parsedUrl = url
-      tx.url = urltils.obfuscatePath(_agent.config, url.pathname)
-      tx.verb = request.method
-      if (url.port === '') {
-        tx.port = transport === 'HTTPS' ? '443' : '80'
-      } else {
-        tx.port = url.port
-      }
+      tx.initializeWeb({ absoluteUrl, method: request.method, port, headers: request.headers, transport })
 
-      tx.trace.attributes.addAttribute(
-        DESTS.TRANS_EVENT | DESTS.ERROR_EVENT,
-        'request.uri',
-        tx.url
-      )
-      segment.addSpanAttribute('request.uri', tx.url)
-      if (request.method != null) {
-        segment.addSpanAttribute('request.method', request.method)
-      }
       addAttributes({ transaction: tx, functionContext: context })
 
-      const queueTimeStamp = headerProcessing.getQueueTime(_logger, request.headers)
-      if (queueTimeStamp) {
-        tx.queueTime = Date.now() - queueTimeStamp
-      }
-
-      synthetics.assignHeadersToTransaction(_agent.config, tx, request.headers)
-      if (_agent.config.distributed_tracing.enabled === true) {
-        tx.acceptDistributedTraceHeaders(transport, request.headers)
-      }
-
       const newContext = ctx.enterSegment({ segment })
       const boundHandler = tracer.bindFunction(handler, newContext)
       const result = await boundHandler(...args)
 
-      // Responses should have a shape as described at:
-      // https://learn.microsoft.com/en-us/azure/azure-functions/functions-reference-node?tabs=javascript%2Cwindows%2Cazure-cli&pivots=nodejs-model-v4#http-response
-      if (result?.status) {
-        tx.trace.attributes.addAttribute(
-          DESTS.TRANS_COMMON,
-          'http.statusCode',
-          result.status
-        )
-      }
       if (coldStart === true) {
         tx.trace.attributes.addAttribute(DESTS.TRANS_COMMON, 'faas.coldStart', true)
         coldStart = false
       }
+      // Responses should have a shape as described at:
+      // https://learn.microsoft.com/en-us/azure/azure-functions/functions-reference-node?tabs=javascript%2Cwindows%2Cazure-cli&pivots=nodejs-model-v4#http-response
+      tx.finalizeWeb({ statusCode: result?.status, headers: result?.headers, end: false })
       if (result?.body instanceof Transform) {
         result.body.on('close', () => {
           tx.end()

package/lib/instrumentation/core/http-outbound.js

@@ -10,7 +10,6 @@ const cat = require('../../util/cat')
 const urltils = require('../../util/urltils')
 const logger = require('../../logger').child({ component: 'outbound' })
 const shimmer = require('../../shimmer')
-const url = require('url')
 const symbols = require('../../symbols')
 const synthetics = require('../../synthetics')
 const { URL } = require('node:url')
@@ -245,16 +244,33 @@ function applySegment({ opts, makeRequest, host, port, hostname, segment, config
   segment.start()
   const request = makeRequest(opts)
 
-  // Attempt to parse into new URL.
-  // If no href, revert to url.parse.
-  // Rarely, the href doesn't contain the
-  // path, so we have to use url.parse to get the path.
-  const urlObject = (opts?.href?.includes(request.path)) ? new URL(opts.href) : url.parse(request.path, true)
-  const parsed = urltils.scrubAndParseParameters(urlObject)
-  const obfuscatedPath = urltils.obfuscatePath(config, parsed.path)
+  // Parse the appropriate URL from the request options
+  // 1. If the path is a proxy url use the entire path
+  // 2. construct url from path, protocol and host if href does not already include path
+  // 3. use href to construct url
+  let absoluteUrl = null
+  if (request?.path?.startsWith('http://') || request?.path?.startsWith('https://')) {
+    absoluteUrl = request.path
+  } else if (!opts?.href?.includes(request.path)) {
+    const protocol = opts.protocol || 'http:'
+    absoluteUrl = `${protocol}//${host}${request.path}`
+  } else {
+    absoluteUrl = opts.href
+  }
+
+  let obfuscatedPath, parsed
+  try {
+    const urlObject = new URL(absoluteUrl)
+    parsed = urltils.scrubAndParseParameters(urlObject)
+    obfuscatedPath = urltils.obfuscatePath(config, parsed.path)
+    segment.name += obfuscatedPath
+  } catch (err) {
+    logger.debug('Could not parse URL from request options: %s', err.message)
+    obfuscatedPath = request.path
+  }
 
   const proto = parsed.protocol || opts.protocol || 'http:'
-  segment.name += obfuscatedPath
+
   segment.captureExternalAttributes({
     protocol: proto,
     hostname,
@@ -262,7 +278,7 @@ function applySegment({ opts, makeRequest, host, port, hostname, segment, config
     method: opts.method,
     port,
     path: obfuscatedPath,
-    queryParams: parsed.parameters
+    queryParams: parsed?.parameters
   })
   request[symbols.segment] = segment
   return request

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