dd-trace 5.52.0 → 5.54.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/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

@@ -61,6 +61,7 @@ module.exports = {
   http2: () => require('../http2'),
   https: () => require('../http'),
   ioredis: () => require('../ioredis'),
+  iovalkey: () => require('../iovalkey'),
   'jest-circus': () => require('../jest'),
   'jest-config': () => require('../jest'),
   'jest-environment-node': () => require('../jest'),
@@ -104,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)
   }
@@ -43,7 +43,7 @@ if (!disabledInstrumentations.has('process')) {
   require('../process')
 }
 
-const HOOK_SYMBOL = Symbol('hookExportsMap')
+const HOOK_SYMBOL = Symbol('hookExportsSet')
 
 if (DD_TRACE_DEBUG && DD_TRACE_DEBUG.toLowerCase() !== 'false') {
   checkRequireCache.checkForRequiredModules()
@@ -89,12 +89,13 @@ for (const packageName of names) {
         fullFilePattern = filename(name, fullFilePattern)
       }
 
-      // Create a WeakMap associated with the hook function so that patches on the same moduleExport only happens once
+      // Create a WeakSet associated with the hook function so that patches on the same moduleExport only happens once
       // for example by instrumenting both dns and node:dns double the spans would be created
-      // since they both patch the same moduleExport, this WeakMap is used to mitigate that
-      if (!hook[HOOK_SYMBOL]) {
-        hook[HOOK_SYMBOL] = new WeakMap()
-      }
+      // since they both patch the same moduleExport, this WeakSet is used to mitigate that
+      // TODO(BridgeAR): Instead of using a WeakSet here, why not just use aliases for the hook in register?
+      // 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
@@ -114,7 +115,7 @@ for (const packageName of names) {
           log.error('Error getting version for "%s": %s', name, e.message, e)
           continue
         }
-        if (typeof 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
@@ -122,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)) {
@@ -140,12 +139,16 @@ for (const packageName of names) {
             loadChannel.publish({ name, version, file })
             // Send the name and version of the module back to the callback because now addHook
             // takes in an array of names so by passing the name the callback will know which module name is being used
-            moduleExports = hook(moduleExports, version, name)
-            // Set the moduleExports in the hooks weakmap
-            hook[HOOK_SYMBOL].set(moduleExports, name)
+            // TODO(BridgeAR): This is only true in case the name is identical
+            // in all loads. If they deviate, the deviating name would not be
+            // picked up due to the unification. Check what modules actually use the name.
+            // TODO(BridgeAR): Only replace moduleExports if the hook returns a new value.
+            // This allows to reduce the instrumentation code (no return needed).
+            moduleExports = hook(moduleExports, version, name) ?? moduleExports
+            // Set the moduleExports in the hooks WeakSet
+            hook[HOOK_SYMBOL].add(moduleExports)
           } catch (e) {
-            log.info('Error during ddtrace instrumentation of application, aborting.')
-            log.info(e)
+            log.info('Error during ddtrace instrumentation of application, aborting.', e)
             telemetry('error', [
               `error_type:${e.constructor.name}`,
               `integration:${name}`,
@@ -185,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
@@ -212,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

@@ -3,6 +3,7 @@
 /* eslint-disable no-fallthrough */
 
 const url = require('url')
+const { errorMonitor } = require('events')
 const { channel, addHook } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 
@@ -25,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)
 
@@ -88,7 +102,7 @@ function patch (http, methodName) {
                 const res = arg
                 ctx.res = res
                 res.on('end', finish)
-                res.on('error', finish)
+                res.on(errorMonitor, finish)
                 break
               }
               case 'connect':
@@ -142,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)
       }

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

@@ -0,0 +1,51 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const startCh = channel('apm:iovalkey:command:start')
+const finishCh = channel('apm:iovalkey:command:finish')
+const errorCh = channel('apm:iovalkey:command:error')
+
+addHook({ name: 'iovalkey', versions: ['>=0.0.1'] }, Valkey => {
+  shimmer.wrap(Valkey.prototype, 'sendCommand', sendCommand => function (command, stream) {
+    if (!startCh.hasSubscribers) return sendCommand.apply(this, arguments)
+
+    if (!command?.promise) return sendCommand.apply(this, arguments)
+
+    const options = this.options || {}
+    const connectionName = options.connectionName
+    const db = options.db
+    const connectionOptions = { host: options.host, port: options.port }
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    return asyncResource.runInAsyncScope(() => {
+      startCh.publish({ db, command: command.name, args: command.args, connectionOptions, connectionName })
+
+      const onResolve = asyncResource.bind(() => finishCh.publish())
+      const onReject = asyncResource.bind(err => finish(finishCh, errorCh, err))
+
+      command.promise.then(onResolve, onReject)
+
+      try {
+        return sendCommand.apply(this, arguments)
+      } catch (err) {
+        errorCh.publish(err)
+
+        throw err
+      }
+    })
+  })
+  return Valkey
+})
+
+function finish (finishCh, errorCh, error) {
+  if (error) {
+    errorCh.publish(error)
+  }
+  finishCh.publish()
+}