dd-trace 5.53.0 → 5.55.0

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/hapi.js

@@ -42,7 +42,10 @@ function wrapExt (ext) {
     if (events !== null && typeof events === 'object') {
       arguments[0] = wrapEvents(events)
     } else {
-      arguments[1] = wrapExtension(method)
+      // The method should never be an array. The check is done as a safe guard
+      // during a refactoring where it was unclear if this would be possible or
+      // not.
+      arguments[1] = Array.isArray(method) ? method.map(wrapHandler) : [wrapHandler(method)]
     }
 
     return ext.apply(this, arguments)
@@ -75,17 +78,13 @@ function wrapRebuild (rebuild) {
   }
 }
 
-function wrapExtension (method) {
-  return [].concat(method).map(wrapHandler)
-}
+function wrapEvents (events, flat = false) {
+  const eventsArray = Array.isArray(events) ? events : [events]
 
-function wrapEvents (events) {
-  return [].concat(events).map(event => {
-    if (!event || !event.method) return event
+  return eventsArray.map(event => {
+    if (!event?.method) return event
 
-    return Object.assign({}, event, {
-      method: wrapExtension(event.method)
-    })
+    return { ...event, method: wrapHandler(event.method) }
   })
 }
 
@@ -93,7 +92,7 @@ function wrapHandler (handler) {
   if (typeof handler !== 'function') return handler
 
   return shimmer.wrapFunction(handler, handler => function (request, h) {
-    const req = request && request.raw && request.raw.req
+    const req = request?.raw?.req
 
     if (!req) return handler.apply(this, arguments)
 

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/fetch.js

@@ -16,12 +16,11 @@ exports.createWrapFetch = function createWrapFetch (Request, ch, onLoad) {
         const ctx = { req: input }
 
         return ch.tracePromise(() => fetch.call(this, input, init), ctx)
-      } else {
-        const req = new Request(input, init)
-        const ctx = { req }
-
-        return ch.tracePromise(() => fetch.call(this, req), ctx)
       }
+      const req = new Request(input, init)
+      const ctx = { req }
+
+      return ch.tracePromise(() => fetch.call(this, req), ctx)
     }
   }
 }

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
@@ -41,9 +41,8 @@ function Hook (modules, hookOptions, onrequire) {
     if (moduleExports && moduleExports.default) {
       moduleExports.default = safeHook(moduleExports.default, moduleName, moduleBaseDir)
       return moduleExports
-    } else {
-      return safeHook(moduleExports, moduleName, moduleBaseDir)
     }
+    return safeHook(moduleExports, moduleName, moduleBaseDir)
   })
 }
 

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

@@ -9,11 +9,14 @@ const log = require('../../../dd-trace/src/log')
 const checkRequireCache = require('./check-require-cache')
 const telemetry = require('../../../dd-trace/src/guardrails/telemetry')
 const { isInServerlessEnvironment } = require('../../../dd-trace/src/serverless')
+const { getEnvironmentVariables } = require('../../../dd-trace/src/config-helper')
+
+const envs = getEnvironmentVariables()
 
 const {
   DD_TRACE_DISABLED_INSTRUMENTATIONS = '',
   DD_TRACE_DEBUG = ''
-} = process.env
+} = envs
 
 const hooks = require('./hooks')
 const instrumentations = require('./instrumentations')
@@ -24,9 +27,9 @@ const disabledInstrumentations = new Set(
 )
 
 // Check for DD_TRACE_<INTEGRATION>_ENABLED environment variables
-for (const [key, value] of Object.entries(process.env)) {
+for (const [key, value] of Object.entries(envs)) {
   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)
   }
@@ -96,9 +99,7 @@ for (const packageName of names) {
       // That way it would also not be duplicated. The actual name being used has to be identified else wise.
       // Maybe it is also not important to know what name was actually used?
       hook[HOOK_SYMBOL] ??= new WeakSet()
-      let matchesFile = false
-
-      matchesFile = moduleName === fullFilename
+      let matchesFile = moduleName === fullFilename
 
       if (fullFilePattern) {
         // Some libraries include a hash in their filenames when installed,
@@ -115,7 +116,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 +124,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 +189,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 +216,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)
       }