newrelic 13.3.3 → 13.4.0

package/lib/instrumentation/amqplib/channel-model.js

@@ -1,124 +0,0 @@
-/*
- * Copyright 2024 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-'use strict'
-const { MessageSpec, MessageSubscribeSpec, RecorderSpec } = require('../../shim/specs')
-const { amqpConnection } = require('../../symbols')
-const CHANNEL_METHODS = [
-  'close',
-  'open',
-  'assertQueue',
-  'checkQueue',
-  'deleteQueue',
-  'bindQueue',
-  'unbindQueue',
-  'assertExchange',
-  'checkExchange',
-  'deleteExchange',
-  'bindExchange',
-  'unbindExchange',
-  'cancel',
-  'prefetch',
-  'recover'
-]
-const { describeMessage, setCallback, getParametersFromMessage, TEMP_RE } = require('./utils')
-
-/**
- *
- * Instruments the relevant channel callback_model or channel_model.
- *
- * @param {Shim} shim instance of shim
- * @param {object} Model either channel or callback model
- * @param {boolean} promiseMode is this promise based?
- */
-module.exports = function wrapModel(shim, Model, promiseMode) {
-  if (!Model.Channel?.prototype) {
-    shim.logger.debug(
-      `Could not get ${promiseMode ? 'promise' : 'callback'} model Channel to instrument.`
-    )
-    return
-  }
-
-  const proto = Model.Channel.prototype
-  if (shim.isWrapped(proto.consume)) {
-    shim.logger.trace(`${promiseMode ? 'promise' : 'callback'} model already instrumented.`)
-    return
-  }
-
-  recordChannelMethods({ shim, proto, promiseMode })
-  recordPurge({ shim, proto, promiseMode })
-  recordGet({ shim, proto, promiseMode })
-  recordConsume({ shim, proto, promiseMode })
-}
-
-/**
- * Record spans for common methods on channel
- *
- * @param {Channel} proto prototype of Model.Channel
- */
-function recordChannelMethods({ shim, proto, promiseMode }) {
-  shim.record(proto, CHANNEL_METHODS, function recordChannelMethod(shim, fn, name) {
-    return new RecorderSpec({
-      name: 'Channel#' + name,
-      callback: setCallback(shim, promiseMode),
-      promise: promiseMode
-    })
-  })
-}
-
-function recordPurge({ shim, proto, promiseMode }) {
-  shim.recordPurgeQueue(proto, 'purgeQueue', function purge(shim, fn, name, args) {
-    let queue = args[0]
-    if (TEMP_RE.test(queue)) {
-      queue = null
-    }
-    return new MessageSpec({
-      queue,
-      promise: promiseMode,
-      callback: setCallback(shim, promiseMode)
-    })
-  })
-}
-
-function recordGet({ shim, proto, promiseMode }) {
-  shim.recordConsume(proto, 'get', function wrapGet() {
-    const { host, port } = this?.connection?.[amqpConnection] || {}
-    return new MessageSpec({
-      destinationName: shim.FIRST,
-      callback: setCallback(shim, promiseMode),
-      promise: promiseMode,
-      after: function handleConsumedMessage({ shim, result, args, segment }) {
-        if (!shim.agent.config.message_tracer.segment_parameters.enabled) {
-          shim.logger.trace('Not capturing segment parameters')
-          return
-        }
-
-        // the message is the param when using the promised based model
-        const message = promiseMode ? result : args?.[1]
-        if (!message) {
-          shim.logger.trace('No results from consume.')
-          return null
-        }
-        const parameters = getParametersFromMessage({ message, host, port })
-        shim.copySegmentParameters(segment, parameters)
-      }
-    })
-  })
-}
-
-function recordConsume({ shim, proto, promiseMode }) {
-  shim.recordSubscribedConsume(proto, 'consume', function consume() {
-    const { host, port } = this?.connection?.[amqpConnection] || {}
-    return new MessageSubscribeSpec({
-      name: 'amqplib.Channel#consume',
-      queue: shim.FIRST,
-      consumer: shim.SECOND,
-      promise: promiseMode,
-      parameters: { host, port },
-      callback: promiseMode ? null : shim.FOURTH,
-      messageHandler: describeMessage({ host, port })
-    })
-  })
-}

