@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,105 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { channel, addHook } = require('./helpers/instrument')
+
+addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connection => {
+  const startCh = channel('apm:mysql:query:start')
+  const finishCh = channel('apm:mysql:query:finish')
+  const errorCh = channel('apm:mysql:query:error')
+
+  shimmer.wrap(Connection.prototype, 'query', query => function () {
+    if (!startCh.hasSubscribers) {
+      return query.apply(this, arguments)
+    }
+
+    const sql = arguments[0].sql || arguments[0]
+    const conf = this.config
+    const ctx = { sql, conf }
+
+    return startCh.runStores(ctx, () => {
+      if (arguments[0].sql) {
+        arguments[0].sql = ctx.sql
+      } else {
+        arguments[0] = ctx.sql
+      }
+
+      try {
+        const res = query.apply(this, arguments)
+
+        if (res._callback) {
+          const cb = res._callback
+          res._callback = shimmer.wrapFunction(cb, cb => function (error, result) {
+            if (error) {
+              ctx.error = error
+              errorCh.publish(ctx)
+            }
+            ctx.result = result
+
+            return finishCh.runStores(ctx, cb, this, error, result)
+          })
+        } else {
+          res.once('end', () => finishCh.publish(ctx))
+        }
+
+        return res
+      } catch (err) {
+        void err.stack // trigger getting the stack at the original throwing point
+        ctx.error = err
+        errorCh.publish(ctx)
+
+        throw err
+      }
+    })
+  })
+
+  return Connection
+})
+
+addHook({ name: 'mysql', file: 'lib/Pool.js', versions: ['>=2'] }, Pool => {
+  const connectionStartCh = channel('apm:mysql:connection:start')
+  const connectionFinishCh = channel('apm:mysql:connection:finish')
+  const startPoolQueryCh = channel('datadog:mysql:pool:query:start')
+  const finishPoolQueryCh = channel('datadog:mysql:pool:query:finish')
+
+  shimmer.wrap(Pool.prototype, 'getConnection', getConnection => function (cb) {
+    arguments[0] = function () {
+      return connectionFinishCh.runStores(ctx, cb, this, ...arguments)
+    }
+
+    const ctx = {}
+
+    connectionStartCh.publish(ctx)
+
+    return getConnection.apply(this, arguments)
+  })
+
+  shimmer.wrap(Pool.prototype, 'query', query => function () {
+    if (!startPoolQueryCh.hasSubscribers) {
+      return query.apply(this, arguments)
+    }
+
+    const sql = arguments[0].sql || arguments[0]
+    const ctx = { sql }
+    const finish = () => finishPoolQueryCh.publish(ctx)
+
+    return startPoolQueryCh.runStores(ctx, () => {
+      const cb = arguments[arguments.length - 1]
+      if (typeof cb === 'function') {
+        arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => function () {
+          return finishPoolQueryCh.runStores(ctx, cb, this, ...arguments)
+        })
+      }
+
+      const retval = query.apply(this, arguments)
+
+      if (retval && retval.then) {
+        retval.then(finish).catch(finish)
+      }
+
+      return retval
+    })
+  })
+
+  return Pool
+})

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

