@depup/dd-trace 5.90.0-depup.0

package/packages/datadog-instrumentations/src/moleculer/server.js

@@ -0,0 +1,58 @@
+'use strict'
+
+const { channel, addHook } = require('../helpers/instrument')
+const shimmer = require('../../../datadog-shimmer')
+
+const startChannel = channel('apm:moleculer:action:start')
+const finishChannel = channel('apm:moleculer:action:finish')
+const errorChannel = channel('apm:moleculer:action:error')
+
+function wrapRegisterMiddlewares (registerMiddlewares) {
+  return function (userMiddlewares) {
+    if (this.middlewares && this.middlewares.add) {
+      this.middlewares.add(createMiddleware())
+    }
+
+    return registerMiddlewares.apply(this, arguments)
+  }
+}
+
+function createMiddleware () {
+  return {
+    name: 'Datadog',
+
+    localAction (next, action) {
+      const broker = this
+
+      return shimmer.wrapFunction(next, next => function datadogMiddleware (middlewareCtx) {
+        const ctx = { action, middlewareCtx, broker }
+        return startChannel.runStores(ctx, () => {
+          try {
+            return next(middlewareCtx).then(
+              result => {
+                finishChannel.publish(ctx)
+                return result
+              },
+              error => {
+                ctx.error = error
+                errorChannel.publish(ctx)
+                finishChannel.publish(ctx)
+                throw error
+              }
+            )
+          } catch (e) {
+            ctx.error = e
+            errorChannel.publish(ctx)
+            finishChannel.publish(ctx)
+          }
+        })
+      })
+    },
+  }
+}
+
+addHook({ name: 'moleculer', versions: ['>=0.14'] }, moleculer => {
+  shimmer.wrap(moleculer.ServiceBroker.prototype, 'registerMiddlewares', wrapRegisterMiddlewares)
+
+  return moleculer
+})

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

@@ -0,0 +1,4 @@
+'use strict'
+
+require('./moleculer/client')
+require('./moleculer/server')

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

