dd-trace 2.28.0 → 2.30.0

package/packages/datadog-instrumentations/src/helpers/hook.js

@@ -3,13 +3,21 @@
 const path = require('path')
 const iitm = require('../../../dd-trace/src/iitm')
 const ritm = require('../../../dd-trace/src/ritm')
-
+const dcitm = require('../../../dd-trace/src/dcitm')
+
+/**
+ * This is called for every module that dd-trace supports instrumentation for.
+ * In practice, `modules` is always an array with a single entry.
+ *
+ * @param {string[]} modules list of modules to hook into
+ * @param {Function} onrequire callback to be executed upon encountering module
+ */
 function Hook (modules, onrequire) {
   if (!(this instanceof Hook)) return new Hook(modules, onrequire)
 
   this._patched = Object.create(null)
 
-  const safeHook = (moduleExports, moduleName, moduleBaseDir) => {
+  const safeHook = (moduleExports, moduleName, moduleBaseDir, moduleVersion) => {
     const parts = [moduleBaseDir, moduleName].filter(v => v)
     const filename = path.join(...parts)
 
@@ -17,7 +25,7 @@ function Hook (modules, onrequire) {
 
     this._patched[filename] = true
 
-    return onrequire(moduleExports, moduleName, moduleBaseDir)
+    return onrequire(moduleExports, moduleName, moduleBaseDir, moduleVersion)
   }
 
   this._ritmHook = ritm(modules, {}, safeHook)
@@ -33,11 +41,13 @@ function Hook (modules, onrequire) {
       return safeHook(moduleExports, moduleName, moduleBaseDir)
     }
   })
+  this._dcitmHook = dcitm(modules, {}, safeHook)
 }
 
 Hook.prototype.unhook = function () {
   this._ritmHook.unhook()
   this._iitmHook.unhook()
+  this._dcitmHook.unhook()
   this._patched = Object.create(null)
 }
 

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -47,6 +47,7 @@ module.exports = {
   'jest-environment-node': () => require('../jest'),
   'jest-environment-jsdom': () => require('../jest'),
   'jest-jasmine2': () => require('../jest'),
+  'jest-worker': () => require('../jest'),
   'koa': () => require('../koa'),
   'koa-router': () => require('../koa'),
   'kafkajs': () => require('../kafkajs'),

package/packages/datadog-instrumentations/src/helpers/instrument.js

@@ -14,6 +14,12 @@ exports.channel = function (name) {
   return ch
 }
 
+/**
+ * @param {string} args.name module name
+ * @param {string[]} args.versions array of semver range strings
+ * @param {string} args.file path to file within package to instrument?
+ * @param Function hook
+ */
 exports.addHook = function addHook ({ name, versions, file }, hook) {
   if (!instrumentations[name]) {
     instrumentations[name] = []

package/packages/datadog-instrumentations/src/helpers/register.js

@@ -17,7 +17,7 @@ const loadChannel = channel('dd-trace:instrumentation:load')
 // TODO: make this more efficient
 
 for (const packageName of names) {
-  Hook([packageName], (moduleExports, moduleName, moduleBaseDir) => {
+  Hook([packageName], (moduleExports, moduleName, moduleBaseDir, moduleVersion) => {
     moduleName = moduleName.replace(pathSepExpr, '/')
 
     hooks[packageName]()
@@ -26,7 +26,7 @@ for (const packageName of names) {
       const fullFilename = filename(name, file)
 
       if (moduleName === fullFilename) {
-        const version = getVersion(moduleBaseDir)
+        const version = moduleVersion || getVersion(moduleBaseDir)
 
         if (matchVersion(version, versions)) {
           try {

package/packages/datadog-instrumentations/src/jest.js

@@ -2,7 +2,11 @@
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 const log = require('../../dd-trace/src/log')
-const { getCoveredFilenamesFromCoverage } = require('../../dd-trace/src/plugins/util/test')
+const {
+  getCoveredFilenamesFromCoverage,
+  JEST_WORKER_TRACE_PAYLOAD_CODE,
+  JEST_WORKER_COVERAGE_PAYLOAD_CODE
+} = require('../../dd-trace/src/plugins/util/test')
 
 const testSessionStartCh = channel('ci:jest:session:start')
 const testSessionFinishCh = channel('ci:jest:session:finish')
@@ -11,6 +15,10 @@ const testSessionConfigurationCh = channel('ci:jest:session:configuration')
 
 const testSuiteStartCh = channel('ci:jest:test-suite:start')
 const testSuiteFinishCh = channel('ci:jest:test-suite:finish')
+
+const workerReportTraceCh = channel('ci:jest:worker-report:trace')
+const workerReportCoverageCh = channel('ci:jest:worker-report:coverage')
+
 const testSuiteCodeCoverageCh = channel('ci:jest:test-suite:code-coverage')
 
 const testStartCh = channel('ci:jest:test:start')
@@ -214,7 +222,6 @@ function cliWrapper (cli, jestVersion) {
         log.error(err)
       }
     }
-
     const isSuitesSkipped = !!skippableSuites.length
 
     const processArgv = process.argv.slice(2).join(' ')
@@ -309,7 +316,6 @@ function jestAdapterWrapper (jestAdapter, jestVersion) {
         } else if (numFailingTests !== 0) {
           status = 'fail'
         }
-        testSuiteFinishCh.publish({ status, errorMessage })
 
         const coverageFiles = getCoveredFilenamesFromCoverage(environment.global.__coverage__)
           .map(filename => getTestSuitePath(filename, environment.rootDir))
@@ -326,6 +332,7 @@ function jestAdapterWrapper (jestAdapter, jestVersion) {
             testSuiteCodeCoverageCh.publish([...coverageFiles, environment.testSuite])
           })
         }
+        testSuiteFinishCh.publish({ status, errorMessage })
         return suiteResults
       })
     })
@@ -475,3 +482,28 @@ addHook({
   versions: ['>=24.8.0'],
   file: 'build/jasmineAsyncInstall.js'
 }, jasmineAsyncInstallWraper)
+
+addHook({
+  name: 'jest-worker',
+  versions: ['>=24.9.0'],
+  file: 'build/workers/ChildProcessWorker.js'
+}, (childProcessWorker) => {
+  const ChildProcessWorker = childProcessWorker.default
+  shimmer.wrap(ChildProcessWorker.prototype, '_onMessage', _onMessage => function () {
+    const [code, data] = arguments[0]
+    if (code === JEST_WORKER_TRACE_PAYLOAD_CODE) { // datadog trace payload
+      sessionAsyncResource.runInAsyncScope(() => {
+        workerReportTraceCh.publish(data)
+      })
+      return
+    }
+    if (code === JEST_WORKER_COVERAGE_PAYLOAD_CODE) { // datadog coverage payload
+      sessionAsyncResource.runInAsyncScope(() => {
+        workerReportCoverageCh.publish(data)
+      })
+      return
+    }
+    return _onMessage.apply(this, arguments)
+  })
+  return childProcessWorker
+})

package/packages/datadog-instrumentations/src/mariadb.js

@@ -7,17 +7,17 @@ const shimmer = require('../../datadog-shimmer')
 const startCh = channel('apm:mariadb:query:start')
 const finishCh = channel('apm:mariadb:query:finish')
 const errorCh = channel('apm:mariadb:query:error')
+const skipCh = channel('apm:mariadb:pool:skip')
+const unskipCh = channel('apm:mariadb:pool:unskip')
 
-function wrapCommandStart (start) {
+function wrapCommandStart (start, callbackResource) {
   return function () {
     if (!startCh.hasSubscribers) return start.apply(this, arguments)
 
-    const callbackResource = new AsyncResource('bound-anonymous-fn')
-
     const resolve = callbackResource.bind(this.resolve)
     const reject = callbackResource.bind(this.reject)
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    const asyncResource = callbackResource.runInAsyncScope(() => new AsyncResource('bound-anonymous-fn'))
 
     shimmer.wrap(this, 'resolve', function wrapResolve () {
       return function () {
@@ -47,17 +47,136 @@ function wrapCommandStart (start) {
   }
 }
 
+function wrapCommand (Command) {
+  return class extends Command {
+    constructor (...args) {
+      super(...args)
+
+      const callbackResource = new AsyncResource('bound-anonymous-fn')
+
+      if (this.start) {
+        this.start = wrapCommandStart(this.start, callbackResource)
+      }
+    }
+  }
+}
+
+function createWrapQuery (options) {
+  return function wrapQuery (query) {
+    return function (sql) {
+      if (!startCh.hasSubscribers) return query.apply(this, arguments)
+
+      const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+      return asyncResource.runInAsyncScope(() => {
+        startCh.publish({ sql, conf: options })
+
+        return query.apply(this, arguments)
+          .then(result => {
+            finishCh.publish()
+            return result
+          }, error => {
+            errorCh.publish(error)
+            finishCh.publish()
+            throw error
+          })
+      }, 'bound-anonymous-fn')
+    }
+  }
+}
+
+function createWrapQueryCallback (options) {
+  return function wrapQuery (query) {
+    return function (sql) {
+      if (!startCh.hasSubscribers) return query.apply(this, arguments)
+
+      const cb = arguments[arguments.length - 1]
+      const asyncResource = new AsyncResource('bound-anonymous-fn')
+      const callbackResource = new AsyncResource('bound-anonymous-fn')
+
+      if (typeof cb !== 'function') {
+        arguments.length = arguments.length + 1
+      }
+
+      arguments[arguments.length - 1] = asyncResource.bind(function (err) {
+        if (err) {
+          errorCh.publish(err)
+        }
+
+        finishCh.publish()
+
+        if (typeof cb === 'function') {
+          return callbackResource.runInAsyncScope(() => cb.apply(this, arguments))
+        }
+      })
+
+      return asyncResource.runInAsyncScope(() => {
+        startCh.publish({ sql, conf: options })
+
+        return query.apply(this, arguments)
+      }, 'bound-anonymous-fn')
+    }
+  }
+}
+
+function wrapConnection (Connection, promiseMethod) {
+  return function (options) {
+    Connection.apply(this, arguments)
+
+    shimmer.wrap(this, promiseMethod, createWrapQuery(options))
+    shimmer.wrap(this, '_queryCallback', createWrapQueryCallback(options))
+  }
+}
+
+function wrapPoolBase (PoolBase) {
+  return function (options, processTask, createConnectionPool, pingPromise) {
+    arguments[1] = wrapPoolMethod(processTask)
+    arguments[2] = wrapPoolMethod(createConnectionPool)
+
+    PoolBase.apply(this, arguments)
+
+    shimmer.wrap(this, 'query', createWrapQuery(options.connOptions))
+  }
+}
+
+// It's not possible to prevent connection pools from leaking across queries,
+// so instead we just skip instrumentation completely to avoid memory leaks
+// and/or orphan spans.
+function wrapPoolMethod (createConnection) {
+  return function () {
+    skipCh.publish()
+    try {
+      return createConnection.apply(this, arguments)
+    } finally {
+      unskipCh.publish()
+    }
+  }
+}
+
 const name = 'mariadb'
-const versions = ['>=2.0.3']
 
-addHook({ name, file: 'lib/cmd/query.js', versions }, (Query) => {
-  shimmer.wrap(Query.prototype, 'start', wrapCommandStart)
+addHook({ name, file: 'lib/cmd/query.js', versions: ['>=3'] }, (Query) => {
+  return wrapCommand(Query)
+})
+
+addHook({ name, file: 'lib/cmd/execute.js', versions: ['>=3'] }, (Execute) => {
+  return wrapCommand(Execute)
+})
+
+addHook({ name, file: 'lib/pool.js', versions: ['>=3'] }, (Pool) => {
+  shimmer.wrap(Pool.prototype, '_createConnection', wrapPoolMethod)
 
-  return Query
+  return Pool
 })
 
-addHook({ name, file: 'lib/cmd/execute.js', versions }, (Query) => {
-  shimmer.wrap(Query.prototype, 'start', wrapCommandStart)
+addHook({ name, file: 'lib/connection.js', versions: ['>=2.5.2 <3'] }, (Connection) => {
+  return shimmer.wrap(Connection, wrapConnection(Connection, '_queryPromise'))
+})
+
+addHook({ name, file: 'lib/connection.js', versions: ['>=2.0.4 <=2.5.1'] }, (Connection) => {
+  return shimmer.wrap(Connection, wrapConnection(Connection, 'query'))
+})
 
-  return Query
+addHook({ name, file: 'lib/pool-base.js', versions: ['>=2.0.4 <3'] }, (PoolBase) => {
+  return shimmer.wrap(PoolBase, wrapPoolBase(PoolBase))
 })

package/packages/datadog-instrumentations/src/mocha.js

@@ -2,6 +2,8 @@ const { createCoverageMap } = require('istanbul-lib-coverage')
 
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
+const log = require('../../dd-trace/src/log')
+
 const {
   getCoveredFilenamesFromCoverage,
   resetCoverage,
@@ -34,6 +36,9 @@ const testToAr = new WeakMap()
 const originalFns = new WeakMap()
 const testFileToSuiteAr = new Map()
 
+// `isWorker` is true if it's a Mocha worker
+let isWorker = false
+
 // We'll preserve the original coverage here
 const originalCoverageMap = createCoverageMap()
 
@@ -101,7 +106,7 @@ function mochaHook (Runner) {
   patched.add(Runner)
 
   shimmer.wrap(Runner.prototype, 'run', run => function () {
-    if (!testStartCh.hasSubscribers) {
+    if (!testStartCh.hasSubscribers || isWorker) {
       return run.apply(this, arguments)
     }
 
@@ -120,9 +125,18 @@ function mochaHook (Runner) {
 
       const isSuitesSkipped = !!suitesToSkip.length
 
-      testSessionFinishCh.publish({ status, isSuitesSkipped })
-      // restore the original coverage
-      global.__coverage__ = fromCoverageMapToCoverage(originalCoverageMap)
+      let testCodeCoverageLinesTotal
+      if (global.__coverage__) {
+        try {
+          testCodeCoverageLinesTotal = originalCoverageMap.getCoverageSummary().lines.pct
+        } catch (e) {
+          // ignore errors
+        }
+        // restore the original coverage
+        global.__coverage__ = fromCoverageMapToCoverage(originalCoverageMap)
+      }
+
+      testSessionFinishCh.publish({ status, isSuitesSkipped, testCodeCoverageLinesTotal })
     }))
 
     this.once('start', testRunAsyncResource.bind(function () {
@@ -321,7 +335,15 @@ addHook({
    * If ITR is disabled, `onDone` is called immediately on the subscriber
    */
   shimmer.wrap(Mocha.prototype, 'run', run => function () {
-    if (!itrConfigurationCh.hasSubscribers) {
+    if (this.options.parallel) {
+      log.warn(`Unable to initialize CI Visibility because Mocha is running in parallel mode.`)
+      return run.apply(this, arguments)
+    }
+
+    if (!itrConfigurationCh.hasSubscribers || this.isWorker) {
+      if (this.isWorker) {
+        isWorker = true
+      }
       return run.apply(this, arguments)
     }
     this.options.delay = true
@@ -379,7 +401,9 @@ addHook({
      * This attaches `run` to the global context, which we'll call after
      * our configuration and skippable suites requests
      */
-    mocha.options.delay = true
+    if (!mocha.options.parallel) {
+      mocha.options.delay = true
+    }
     return runMocha.apply(this, arguments)
   })
   return run

package/packages/datadog-instrumentations/src/mongodb-core.js

@@ -25,13 +25,19 @@ addHook({ name: 'mongodb-core', versions: ['2 - 3.1.9'] }, Server => {
   return Server
 })
 
-addHook({ name: 'mongodb', versions: ['>=4'], file: 'lib/cmap/connection.js' }, Connection => {
+addHook({ name: 'mongodb', versions: ['>=4 <4.6.0'], file: 'lib/cmap/connection.js' }, Connection => {
   const proto = Connection.Connection.prototype
   shimmer.wrap(proto, 'command', command => wrapConnectionCommand(command, 'command'))
   shimmer.wrap(proto, 'query', query => wrapConnectionCommand(query, 'query'))
   return Connection
 })
 
+addHook({ name: 'mongodb', versions: ['>=4.6.0'], file: 'lib/cmap/connection.js' }, Connection => {
+  const proto = Connection.Connection.prototype
+  shimmer.wrap(proto, 'command', command => wrapConnectionCommand(command, 'command'))
+  return Connection
+})
+
 addHook({ name: 'mongodb', versions: ['>=3.3 <4'], file: 'lib/core/wireprotocol/index.js' }, wp => wrapWp(wp))
 
 addHook({ name: 'mongodb-core', versions: ['>=3.2'], file: 'lib/wireprotocol/index.js' }, wp => wrapWp(wp))
@@ -46,7 +52,7 @@ addHook({ name: 'mongodb-core', versions: ['~3.1.10'], file: 'lib/wireprotocol/2
   return WireProtocol
 })
 
-addHook({ name: 'mongodb', versions: ['>=3.5.4'], file: 'lib/utils.js' }, util => {
+addHook({ name: 'mongodb', versions: ['>=3.5.4 <4.11.0'], file: 'lib/utils.js' }, util => {
   shimmer.wrap(util, 'maybePromise', maybePromise => function (parent, callback, fn) {
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     const callbackIndex = arguments.length - 2

package/packages/datadog-instrumentations/src/mongoose.js

@@ -19,7 +19,7 @@ function wrapAddQueue (addQueue) {
 
 addHook({
   name: 'mongoose',
-  versions: ['>=4.6.4 <7'] // TODO: Mongoose v7 compat
+  versions: ['>=4.6.4 <5', '5', '6', '>=7']
 }, mongoose => {
   if (mongoose.Promise !== global.Promise) {
     shimmer.wrap(mongoose.Promise.prototype, 'then', wrapThen)

package/packages/datadog-instrumentations/src/next.js

@@ -26,16 +26,33 @@ function wrapHandleApiRequest (handleApiRequest) {
       return promise.then(handled => {
         if (!handled) return handled
 
-        const page = getPageFromPath(pathname, this.dynamicRoutes)
+        return this.hasPage(pathname).then(pageFound => {
+          const page = pageFound ? pathname : getPageFromPath(pathname, this.dynamicRoutes)
 
-        pageLoadChannel.publish({ page })
+          pageLoadChannel.publish({ page })
 
-        return handled
+          return handled
+        })
       })
     })
   }
 }
 
+// next 13.2 handleApiRequest uses a different set of parameters
+function wrapHandleApiRequestWithMatch (handleApiRequest) {
+  return function (req, res, query, match) {
+    return instrument(req, res, () => {
+      const page = (typeof match === 'object' && typeof match.definition === 'object')
+        ? match.definition.pathname
+        : undefined
+
+      pageLoadChannel.publish({ page })
+
+      return handleApiRequest.apply(this, arguments)
+    })
+  }
+}
+
 function wrapRenderToResponse (renderToResponse) {
   return function (ctx) {
     return instrument(ctx.req, ctx.res, () => renderToResponse.apply(this, arguments))
@@ -127,7 +144,18 @@ function finish (req, res, result, err) {
   return result
 }
 
-// TODO: 13.2 support
+addHook({ name: 'next', versions: ['>=13.2'], file: 'dist/server/next-server.js' }, nextServer => {
+  const Server = nextServer.default
+
+  shimmer.wrap(Server.prototype, 'handleRequest', wrapHandleRequest)
+  shimmer.wrap(Server.prototype, 'handleApiRequest', wrapHandleApiRequestWithMatch)
+  shimmer.wrap(Server.prototype, 'renderToResponse', wrapRenderToResponse)
+  shimmer.wrap(Server.prototype, 'renderErrorToResponse', wrapRenderErrorToResponse)
+  shimmer.wrap(Server.prototype, 'findPageComponents', wrapFindPageComponents)
+
+  return nextServer
+})
+
 addHook({ name: 'next', versions: ['>=11.1 <13.2'], file: 'dist/server/next-server.js' }, nextServer => {
   const Server = nextServer.default
 

package/packages/datadog-instrumentations/src/pg.js

@@ -27,27 +27,22 @@ function wrapQuery (query) {
       return query.apply(this, arguments)
     }
 
-    const retval = query.apply(this, arguments)
-
-    const queryQueue = this.queryQueue || this._queryQueue
-    const activeQuery = this.activeQuery || this._activeQuery
-    const pgQuery = queryQueue[queryQueue.length - 1] || activeQuery
-
-    if (!pgQuery) {
-      return retval
-    }
-
     const callbackResource = new AsyncResource('bound-anonymous-fn')
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     const processId = this.processID
+    let pgQuery = {
+      text: arguments[0]
+    }
+
     return asyncResource.runInAsyncScope(() => {
       startCh.publish({
         params: this.connectionParameters,
-        originalQuery: pgQuery.text,
         query: pgQuery,
         processId
       })
 
+      arguments[0] = pgQuery.text
+
       const finish = asyncResource.bind(function (error) {
         if (error) {
           errorCh.publish(error)
@@ -55,6 +50,16 @@ function wrapQuery (query) {
         finishCh.publish()
       })
 
+      const retval = query.apply(this, arguments)
+      const queryQueue = this.queryQueue || this._queryQueue
+      const activeQuery = this.activeQuery || this._activeQuery
+
+      pgQuery = queryQueue[queryQueue.length - 1] || activeQuery
+
+      if (!pgQuery) {
+        return retval
+      }
+
       if (pgQuery.callback) {
         const originalCallback = callbackResource.bind(pgQuery.callback)
         pgQuery.callback = function (err, res) {

package/packages/datadog-instrumentations/src/playwright.js

@@ -76,7 +76,7 @@ function getRootDir (playwrightRunner) {
 }
 
 function testBeginHandler (test) {
-  const { title: testName, location: { file: testSuiteAbsolutePath }, _type } = test
+  const { _requireFile: testSuiteAbsolutePath, title: testName, _type } = test
 
   if (_type === 'beforeAll' || _type === 'afterAll') {
     return
@@ -101,7 +101,7 @@ function testBeginHandler (test) {
 }
 
 function testEndHandler (test, testStatus, error) {
-  const { location: { file: testSuiteAbsolutePath }, results, _type } = test
+  const { _requireFile: testSuiteAbsolutePath, results, _type } = test
 
   if (_type === 'beforeAll' || _type === 'afterAll') {
     return

package/packages/datadog-plugin-amqp10/src/consumer.js

@@ -4,7 +4,7 @@ const ConsumerPlugin = require('../../dd-trace/src/plugins/consumer')
 const { getAddress, getShortName } = require('./util')
 
 class Amqp10ConsumerPlugin extends ConsumerPlugin {
-  static get name () { return 'amqp10' }
+  static get id () { return 'amqp10' }
   static get system () { return 'amqp' }
 
   start ({ link }) {

package/packages/datadog-plugin-amqp10/src/index.js

@@ -5,7 +5,7 @@ const ConsumerPlugin = require('./consumer')
 const CompositePlugin = require('../../dd-trace/src/plugins/composite')
 
 class Amqp10Plugin extends CompositePlugin {
-  static get name () { return 'amqp10' }
+  static get id () { return 'amqp10' }
   static get plugins () {
     return {
       producer: ProducerPlugin,

package/packages/datadog-plugin-amqp10/src/producer.js

@@ -1,10 +1,11 @@
 'use strict'
 
 const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
+const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
 const { getAddress, getShortName } = require('./util')
 
 class Amqp10ProducerPlugin extends ProducerPlugin {
-  static get name () { return 'amqp10' }
+  static get id () { return 'amqp10' }
   static get operation () { return 'send' }
   static get system () { return 'amqp' }
 
@@ -20,7 +21,7 @@ class Amqp10ProducerPlugin extends ProducerPlugin {
         'amqp.link.target.address': target,
         'amqp.link.role': 'sender',
         'out.host': address.host,
-        'out.port': address.port,
+        [CLIENT_PORT_KEY]: address.port,
         'amqp.link.name': link.name,
         'amqp.link.handle': link.handle,
         'amqp.connection.host': address.host,

package/packages/datadog-plugin-amqplib/src/client.js

@@ -1,11 +1,12 @@
 'use strict'
 
 const { TEXT_MAP } = require('../../../ext/formats')
+const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
 const ClientPlugin = require('../../dd-trace/src/plugins/client')
 const { getResourceName } = require('./util')
 
 class AmqplibClientPlugin extends ClientPlugin {
-  static get name () { return 'amqplib' }
+  static get id () { return 'amqplib' }
   static get operation () { return 'command' }
 
   start ({ channel = {}, method, fields }) {
@@ -19,7 +20,7 @@ class AmqplibClientPlugin extends ClientPlugin {
       kind: 'client',
       meta: {
         'out.host': stream._host,
-        'out.port': stream.remotePort,
+        [CLIENT_PORT_KEY]: stream.remotePort,
         'amqp.queue': fields.queue,
         'amqp.exchange': fields.exchange,
         'amqp.routingKey': fields.routingKey,

package/packages/datadog-plugin-amqplib/src/consumer.js

@@ -5,7 +5,7 @@ const ConsumerPlugin = require('../../dd-trace/src/plugins/consumer')
 const { getResourceName } = require('./util')
 
 class AmqplibConsumerPlugin extends ConsumerPlugin {
-  static get name () { return 'amqplib' }
+  static get id () { return 'amqplib' }
   static get operation () { return 'command' }
 
   start ({ method, fields, message }) {

package/packages/datadog-plugin-amqplib/src/index.js

@@ -7,7 +7,7 @@ const CompositePlugin = require('../../dd-trace/src/plugins/composite')
 
 // TODO: Consider splitting channels for publish/receive in the instrumentation.
 class AmqplibPlugin extends CompositePlugin {
-  static get name () { return 'amqplib' }
+  static get id () { return 'amqplib' }
   static get plugins () {
     return {
       producer: ProducerPlugin,