@@ -0,0 +1,380 @@
+'use strict'
+
+const { errorMonitor } = require('node:events')
+
+const shimmer = require('../../datadog-shimmer')
+const satisfies = require('../../../vendor/dist/semifies')
+const { channel, addHook } = require('./helpers/instrument')
+
+/** @type {WeakMap<object, Function>} */
+const wrappedOnResult = new WeakMap()
+
+/**
+ * @param {unknown} sql
+ * @returns {string|undefined}
+ */
+function resolveSqlString (sql) {
+  return typeof sql === 'string' ? sql : /** @type {{ sql?: string }} */ (sql)?.sql
+}
+
+/**
+ * @param {Function} Connection
+ * @param {string} version
+ * @returns {Function}
+ */
+function wrapConnection (Connection, version) {
+  const startCh = channel('apm:mysql2:query:start')
+  const finishCh = channel('apm:mysql2:query:finish')
+  const errorCh = channel('apm:mysql2:query:error')
+  const startOuterQueryCh = channel('datadog:mysql2:outerquery:start')
+  const commandAddCh = channel('apm:mysql2:command:add')
+  const commandStartCh = channel('apm:mysql2:command:start')
+  const commandFinishCh = channel('apm:mysql2:command:finish')
+  const shouldEmitEndAfterQueryAbort = satisfies(version, '>=1.3.3')
+
+  shimmer.wrap(Connection.prototype, 'addCommand', addCommand => function (cmd) {
+    if (!startCh.hasSubscribers) return addCommand.apply(this, arguments)
+
+    const command = /** @type {{ execute?: Function, constructor?: { name?: string } }} */ (cmd)
+    if (typeof command.execute !== 'function') return addCommand.apply(this, arguments)
+
+    const name = command.constructor?.name
+    const isQuery = name === 'Execute' || name === 'Query'
+    const ctx = {}
+
+    if (isQuery) {
+      command.execute = wrapExecute(command, command.execute, ctx, this.config)
+
+      return commandAddCh.runStores(ctx, addCommand, this, ...arguments)
+    }
+
+    wrapCommandOnResult(command, ctx)
+
+    command.execute = shimmer.wrapFunction(
+      command.execute,
+      execute => function executeWithTrace (_packet_, _connection_) {
+        return commandStartCh.runStores(ctx, execute, this, ...arguments)
+      }
+    )
+
+    return commandAddCh.runStores(ctx, addCommand, this, ...arguments)
+  })
+
+  shimmer.wrap(Connection.prototype, 'query', query => function (sql, values, cb) {
+    if (!startOuterQueryCh.hasSubscribers) return query.apply(this, arguments)
+
+    const resolvedSql = resolveSqlString(sql)
+    if (resolvedSql === undefined) return query.apply(this, arguments)
+
+    const abortController = new AbortController()
+    startOuterQueryCh.publish({ sql: resolvedSql, abortController })
+
+    if (abortController.signal.aborted) {
+      const addCommand = this.addCommand
+      this.addCommand = function (cmd) { return cmd }
+
+      let queryCommand
+      try {
+        queryCommand = query.apply(this, arguments)
+      } finally {
+        this.addCommand = addCommand
+      }
+
+      cb = queryCommand.onResult
+
+      process.nextTick(() => {
+        if (typeof cb === 'function') {
+          cb(abortController.signal.reason)
+        } else {
+          queryCommand.emit('error', abortController.signal.reason)
+        }
+
+        if (shouldEmitEndAfterQueryAbort) {
+          queryCommand.emit('end')
+        }
+      })
+
+      return queryCommand
+    }
+
+    return query.apply(this, arguments)
+  })
+
+  shimmer.wrap(Connection.prototype, 'execute', execute => function (sql, values, cb) {
+    if (!startOuterQueryCh.hasSubscribers) return execute.apply(this, arguments)
+
+    const resolvedSql = resolveSqlString(sql)
+    if (resolvedSql === undefined) return execute.apply(this, arguments)
+
+    const abortController = new AbortController()
+    startOuterQueryCh.publish({ sql: resolvedSql, abortController })
+
+    if (abortController.signal.aborted) {
+      const addCommand = this.addCommand
+      this.addCommand = function (cmd) { return cmd }
+
+      let result
+      try {
+        result = execute.apply(this, arguments)
+      } finally {
+        this.addCommand = addCommand
+      }
+
+      if (typeof result?.onResult === 'function') {
+        result.onResult(abortController.signal.reason)
+      }
+
+      return result
+    }
+
+    return execute.apply(this, arguments)
+  })
+
+  return Connection
+
+  /**
+   * @param {object} cmd
+   * @param {object} ctx
+   * @returns {void}
+   */
+  function wrapCommandOnResult (cmd, ctx) {
+    const onResult = cmd?.onResult
+    if (typeof onResult !== 'function') return
+
+    const cached = wrappedOnResult.get(cmd)
+
+    if (cached === onResult) return
+
+    const wrapped = function () {
+      return commandFinishCh.runStores(ctx, onResult, this, ...arguments)
+    }
+
+    wrappedOnResult.set(cmd, wrapped)
+    cmd.onResult = wrapped
+  }
+
+  /**
+   * @param {object} cmd
+   * @param {Function} execute
+   * @param {object} ctx
+   * @param {object} config
+   * @returns {Function}
+   */
+  function wrapExecute (cmd, execute, ctx, config) {
+    return shimmer.wrapFunction(execute, execute => function executeWithTrace (packet, connection) {
+      const command = /** @type {{ statement?: { query?: unknown }, sql?: unknown }} */ (cmd)
+      ctx.sql = command.statement ? command.statement.query : command.sql
+      ctx.conf = config
+
+      return startCh.runStores(ctx, () => {
+        if (command.statement) {
+          command.statement.query = ctx.sql
+        } else {
+          command.sql = ctx.sql
+        }
+
+        if (typeof this.onResult === 'function') {
+          const onResult = this.onResult
+
+          this.onResult = shimmer.wrapFunction(onResult, onResult => function (error) {
+            if (error) {
+              ctx.error = error
+              errorCh.publish(ctx)
+            }
+            finishCh.runStores(ctx, onResult, this, ...arguments)
+          })
+        } else {
+          const command = /** @type {{ once?: Function }} */ (this)
+          if (typeof command.once === 'function') {
+            command.once(errorMonitor, error => {
+              ctx.error = error
+              errorCh.publish(ctx)
+            })
+            command.once('end', () => finishCh.publish(ctx))
+          }
+        }
+
+        this.execute = execute
+
+        try {
+          return execute.apply(this, arguments)
+        } catch (err) {
+          ctx.error = err
+          errorCh.publish(ctx)
+        }
+      })
+    })
+  }
+}
+/**
+ * @param {Function} Pool
+ * @param {string} version
+ * @returns {Function}
+ */
+function wrapPool (Pool, version) {
+  const startOuterQueryCh = channel('datadog:mysql2:outerquery:start')
+  const shouldEmitEndAfterQueryAbort = satisfies(version, '>=1.3.3')
+
+  shimmer.wrap(Pool.prototype, 'query', query => function (sql, values, cb) {
+    if (!startOuterQueryCh.hasSubscribers) return query.apply(this, arguments)
+
+    const resolvedSql = resolveSqlString(sql)
+    if (resolvedSql === undefined) return query.apply(this, arguments)
+
+    const abortController = new AbortController()
+    startOuterQueryCh.publish({ sql: resolvedSql, abortController })
+
+    if (abortController.signal.aborted) {
+      const getConnection = this.getConnection
+      this.getConnection = function () {}
+
+      let queryCommand
+      try {
+        queryCommand = query.apply(this, arguments)
+      } finally {
+        this.getConnection = getConnection
+      }
+
+      process.nextTick(() => {
+        if (queryCommand.onResult) {
+          queryCommand.onResult(abortController.signal.reason)
+        } else {
+          queryCommand.emit('error', abortController.signal.reason)
+        }
+
+        if (shouldEmitEndAfterQueryAbort) {
+          queryCommand.emit('end')
+        }
+      })
+
+      return queryCommand
+    }
+
+    return query.apply(this, arguments)
+  })
+
+  shimmer.wrap(Pool.prototype, 'execute', execute => function (sql, values, cb) {
+    if (!startOuterQueryCh.hasSubscribers) return execute.apply(this, arguments)
+
+    const resolvedSql = resolveSqlString(sql)
+    if (resolvedSql === undefined) return execute.apply(this, arguments)
+
+    const abortController = new AbortController()
+    startOuterQueryCh.publish({ sql: resolvedSql, abortController })
+
+    if (abortController.signal.aborted) {
+      if (typeof values === 'function') {
+        cb = values
+      }
+
+      if (typeof cb === 'function') {
+        process.nextTick(() => {
+          /** @type {Function} */ (cb)(abortController.signal.reason)
+        })
+      }
+      return
+    }
+
+    return execute.apply(this, arguments)
+  })
+
+  return Pool
+}
+
+/**
+ * @param {Function} PoolCluster
+ * @returns {Function}
+ */
+function wrapPoolCluster (PoolCluster) {
+  const startOuterQueryCh = channel('datadog:mysql2:outerquery:start')
+  const wrappedPoolNamespaces = new WeakSet()
+
+  shimmer.wrap(PoolCluster.prototype, 'of', of => function () {
+    const poolNamespace = of.apply(this, arguments)
+
+    if (startOuterQueryCh.hasSubscribers && !wrappedPoolNamespaces.has(poolNamespace)) {
+      shimmer.wrap(poolNamespace, 'query', query => function (sql, values, cb) {
+        const resolvedSql = resolveSqlString(sql)
+        if (resolvedSql === undefined) return query.apply(this, arguments)
+
+        const abortController = new AbortController()
+        startOuterQueryCh.publish({ sql: resolvedSql, abortController })
+
+        if (abortController.signal.aborted) {
+          const getConnection = this.getConnection
+          this.getConnection = function () {}
+
+          let queryCommand
+          try {
+            queryCommand = query.apply(this, arguments)
+          } finally {
+            this.getConnection = getConnection
+          }
+
+          process.nextTick(() => {
+            if (queryCommand.onResult) {
+              queryCommand.onResult(abortController.signal.reason)
+            } else {
+              queryCommand.emit('error', abortController.signal.reason)
+            }
+
+            queryCommand.emit('end')
+          })
+
+          return queryCommand
+        }
+
+        return query.apply(this, arguments)
+      })
+
+      shimmer.wrap(poolNamespace, 'execute', execute => function (sql, values, cb) {
+        const resolvedSql = resolveSqlString(sql)
+        if (resolvedSql === undefined) return execute.apply(this, arguments)
+
+        const abortController = new AbortController()
+        startOuterQueryCh.publish({ sql: resolvedSql, abortController })
+
+        if (abortController.signal.aborted) {
+          if (typeof values === 'function') {
+            cb = values
+          }
+
+          if (typeof cb === 'function') {
+            process.nextTick(() => {
+              /** @type {Function} */ (cb)(abortController.signal.reason)
+            })
+          }
+
+          return
+        }
+
+        return execute.apply(this, arguments)
+      })
+
+      wrappedPoolNamespaces.add(poolNamespace)
+    }
+
+    return poolNamespace
+  })
+
+  return PoolCluster
+}
+
+addHook(
+  { name: 'mysql2', file: 'lib/base/connection.js', versions: ['>=3.11.5'] },
+  /** @type {(moduleExports: unknown, version: string) => unknown} */ (wrapConnection)
+)
+addHook(
+  { name: 'mysql2', file: 'lib/connection.js', versions: ['1 - 3.11.4'] },
+  /** @type {(moduleExports: unknown, version: string) => unknown} */ (wrapConnection)
+)
+addHook(
+  { name: 'mysql2', file: 'lib/pool.js', versions: ['1 - 3.11.4'] },
+  /** @type {(moduleExports: unknown, version: string) => unknown} */ (wrapPool)
+)
+
+// PoolNamespace.prototype.query does not exist in mysql2<2.3.0
+addHook(
+  { name: 'mysql2', file: 'lib/pool_cluster.js', versions: ['2.3.0 - 3.11.4'] },
+  /** @type {(moduleExports: unknown, version: string) => unknown} */ (wrapPoolCluster)
+)

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