@@ -0,0 +1,213 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const {
+  channel,
+  addHook,
+  AsyncResource,
+} = require('./helpers/instrument')
+
+const startCh = channel('apm:mongodb:query:start')
+const finishCh = channel('apm:mongodb:query:finish')
+const errorCh = channel('apm:mongodb:query:error')
+
+addHook({ name: 'mongodb-core', versions: ['2 - 3.1.9'] }, Server => {
+  const serverProto = Server.Server.prototype
+  shimmer.wrap(serverProto, 'command', command => wrapCommand(command, 'command'))
+  shimmer.wrap(serverProto, 'insert', insert => wrapCommand(insert, 'insert', 'insert'))
+  shimmer.wrap(serverProto, 'update', update => wrapCommand(update, 'update', 'update'))
+  shimmer.wrap(serverProto, 'remove', remove => wrapCommand(remove, 'remove', 'remove'))
+
+  const cursorProto = Server.Cursor.prototype
+  shimmer.wrap(cursorProto, '_getmore', _getmore => wrapCursor(_getmore, 'getMore', 'getMore'))
+  shimmer.wrap(cursorProto, '_find', _find => wrapQuery(_find, '_find'))
+  shimmer.wrap(cursorProto, 'kill', kill => wrapCursor(kill, 'killCursors', 'killCursors'))
+  return Server
+})
+
+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 <6.4.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: ['>=6.4.0'], file: 'lib/cmap/connection.js' }, Connection => {
+  const proto = Connection.Connection.prototype
+  shimmer.wrap(proto, 'command', command => wrapConnectionCommand(command, 'command', undefined, instrumentPromise))
+  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))
+
+addHook({ name: 'mongodb-core', versions: ['~3.1.10'], file: 'lib/wireprotocol/3_2_support.js' }, WireProtocol => {
+  shimmer.wrap(WireProtocol.prototype, 'command', command => wrapUnifiedCommand(command, 'command'))
+  return WireProtocol
+})
+
+addHook({ name: 'mongodb-core', versions: ['~3.1.10'], file: 'lib/wireprotocol/2_6_support.js' }, WireProtocol => {
+  shimmer.wrap(WireProtocol.prototype, 'command', command => wrapUnifiedCommand(command, 'command'))
+  return WireProtocol
+})
+
+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
+
+    callback = arguments[callbackIndex]
+
+    if (typeof callback === 'function') {
+      arguments[callbackIndex] = asyncResource.bind(callback)
+    }
+
+    return maybePromise.apply(this, arguments)
+  })
+  return util
+})
+
+function wrapWp (wp) {
+  shimmer.wrap(wp, 'command', command => wrapUnifiedCommand(command, 'command'))
+  shimmer.wrap(wp, 'insert', insert => wrapUnifiedCommand(insert, 'insert', 'insert'))
+  shimmer.wrap(wp, 'update', update => wrapUnifiedCommand(update, 'update', 'update'))
+  shimmer.wrap(wp, 'remove', remove => wrapUnifiedCommand(remove, 'remove', 'remove'))
+  shimmer.wrap(wp, 'query', query => wrapUnifiedCommand(query, 'query'))
+  shimmer.wrap(wp, 'getMore', getMore => wrapUnifiedCommand(getMore, 'getMore', 'getMore'))
+  shimmer.wrap(wp, 'killCursors', killCursors => wrapUnifiedCommand(killCursors, 'killCursors', 'killCursors'))
+  return wp
+}
+
+function wrapUnifiedCommand (command, operation, name) {
+  const wrapped = function (server, ns, ops) {
+    if (!startCh.hasSubscribers) {
+      return command.apply(this, arguments)
+    }
+    return instrument(operation, command, this, arguments, server, ns, ops, { name })
+  }
+  return wrapped
+}
+
+function wrapConnectionCommand (command, operation, name, instrumentFn = instrument) {
+  const wrapped = function (ns, ops) {
+    if (!startCh.hasSubscribers) {
+      return command.apply(this, arguments)
+    }
+    const hostParts = typeof this.address === 'string' ? this.address.split(':') : ''
+    const options = hostParts.length === 2
+      ? { host: hostParts[0], port: hostParts[1] }
+      : {} // no port means the address is a random UUID so no host either
+    const topology = { s: { options } }
+
+    ns = `${ns.db}.${ns.collection}`
+    return instrumentFn(operation, command, this, arguments, topology, ns, ops, { name })
+  }
+  return wrapped
+}
+
+function wrapQuery (query, operation, name) {
+  const wrapped = function () {
+    if (!startCh.hasSubscribers) {
+      return query.apply(this, arguments)
+    }
+    const pool = this.server.s.pool
+    const ns = this.ns
+    const ops = this.cmd
+    return instrument(operation, query, this, arguments, pool, ns, ops)
+  }
+
+  return wrapped
+}
+
+function wrapCursor (cursor, operation, name) {
+  const wrapped = function () {
+    if (!startCh.hasSubscribers) {
+      return cursor.apply(this, arguments)
+    }
+    const pool = this.server.s.pool
+    const ns = this.ns
+    return instrument(operation, cursor, this, arguments, pool, ns, {}, { name })
+  }
+  return wrapped
+}
+
+function wrapCommand (command, operation, name) {
+  const wrapped = function (ns, ops) {
+    if (!startCh.hasSubscribers) {
+      return command.apply(this, arguments)
+    }
+    return instrument(operation, command, this, arguments, this, ns, ops, { name })
+  }
+  return wrapped
+}
+
+function instrument (operation, command, instance, args, server, ns, ops, options = {}) {
+  const name = options.name || (ops && Object.keys(ops)[0])
+  const index = args.length - 1
+  const callback = args[index]
+
+  if (typeof callback !== 'function') return command.apply(instance, args)
+
+  const serverInfo = server && server.s && server.s.options
+
+  const ctx = {
+    ns,
+    ops,
+    options: serverInfo,
+    name,
+  }
+  return startCh.runStores(ctx, () => {
+    args[index] = shimmer.wrapFunction(callback, callback => function (err, res) {
+      if (err) {
+        ctx.error = err
+        errorCh.publish(ctx)
+      }
+
+      return finishCh.runStores(ctx, callback, this, ...arguments)
+    })
+
+    try {
+      return command.apply(instance, args)
+    } catch (err) {
+      ctx.error = err
+      errorCh.publish(ctx)
+
+      throw err
+    }
+  })
+}
+
+function instrumentPromise (operation, command, instance, args, server, ns, ops, options = {}) {
+  const name = options.name || (ops && Object.keys(ops)[0])
+
+  const serverInfo = server && server.s && server.s.options
+
+  const ctx = {
+    ns,
+    ops,
+    options: serverInfo,
+    name,
+  }
+
+  return startCh.runStores(ctx, () => {
+    const promise = command.apply(instance, args)
+
+    promise.then(function (res) {
+      ctx.result = res
+      finishCh.publish(ctx)
+    }, function (err) {
+      ctx.error = err
+      errorCh.publish(ctx)
+      finishCh.publish(ctx)
+    })
+
+    return promise
+  })
+}

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