package/lib/instrumentation/amqplib/channel.js

@@ -1,72 +0,0 @@
-/*
- * Copyright 2024 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-'use strict'
-const { MessageSpec } = require('../../shim/specs')
-const { amqpConnection } = require('../../symbols')
-const { getParameters, TEMP_RE } = require('./utils')
-
-/**
- *
- * Instruments the sendOrEnqueue and sendMessage methods of the ampqlib channel.
- *
- * @param {Shim} shim instance of shim
- */
-module.exports = function wrapChannel(shim) {
-  const libChannel = shim.require('./lib/channel')
-  if (!libChannel?.Channel?.prototype) {
-    shim.logger.debug('Could not get Channel class to instrument.')
-    return
-  }
-
-  const proto = libChannel.Channel.prototype
-  if (shim.isWrapped(proto.sendMessage)) {
-    shim.logger.trace('Channel already instrumented.')
-    return
-  }
-  shim.logger.trace('Instrumenting basic Channel class.')
-
-  shim.wrap(proto, 'sendOrEnqueue', function wrapSendOrEnqueue(shim, fn) {
-    if (!shim.isFunction(fn)) {
-      return fn
-    }
-
-    return function wrappedSendOrEnqueue(...args) {
-      const segment = shim.getSegment()
-      const cb = args[args.length - 1]
-      if (!shim.isFunction(cb) || !segment) {
-        shim.logger.debug({ cb: !!cb, segment: !!segment }, 'Not binding sendOrEnqueue callback')
-        return fn.apply(this, args)
-      }
-
-      shim.logger.trace('Binding sendOrEnqueue callback to %s', segment.name)
-      args[args.length - 1] = shim.bindSegment(cb, segment)
-      return fn.apply(this, args)
-    }
-  })
-
-  shim.recordProduce(proto, 'sendMessage', recordSendMessage)
-}
-
-function recordSendMessage(shim, fn, n, args) {
-  const fields = args[0]
-  if (!fields) {
-    return null
-  }
-  const isDefault = fields.exchange === ''
-  let exchange = 'Default'
-  if (!isDefault) {
-    exchange = TEMP_RE.test(fields.exchange) ? null : fields.exchange
-  }
-  const { host, port } = this?.connection?.[amqpConnection] || {}
-
-  return new MessageSpec({
-    destinationName: exchange,
-    destinationType: shim.EXCHANGE,
-    routingKey: fields.routingKey,
-    headers: fields.headers,
-    parameters: getParameters({ parameters: Object.create(null), fields, host, port })
-  })
-}

package/lib/instrumentation/amqplib/nr-hooks.js