@@ -0,0 +1,143 @@
+'use strict'
+
+const { errorMonitor } = require('events')
+
+const shimmer = require('../../datadog-shimmer')
+const { channel, addHook } = require('./helpers/instrument')
+
+const startICPCh = channel('apm:net:ipc:start')
+const finishICPCh = channel('apm:net:ipc:finish')
+const errorICPCh = channel('apm:net:ipc:error')
+
+const startTCPCh = channel('apm:net:tcp:start')
+const finishTCPCh = channel('apm:net:tcp:finish')
+const errorTCPCh = channel('apm:net:tcp:error')
+
+const readyCh = channel('apm:net:tcp:ready')
+const connectionCh = channel('apm:net:tcp:connection')
+
+const names = ['net', 'node:net']
+
+addHook({ name: names }, (net, version, name) => {
+  // explicitly require dns so that net gets an instrumented instance
+  // so that we don't miss the dns calls
+  if (name === 'net') {
+    require('dns')
+  } else {
+    require('node:dns')
+  }
+
+  shimmer.wrap(net.Socket.prototype, 'connect', connect => function () {
+    if (!startICPCh.hasSubscribers || !startTCPCh.hasSubscribers) {
+      return connect.apply(this, arguments)
+    }
+
+    const options = getOptions(arguments)
+    const lastIndex = arguments.length - 1
+    const callback = arguments[lastIndex]
+
+    if (!options) return connect.apply(this, arguments)
+
+    const protocol = options.path ? 'ipc' : 'tcp'
+    const startCh = protocol === 'ipc' ? startICPCh : startTCPCh
+    const finishCh = protocol === 'ipc' ? finishICPCh : finishTCPCh
+    const errorCh = protocol === 'ipc' ? errorICPCh : errorTCPCh
+    const ctx = { options }
+
+    if (typeof callback === 'function') {
+      arguments[lastIndex] = function (...args) {
+        return finishCh.runStores(ctx, callback, this, ...args)
+      }
+    }
+
+    return startCh.runStores(ctx, () => {
+      setupListeners(this, protocol, ctx, finishCh, errorCh)
+
+      const emit = this.emit
+      this.emit = shimmer.wrapFunction(emit, emit => function (eventName) {
+        switch (eventName) {
+          case 'ready':
+          case 'connect':
+            return readyCh.runStores(ctx, () => {
+              return emit.apply(this, arguments)
+            })
+          default:
+            return emit.apply(this, arguments)
+        }
+      })
+
+      try {
+        return connect.apply(this, arguments)
+      } catch (err) {
+        errorCh.publish(err)
+
+        throw err
+      }
+    })
+  })
+
+  return net
+})
+
+function getOptions (args) {
+  if (!args[0]) return
+
+  switch (typeof args[0]) {
+    case 'object':
+      if (Array.isArray(args[0])) return getOptions(args[0])
+      return args[0]
+    case 'string':
+      if (Number.isNaN(Number.parseFloat(args[0]))) {
+        return {
+          path: args[0],
+        }
+      }
+    case 'number': // eslint-disable-line no-fallthrough
+      return {
+        port: args[0],
+        host: typeof args[1] === 'string' ? args[1] : 'localhost',
+      }
+  }
+}
+
+function setupListeners (socket, protocol, ctx, finishCh, errorCh) {
+  const events = [errorMonitor, 'close', 'timeout']
+
+  const wrapListener = function (error) {
+    if (error) {
+      ctx.error = error
+      errorCh.publish(ctx)
+    }
+    finishCh.runStores(ctx, () => {})
+    cleanupOtherListeners()
+  }
+
+  const localListener = function (error) {
+    ctx.socket = socket
+    connectionCh.publish(ctx)
+    if (error) {
+      ctx.error = error
+      errorCh.publish(ctx)
+    }
+    finishCh.runStores(ctx, () => {})
+    cleanupOtherListeners()
+  }
+
+  const cleanupOtherListeners = function () {
+    socket.removeListener('connect', localListener)
+    for (const event of events) {
+      socket.removeListener(event, wrapListener)
+    }
+  }
+
+  // TODO: Identify why the connect listener should remove the other listeners.
+  if (protocol === 'tcp') {
+    socket.once('connect', localListener)
+  } else {
+    events.push('connect')
+  }
+
+  for (const event of events) {
+    socket.once(event, wrapListener)
+  }
+}