@@ -0,0 +1,59 @@
+'use strict'
+
+require('./mongodb-core')
+
+const shimmer = require('../../datadog-shimmer')
+const {
+  channel,
+  addHook,
+} = require('./helpers/instrument')
+
+// collection methods with filter
+const collectionMethodsWithFilter = [
+  'count',
+  'countDocuments',
+  'deleteMany',
+  'deleteOne',
+  'find',
+  'findOneAndDelete',
+  'findOneAndReplace',
+  'replaceOne',
+] // findOne is ignored because it calls to find
+
+const collectionMethodsWithTwoFilters = [
+  'findOneAndUpdate',
+  'updateMany',
+  'updateOne',
+]
+
+const startCh = channel('datadog:mongodb:collection:filter:start')
+
+addHook({ name: 'mongodb', versions: ['>=3.3 <5', '5', '>=6'] }, mongodb => {
+  for (const methodName of [...collectionMethodsWithFilter, ...collectionMethodsWithTwoFilters]) {
+    if (!(methodName in mongodb.Collection.prototype)) continue
+
+    const useTwoArguments = collectionMethodsWithTwoFilters.includes(methodName)
+
+    shimmer.wrap(mongodb.Collection.prototype, methodName, method => {
+      return function () {
+        if (!startCh.hasSubscribers) {
+          return method.apply(this, arguments)
+        }
+
+        const ctx = {
+          filters: [arguments[0]],
+          methodName,
+        }
+
+        if (useTwoArguments) {
+          ctx.filters.push(arguments[1])
+        }
+
+        return startCh.runStores(ctx, () => {
+          return method.apply(this, arguments)
+        })
+      }
+    })
+  }
+  return mongodb
+})

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