@@ -1,21 +0,0 @@
-/*
- * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-'use strict'
-const amqplib = require('./amqplib')
-const InstrumentationDescriptor = require('../../instrumentation-descriptor')
-
-module.exports = [
-  {
-    moduleName: 'amqplib/callback_api',
-    type: InstrumentationDescriptor.TYPE_MESSAGE,
-    onRequire: amqplib.instrumentCallbackAPI
-  },
-  {
-    moduleName: 'amqplib',
-    type: InstrumentationDescriptor.TYPE_MESSAGE,
-    onRequire: amqplib.instrumentPromiseAPI
-  }
-]

package/lib/instrumentation/amqplib/utils.js

@@ -1,143 +0,0 @@
-/*
- * Copyright 2024 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-'use strict'
-const {
-  MessageSpec,
-  params: { QueueMessageParameters }
-} = require('../../shim/specs')
-const TEMP_RE = /^amq\./
-
-/**
- * Wrapper around message handler to pass host/port
- *
- * @param {object} params to function
- * @param {string} params.host hostname
- * @param {number} params.port port
- * @returns {function} message handler
- */
-function describeMessage({ host, port }) {
-  /**
-   *  Extracts the appropriate messageHandler parameters for the consume method.
-   *
-   *  @param {Shim} shim instance of shim
-   *  @param {Array} args arguments passed to the consume method
-   *  @returns {object} message params
-   */
-  return function messageHandler(shim, args) {
-    const [message] = args
-
-    if (!message?.properties) {
-      shim.logger.debug({ message }, 'Failed to find message in consume arguments.')
-      return null
-    }
-
-    const parameters = getParametersFromMessage({ message, host, port })
-    let exchangeName = message?.fields?.exchange || 'Default'
-
-    if (TEMP_RE.test(exchangeName)) {
-      exchangeName = null
-    }
-
-    return new MessageSpec({
-      destinationName: exchangeName,
-      destinationType: shim.EXCHANGE,
-      routingKey: message?.fields?.routingKey,
-      headers: message.properties.headers,
-      parameters
-    })
-  }
-}
-
-/**
- * Sets the relevant message parameters
- *
- * @param {object} params to function
- * @param {object} params.parameters object used to store the message parameters
- * @param {object} params.fields fields from the sendMessage method
- * @param {string} params.host hostname
- * @param {number} params.port port
- * @returns {QueueMessageParameters} parameters updated parameters
- */
-function getParameters({ parameters, fields, host, port }) {
-  if (fields.routingKey) {
-    parameters.routing_key = fields.routingKey
-  }
-  if (fields.correlationId) {
-    parameters.correlation_id = fields.correlationId
-  }
-  if (fields.replyTo) {
-    parameters.reply_to = fields.replyTo
-  }
-
-  if (host) {
-    parameters.host = host
-  }
-
-  if (port) {
-    parameters.port = port
-  }
-
-  return new QueueMessageParameters(parameters)
-}
-
-/**
- * Sets the QueueMessageParameters from the amqp message
- *
- * @param {object} params to function
- * @param {object} params.message queue message
- * @param {string} params.host host
- * @param {number} params.port port
- * @returns {QueueMessageParameters} parameters from message
- */
-function getParametersFromMessage({ message, host, port }) {
-  const parameters = Object.create(null)
-  getParameters({ parameters, fields: message.fields, host, port })
-  getParameters({ parameters, fields: message.properties })
-  return parameters
-}
-
-/**
- * Helper to set the appropriate value of the callback property
- * in the spec. If it's a promise set to null otherwise set it to `shim.LAST`
- *
- * @param {Shim} shim instance of shim
- * @param {boolean} promiseMode is this promise based?
- * @returns {string|null} appropriate value
- */
-function setCallback(shim, promiseMode) {
-  return promiseMode ? null : shim.LAST
-}
-
-/**
- * Parses the connection args to return host/port
- *
- * @param {string|object} connArgs connection arguments
- * @returns {object} {host, port }
- */
-function parseConnectionArgs({ shim, connArgs }) {
-  const params = {}
-  if (shim.isString(connArgs)) {
-    connArgs = new URL(connArgs)
-    params.host = connArgs.hostname
-    if (connArgs.port) {
-      params.port = parseInt(connArgs.port, 10)
-    }
-  } else {
-    params.port = connArgs.port || (connArgs.protocol === 'amqp' ? 5672 : 5671)
-    params.host = connArgs.hostname
-  }
-
-  return params
-}
-
-module.exports = {
-  describeMessage,
-  getParameters,
-  getParametersFromMessage,
-  parseConnectionArgs,
-  setCallback,
-  TEMP_RE
-}

package/lib/instrumentation/cassandra-driver.js

