dd-trace 5.53.0 → 5.54.0

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

@@ -62,7 +62,7 @@ function wrap (prefix, fn, expectedArgs, rrtype) {
       return fn.apply(this, arguments)
     }
 
-    const args = Array.from(arguments)
+    const args = [...arguments]
     args.pop() // gets rid of the callback
     if (rrtype) {
       args.push(rrtype)

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

@@ -366,7 +366,7 @@ function massWrap (target, methods, wrapper) {
 function wrap (target, method, wrapper) {
   try {
     shimmer.wrap(target, method, wrapper)
-  } catch (e) {
+  } catch {
     // skip unavailable method
   }
 }

package/packages/datadog-instrumentations/src/google-cloud-pubsub.js

@@ -2,8 +2,7 @@
 
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -65,38 +64,32 @@ function wrapMethod (method) {
   return function (request) {
     if (!requestStartCh.hasSubscribers) return method.apply(this, arguments)
 
-    const innerAsyncResource = new AsyncResource('bound-anonymous-fn')
-
-    return innerAsyncResource.runInAsyncScope(() => {
-      const projectId = this.auth._cachedProjectId
+    const ctx = { request, api, projectId: this.auth._cachedProjectId }
+    return requestStartCh.runStores(ctx, () => {
       const cb = arguments[arguments.length - 1]
 
-      requestStartCh.publish({ request, api, projectId })
-
       if (typeof cb === 'function') {
-        const outerAsyncResource = new AsyncResource('bound-anonymous-fn')
-
-        arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => innerAsyncResource.bind(function (error) {
+        arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => function (error) {
           if (error) {
-            requestErrorCh.publish(error)
+            ctx.error = error
+            requestErrorCh.publish(ctx)
           }
 
-          requestFinishCh.publish()
-
-          return outerAsyncResource.runInAsyncScope(() => cb.apply(this, arguments))
-        }))
+          return requestFinishCh.runStores(ctx, cb, this, ...arguments)
+        })
 
         return method.apply(this, arguments)
       } else {
         return method.apply(this, arguments)
           .then(
             response => {
-              requestFinishCh.publish()
+              requestFinishCh.publish(ctx)
               return response
             },
             error => {
-              requestErrorCh.publish(error)
-              requestFinishCh.publish()
+              ctx.error = error
+              requestErrorCh.publish(ctx)
+              requestFinishCh.publish(ctx)
               throw error
             }
           )
@@ -119,16 +112,14 @@ addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'] }, (obj) => {
   shimmer.wrap(Subscription.prototype, 'emit', emit => function (eventName, message) {
     if (eventName !== 'message' || !message) return emit.apply(this, arguments)
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
-    return asyncResource.runInAsyncScope(() => {
-      try {
-        return emit.apply(this, arguments)
-      } catch (err) {
-        receiveErrorCh.publish(err)
-        throw err
-      }
-    })
+    const ctx = {}
+    try {
+      return emit.apply(this, arguments)
+    } catch (err) {
+      ctx.error = err
+      receiveErrorCh.publish(ctx)
+      throw err
+    }
   })
 
   return obj
@@ -136,22 +127,25 @@ addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'] }, (obj) => {
 
 addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'], file: 'build/src/lease-manager.js' }, (obj) => {
   const LeaseManager = obj.LeaseManager
+  const ctx = {}
 
   shimmer.wrap(LeaseManager.prototype, '_dispense', dispense => function (message) {
     if (receiveStartCh.hasSubscribers) {
-      receiveStartCh.publish({ message })
+      ctx.message = message
+      return receiveStartCh.runStores(ctx, dispense, this, ...arguments)
+    } else {
+      return dispense.apply(this, arguments)
     }
-    return dispense.apply(this, arguments)
   })
 
   shimmer.wrap(LeaseManager.prototype, 'remove', remove => function (message) {
-    receiveFinishCh.publish({ message })
-    return remove.apply(this, arguments)
+    return receiveFinishCh.runStores(ctx, remove, this, ...arguments)
   })
 
   shimmer.wrap(LeaseManager.prototype, 'clear', clear => function () {
     for (const message of this._messages) {
-      receiveFinishCh.publish({ message })
+      ctx.message = message
+      receiveFinishCh.publish(ctx)
     }
     return clear.apply(this, arguments)
   })

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

@@ -44,27 +44,24 @@ class AbortError extends Error {
   }
 }
 
+const types = new Set(['query', 'mutation', 'subscription'])
+
 function getOperation (document, operationName) {
   if (!document || !Array.isArray(document.definitions)) {
     return
   }
 
-  const definitions = document.definitions.filter(def => def)
-  const types = ['query', 'mutation', 'subscription']
-
-  if (operationName) {
-    return definitions
-      .filter(def => types.indexOf(def.operation) !== -1)
-      .find(def => operationName === (def.name && def.name.value))
-  } else {
-    return definitions.find(def => types.indexOf(def.operation) !== -1)
+  for (const definition of document.definitions) {
+    if (definition && types.has(definition.operation) && (!operationName || definition.name?.value === operationName)) {
+      return definition
+    }
   }
 }
 
 function normalizeArgs (args, defaultFieldResolver) {
   if (args.length !== 1) return normalizePositional(args, defaultFieldResolver)
 
-  args[0].contextValue = args[0].contextValue || {}
+  args[0].contextValue ||= {}
   args[0].fieldResolver = wrapResolve(args[0].fieldResolver || defaultFieldResolver)
 
   return args[0]

package/packages/datadog-instrumentations/src/grpc/client.js

@@ -4,8 +4,6 @@ const types = require('./types')
 const { addHook, channel } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 
-const nodeMajor = parseInt(process.versions.node.split('.')[0])
-
 const patched = new WeakSet()
 const instances = new WeakMap()
 
@@ -98,7 +96,7 @@ function wrapMethod (method, path, type, hasPeer) {
   return wrapped
 }
 
-function wrapCallback (ctx, callback = () => { }) {
+function wrapCallback (ctx, callback = () => {}) {
   return shimmer.wrapFunction(callback, callback => function (err) {
     if (err) {
       ctx.error = err
@@ -112,18 +110,18 @@ function wrapCallback (ctx, callback = () => { }) {
   })
 }
 
-function createWrapEmit (ctx, hasPeer = false) {
-  const onStatusWithPeer = function (ctx, arg1, thisArg) {
-    ctx.result = arg1
-    ctx.peer = thisArg.getPeer()
-    finishChannel.publish(ctx)
-  }
+const onStatusWithPeer = function (ctx, arg1, thisArg) {
+  ctx.result = arg1
+  ctx.peer = thisArg.getPeer()
+  finishChannel.publish(ctx)
+}
 
-  const onStatusWithoutPeer = function (ctx, arg1, thisArg) {
-    ctx.result = arg1
-    finishChannel.publish(ctx)
-  }
+const onStatusWithoutPeer = function (ctx, arg1) {
+  ctx.result = arg1
+  finishChannel.publish(ctx)
+}
 
+function createWrapEmit (ctx, hasPeer = false) {
   const onStatus = hasPeer ? onStatusWithPeer : onStatusWithoutPeer
 
   return function wrapEmit (emit) {
@@ -245,16 +243,6 @@ function patch (hasPeer = false) {
   }
 }
 
-if (nodeMajor <= 14) {
-  addHook({ name: 'grpc', versions: ['>=1.24.3'] }, patch(true))
-
-  addHook({ name: 'grpc', versions: ['>=1.24.3'], file: 'src/client.js' }, client => {
-    shimmer.wrap(client, 'makeClientConstructor', createWrapMakeClientConstructor(true))
-
-    return client
-  })
-}
-
 addHook({ name: '@grpc/grpc-js', versions: ['>=1.0.3 <1.1.4'] }, patch(false))
 
 addHook({ name: '@grpc/grpc-js', versions: ['>=1.0.3 <1.1.4'], file: 'build/src/make-client.js' }, client => {

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

@@ -4,8 +4,6 @@ const types = require('./types')
 const { channel, addHook } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 
-const nodeMajor = parseInt(process.versions.node.split('.')[0])
-
 const startChannel = channel('apm:grpc:server:request:start')
 const asyncStartChannel = channel('apm:grpc:server:request:asyncStart')
 const errorChannel = channel('apm:grpc:server:request:error')
@@ -17,17 +15,14 @@ const emitChannel = channel('apm:grpc:server:request:emit')
 const OK = 0
 const CANCELLED = 1
 
-function wrapHandler (func, name) {
-  const isValid = (server, args) => {
-    if (!startChannel.hasSubscribers) return false
-    if (!server || !server.type) return false
-    if (!args[0]) return false
-    if (server.type !== 'unary' && !isEmitter(args[0])) return false
-    if (server.type === 'unary' && typeof args[1] !== 'function') return false
-
-    return true
-  }
+const isValid = (server, args) => {
+  return Boolean(startChannel.hasSubscribers &&
+    server?.type &&
+    args[0] &&
+    (server.type === 'unary' ? typeof args[1] === 'function' : isEmitter(args[0])))
+}
 
+function wrapHandler (func, name) {
   return function (call, callback) {
     if (!isValid(this, arguments)) return func.apply(this, arguments)
 
@@ -152,14 +147,6 @@ function isEmitter (obj) {
   return typeof obj.emit === 'function' && typeof obj.once === 'function'
 }
 
-if (nodeMajor <= 14) {
-  addHook({ name: 'grpc', versions: ['>=1.24.3'], file: 'src/server.js' }, server => {
-    shimmer.wrap(server.Server.prototype, 'register', wrapRegister)
-
-    return server
-  })
-}
-
 addHook({ name: '@grpc/grpc-js', versions: ['>=1.0.3'], file: 'build/src/server.js' }, server => {
   shimmer.wrap(server.Server.prototype, 'register', wrapRegister)
 

package/packages/datadog-instrumentations/src/helpers/extract-package-and-module-path.js

@@ -10,27 +10,33 @@ const NM = 'node_modules/'
  */
 module.exports = function extractPackageAndModulePath (fullPath) {
   const nm = fullPath.lastIndexOf(NM)
-  if (nm < 0) {
+  if (nm === -1) {
     return { pkg: null, path: null }
   }
 
-  const subPath = fullPath.substring(nm + NM.length)
+  const subPath = fullPath.slice(nm + NM.length)
   const firstSlash = subPath.indexOf('/')
 
-  const firstPath = fullPath.substring(fullPath[0], nm + NM.length)
+  const firstPath = fullPath.slice(0, nm + NM.length)
+
+  const firstSlashSubPath = subPath.slice(Math.max(0, firstSlash + 1))
 
   if (subPath[0] === '@') {
-    const secondSlash = subPath.substring(firstSlash + 1).indexOf('/')
+    const secondSlash = firstSlashSubPath.indexOf('/')
+    const pkg = subPath.slice(0, Math.max(0, firstSlash + 1 + secondSlash))
+
     return {
-      pkg: subPath.substring(0, firstSlash + 1 + secondSlash),
-      path: subPath.substring(firstSlash + 1 + secondSlash + 1),
-      pkgJson: firstPath + subPath.substring(0, firstSlash + 1 + secondSlash) + '/package.json'
+      pkg,
+      path: subPath.slice(Math.max(0, firstSlash + 1 + secondSlash + 1)),
+      pkgJson: firstPath + pkg + '/package.json'
     }
   }
 
+  const pkg = subPath.slice(0, Math.max(0, firstSlash))
+
   return {
-    pkg: subPath.substring(0, firstSlash),
-    path: subPath.substring(firstSlash + 1),
-    pkgJson: firstPath + subPath.substring(0, firstSlash) + '/package.json'
+    pkg,
+    path: firstSlashSubPath,
+    pkgJson: firstPath + pkg + '/package.json'
   }
 }

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

@@ -22,7 +22,7 @@ function Hook (modules, hookOptions, onrequire) {
   this._patched = Object.create(null)
 
   const safeHook = (moduleExports, moduleName, moduleBaseDir, moduleVersion) => {
-    const parts = [moduleBaseDir, moduleName].filter(v => v)
+    const parts = [moduleBaseDir, moduleName].filter(Boolean)
     const filename = path.join(...parts)
 
     if (this._patched[filename]) return moduleExports

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

@@ -105,7 +105,6 @@ module.exports = {
   nyc: () => require('../nyc'),
   oracledb: () => require('../oracledb'),
   openai: { esmFirst: true, fn: () => require('../openai') },
-  paperplane: () => require('../paperplane'),
   passport: () => require('../passport'),
   'passport-http': () => require('../passport-http'),
   'passport-local': () => require('../passport-local'),

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

@@ -1,7 +1,6 @@
 'use strict'
 
 const dc = require('dc-polyfill')
-const satisfies = require('semifies')
 const instrumentations = require('./instrumentations')
 const { AsyncResource } = require('async_hooks')
 
@@ -34,43 +33,4 @@ exports.addHook = function addHook ({ name, versions, file, filePattern }, hook)
   }
 }
 
-// AsyncResource.bind exists and binds `this` properly only from 17.8.0 and up.
-// https://nodejs.org/api/async_context.html#asyncresourcebindfn-thisarg
-if (satisfies(process.versions.node, '>=17.8.0')) {
-  exports.AsyncResource = AsyncResource
-} else {
-  exports.AsyncResource = class extends AsyncResource {
-    static bind (fn, type, thisArg) {
-      type = type || fn.name
-      return (new exports.AsyncResource(type || 'bound-anonymous-fn')).bind(fn, thisArg)
-    }
-
-    bind (fn, thisArg) {
-      let bound
-      if (thisArg === undefined) {
-        const resource = this
-        bound = function (...args) {
-          args.unshift(fn, this)
-          return Reflect.apply(resource.runInAsyncScope, resource, args)
-        }
-      } else {
-        bound = this.runInAsyncScope.bind(this, fn, thisArg)
-      }
-      Object.defineProperties(bound, {
-        length: {
-          configurable: true,
-          enumerable: false,
-          value: fn.length,
-          writable: false
-        },
-        asyncResource: {
-          configurable: true,
-          enumerable: true,
-          value: this,
-          writable: true
-        }
-      })
-      return bound
-    }
-  }
-}
+exports.AsyncResource = AsyncResource

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

@@ -26,7 +26,7 @@ const disabledInstrumentations = new Set(
 // Check for DD_TRACE_<INTEGRATION>_ENABLED environment variables
 for (const [key, value] of Object.entries(process.env)) {
   const match = key.match(/^DD_TRACE_(.+)_ENABLED$/)
-  if (match && (value.toLowerCase() === 'false' || value === '0')) {
+  if (match && (value?.toLowerCase() === 'false' || value === '0')) {
     const integration = match[1].toLowerCase()
     disabledInstrumentations.add(integration)
   }
@@ -115,7 +115,7 @@ for (const packageName of names) {
           log.error('Error getting version for "%s": %s', name, e.message, e)
           continue
         }
-        if (namesAndSuccesses[`${name}@${version}`] === undefined) {
+        if (namesAndSuccesses[`${name}@${version}`] === undefined && !file) {
           // TODO If `file` is present, we might elsewhere instrument the result of the module
           // for a version range that actually matches, so we can't assume that we're _not_
           // going to instrument that. However, the way the data model around instrumentation
@@ -123,9 +123,7 @@ for (const packageName of names) {
           // ignore this if there is a `file` in the hook. The thing to do here is rework
           // everything so that we can be sure that there are _no_ instrumentations that it
           // could match.
-          if (!file) {
-            namesAndSuccesses[`${name}@${version}`] = false
-          }
+          namesAndSuccesses[`${name}@${version}`] = false
         }
 
         if (matchVersion(version, versions)) {
@@ -190,7 +188,7 @@ function getVersion (moduleBaseDir) {
 }
 
 function filename (name, file) {
-  return [name, file].filter(val => val).join('/')
+  return [name, file].filter(Boolean).join('/')
 }
 
 // This function captures the instrumentation file name for a given package by parsing the hook require
@@ -217,7 +215,7 @@ function parseHookInstrumentationFileName (packageName) {
     let moduleName = match[1]
     // Remove leading '../' if present
     if (moduleName.startsWith('../')) {
-      moduleName = moduleName.substring(3)
+      moduleName = moduleName.slice(3)
     }
     return moduleName
   }

package/packages/datadog-instrumentations/src/http/client.js

@@ -26,6 +26,19 @@ function hookFn (http) {
   return http
 }
 
+function combineOptions (inputURL, inputOptions) {
+  return inputOptions !== null && typeof inputOptions === 'object'
+    ? Object.assign(inputURL || {}, inputOptions)
+    : inputURL
+}
+function normalizeHeaders (options) {
+  options.headers ??= {}
+}
+
+function normalizeCallback (inputOptions, callback, inputURL) {
+  return typeof inputOptions === 'function' ? [inputOptions, inputURL || {}] : [callback, inputOptions]
+}
+
 function patch (http, methodName) {
   shimmer.wrap(http, methodName, instrumentRequest)
 
@@ -143,30 +156,11 @@ function patch (http, methodName) {
     return { uri, options, callback, originalUrl }
   }
 
-  function combineOptions (inputURL, inputOptions) {
-    if (inputOptions !== null && typeof inputOptions === 'object') {
-      return Object.assign(inputURL || {}, inputOptions)
-    } else {
-      return inputURL
-    }
-  }
-  function normalizeHeaders (options) {
-    options.headers = options.headers || {}
-  }
-
-  function normalizeCallback (inputOptions, callback, inputURL) {
-    if (typeof inputOptions === 'function') {
-      return [inputOptions, inputURL || {}]
-    } else {
-      return [callback, inputOptions]
-    }
-  }
-
   function normalizeOptions (inputURL) {
     if (typeof inputURL === 'string') {
       try {
         return urlToOptions(new url.URL(inputURL))
-      } catch (e) {
+      } catch {
         // eslint-disable-next-line n/no-deprecated-api
         return url.parse(inputURL)
       }