@@ -0,0 +1,179 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel } = require('./helpers/instrument')
+const { wrapThen } = require('./helpers/promise')
+
+const startCh = channel('datadog:mongoose:model:filter:start')
+const finishCh = channel('datadog:mongoose:model:filter:finish')
+// this channel is for wrapping the callback of exec methods and handling store context
+const execStartCh = channel('apm:mongoose:exec:start')
+const execFinishCh = channel('apm:mongoose:exec:finish')
+
+function wrapAddQueue (addQueue) {
+  const ctx = {}
+
+  return execStartCh.runStores(ctx, () => {
+    return function addQueueWithTrace (name) {
+      return execFinishCh.runStores(ctx, () => {
+        return addQueue.apply(this, arguments)
+      })
+    }
+  })
+}
+
+addHook({
+  name: 'mongoose',
+  versions: ['>=4.6.4 <5', '5', '6', '>=7'],
+  file: 'lib/index.js',
+}, mongoose => {
+  // As of Mongoose 7, custom promise libraries are no longer supported and mongoose.Promise may be undefined
+  if (mongoose.Promise && mongoose.Promise !== global.Promise) {
+    shimmer.wrap(mongoose.Promise.prototype, 'then', wrapThen)
+  }
+
+  shimmer.wrap(mongoose.Collection.prototype, 'addQueue', wrapAddQueue)
+
+  return mongoose
+})
+
+const collectionMethodsWithFilter = [
+  'count',
+  'countDocuments',
+  'deleteMany',
+  'deleteOne',
+  'find',
+  'findOne',
+  'findOneAndDelete',
+  'findOneAndReplace',
+  'replaceOne',
+  'remove',
+]
+
+const collectionMethodsWithTwoFilters = [
+  'findOneAndUpdate',
+  'updateMany',
+  'updateOne',
+]
+
+addHook({
+  name: 'mongoose',
+  versions: ['>=4.6.4 <5', '5', '6', '>=7'],
+  file: 'lib/model.js',
+}, Model => {
+  for (const methodName of [...collectionMethodsWithFilter, ...collectionMethodsWithTwoFilters]) {
+    const useTwoArguments = collectionMethodsWithTwoFilters.includes(methodName)
+    if (!(methodName in Model)) continue
+
+    shimmer.wrap(Model, methodName, method => {
+      return function wrappedModelMethod () {
+        if (!startCh.hasSubscribers) {
+          return method.apply(this, arguments)
+        }
+
+        const filters = [arguments[0]]
+        if (useTwoArguments) {
+          filters.push(arguments[1])
+        }
+
+        let callbackWrapped = false
+
+        const wrapCallbackIfExist = (args, ctx) => {
+          const lastArgumentIndex = args.length - 1
+
+          if (typeof args[lastArgumentIndex] === 'function') {
+            // is a callback, wrap it to execute finish()
+            shimmer.wrap(args, lastArgumentIndex, originalCb => {
+              return function () {
+                finishCh.publish(ctx)
+
+                return originalCb.apply(this, arguments)
+              }
+            })
+
+            callbackWrapped = true
+          }
+        }
+
+        const ctx = {
+          filters,
+          methodName,
+        }
+
+        return startCh.runStores(ctx, () => {
+          wrapCallbackIfExist(arguments, ctx)
+
+          const res = method.apply(this, arguments)
+
+          // if it is not callback, wrap exec method and its then
+          if (!callbackWrapped) {
+            shimmer.wrap(res, 'exec', originalExec => {
+              return function wrappedExec () {
+                if (!callbackWrapped) {
+                  wrapCallbackIfExist(arguments, ctx)
+                }
+
+                const execResult = originalExec.apply(this, arguments)
+
+                if (callbackWrapped || typeof execResult?.then !== 'function') {
+                  return execResult
+                }
+
+                // wrap them method, wrap resolve and reject methods
+                shimmer.wrap(execResult, 'then', originalThen => {
+                  return function wrappedThen () {
+                    const resolve = arguments[0]
+                    const reject = arguments[1]
+
+                    arguments[0] = shimmer.wrapFunction(resolve, resolve => function wrappedResolve () {
+                      finishCh.publish(ctx)
+
+                      if (resolve) {
+                        return resolve.apply(this, arguments)
+                      }
+                    })
+
+                    arguments[1] = shimmer.wrapFunction(reject, reject => function wrappedReject () {
+                      finishCh.publish(ctx)
+
+                      if (reject) {
+                        return reject.apply(this, arguments)
+                      }
+                    })
+
+                    return originalThen.apply(this, arguments)
+                  }
+                })
+
+                return execResult
+              }
+            })
+          }
+          return res
+        })
+      }
+    })
+  }
+
+  return Model
+})
+
+const sanitizeFilterFinishCh = channel('datadog:mongoose:sanitize-filter:finish')
+
+addHook({
+  name: 'mongoose',
+  versions: ['6', '>=7'],
+  file: 'lib/helpers/query/sanitizeFilter.js',
+}, sanitizeFilter => {
+  return shimmer.wrapFunction(sanitizeFilter, sanitizeFilter => function wrappedSanitizeFilter () {
+    const sanitizedObject = sanitizeFilter.apply(this, arguments)
+
+    if (sanitizeFilterFinishCh.hasSubscribers) {
+      sanitizeFilterFinishCh.publish({
+        sanitizedObject,
+      })
+    }
+
+    return sanitizedObject
+  })
+})

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