@@ -1,131 +0,0 @@
-/*
- * Copyright 2020 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-'use strict'
-
-const semver = require('semver')
-const { OperationSpec, QuerySpec } = require('../shim/specs')
-
-/**
- * Instruments the `cassandra-driver` module, function that is
- * passed to `onRequire` when instantiating instrumentation.
- *
- * @param {object} _agent - NewRelic agent
- * @param {object} cassandra - The cassandra-driver library definition
- * @param {string} _moduleName - String representation of require/import path
- * @param {object} shim - shim for instrumentation
- */
-module.exports = function initialize(_agent, cassandra, _moduleName, shim) {
-  const cassandraVersion = shim.pkgVersion
-
-  shim.setDatastore(shim.CASSANDRA)
-
-  const ClientProto = cassandra.Client.prototype
-  const RequestExecutionProto = shim.require('./lib/request-execution.js').prototype
-
-  shim.recordOperation(
-    ClientProto,
-    ['connect', 'shutdown'],
-    function operationSpec(shim, _fn, name) {
-      return new OperationSpec({ callback: shim.LAST, name, promise: true })
-    }
-  )
-
-  if (semver.satisfies(cassandraVersion, '>=4.4.0')) {
-    shim.recordQuery(
-      ClientProto,
-      '_execute',
-      new QuerySpec({
-        query: shim.FIRST,
-        callback: shim.LAST,
-        promise: true
-      })
-    )
-
-    shim.wrap(
-      RequestExecutionProto,
-      '_sendOnConnection',
-      function wrapSendOnConnection(shim, _sendOnConnection) {
-        return function wrappedSendOnConnection() {
-          shim.captureInstanceAttributes(
-            this._connection.address,
-            this._connection.port,
-            this._connection.keyspace
-          )
-
-          return _sendOnConnection.apply(this, arguments)
-        }
-      }
-    )
-  } else {
-    shim.recordQuery(
-      ClientProto,
-      '_innerExecute',
-      new QuerySpec({
-        query: shim.FIRST,
-        callback: shim.LAST,
-        promise: true
-      })
-    )
-
-    shim.wrap(RequestExecutionProto, 'start', function wrapStart(shim, start) {
-      return function wrappedStart(...args) {
-        const parent = shim.getSegment()
-        const self = this
-
-        /**
-         * In older versions of cassandra-driver, we can't rely on RequestExecution._sendOnConnection,
-         * so instead we use the callback passed to RequestExecution.start as a sort of hook point,
-         * because we know for sure that the connection was set and in scope right before the callback
-         * is executed.
-         *
-         * We also have to set the active segment to the RequestExecution.start's segment to ensure that
-         * we're adding the connection attributes to the correct segment.
-         *
-         * See: https://github.com/datastax/nodejs-driver/blob/v3.4.0/lib/request-execution.js#L51
-         */
-        args[0] = shim.wrap(args[0], function wrapGetHostCallback(shim, getHostCallback) {
-          return function wrappedGetHostCallback() {
-            shim.setActiveSegment(parent)
-
-            shim.captureInstanceAttributes(
-              self._connection.address,
-              self._connection.port,
-              self._connection.keyspace
-            )
-            return getHostCallback.apply(this, arguments)
-          }
-        })
-
-        return start.apply(this, args)
-      }
-    })
-  }
-
-  shim.recordBatchQuery(
-    ClientProto,
-    'batch',
-    new QuerySpec({
-      query: findBatchQueryArg,
-      callback: shim.LAST,
-      promise: true
-    })
-  )
-}
-
-/**
- * Given the arguments for Cassandra's `batch` method, this finds the first
- * query in the batch.
- *
- * @param {object} _shim - shim for instrumentation
- * @param {Function} _batch - original batch function
- * @param {string} _fnName - the function name (batch)
- * @param {Array} args - original arguments passed to the batch function
- * @returns {string} The query for this batch request.
- */
-function findBatchQueryArg(_shim, _batch, _fnName, args) {
-  const sql = (args[0] && args[0][0]) || ''
-  return sql.query || sql
-}