@@ -0,0 +1,65 @@
+'use strict'
+
+const dc = require('dc-polyfill')
+const shimmer = require('../../datadog-shimmer')
+const {
+  channel,
+  addHook,
+} = require('./helpers/instrument')
+
+const prepareCh = channel('datadog:mquery:filter:prepare')
+const tracingCh = dc.tracingChannel('datadog:mquery:filter')
+
+const methods = [
+  'find',
+  'findOne',
+  'findOneAndRemove',
+  'findOneAndDelete',
+  'count',
+  'distinct',
+  'where',
+]
+
+const methodsOptionalArgs = ['findOneAndUpdate']
+
+function getFilters (args, methodName) {
+  const [arg0, arg1] = args
+
+  const filters = arg0 !== null && typeof arg0 === 'object' ? [arg0] : []
+
+  if (arg1 !== null && typeof arg1 === 'object' && methodsOptionalArgs.includes(methodName)) {
+    filters.push(arg1)
+  }
+
+  return filters
+}
+
+addHook({
+  name: 'mquery',
+  versions: ['>=5.0.0'],
+}, Query => {
+  for (const methodName of [...methods, ...methodsOptionalArgs]) {
+    if (!(methodName in Query.prototype)) continue
+
+    shimmer.wrap(Query.prototype, methodName, method => {
+      return function () {
+        if (prepareCh.hasSubscribers) {
+          const filters = getFilters(arguments, methodName)
+          if (filters?.length) {
+            prepareCh.publish({ filters })
+          }
+        }
+
+        return method.apply(this, arguments)
+      }
+    })
+  }
+
+  shimmer.wrap(Query.prototype, 'exec', originalExec => {
+    return function wrappedExec () {
+      return tracingCh.tracePromise(originalExec, {}, this, arguments)
+    }
+  })
+
+  return Query
+})

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

@@ -0,0 +1,37 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { channel, addHook, AsyncResource } = require('./helpers/instrument')
+
+const multerReadCh = channel('datadog:multer:read:finish')
+
+function publishRequestBodyAndNext (req, res, next) {
+  return shimmer.wrapFunction(next, next => function () {
+    if (multerReadCh.hasSubscribers && req) {
+      const abortController = new AbortController()
+      const body = req.body
+
+      multerReadCh.publish({ req, res, body, abortController })
+
+      if (abortController.signal.aborted) return
+    }
+
+    return next.apply(this, arguments)
+  })
+}
+
+addHook({
+  name: 'multer',
+  file: 'lib/make-middleware.js',
+  versions: ['^1.4.4-lts.1'],
+}, makeMiddleware => {
+  return shimmer.wrapFunction(makeMiddleware, makeMiddleware => function () {
+    const middleware = makeMiddleware.apply(this, arguments)
+
+    return shimmer.wrapFunction(middleware, middleware => function wrapMulterMiddleware (req, res, next) {
+      const nextResource = new AsyncResource('bound-anonymous-fn')
+      arguments[2] = nextResource.bind(publishRequestBodyAndNext(req, res, next))
+      return middleware.apply(this, arguments)
+    })
+  })
+})