dd-trace 5.51.0 → 5.53.0

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

@@ -149,11 +149,9 @@ addHook({ name: 'express', versions: ['>=4.3.0 <5.0.0'] }, express => {
 const queryReadCh = channel('datadog:express:query:finish')
 
 addHook({ name: 'express', file: ['lib/request.js'], versions: ['>=5.0.0'] }, request => {
-  const requestDescriptor = Object.getOwnPropertyDescriptor(request, 'query')
-
-  shimmer.wrap(requestDescriptor, 'get', function (originalGet) {
+  shimmer.wrap(request, 'query', function (originalGet) {
     return function wrappedGet () {
-      const query = originalGet.apply(this, arguments)
+      const query = originalGet.call(this)
 
       if (queryReadCh.hasSubscribers && query) {
         queryReadCh.publish({ query })
@@ -163,7 +161,5 @@ addHook({ name: 'express', file: ['lib/request.js'], versions: ['>=5.0.0'] }, re
     }
   })
 
-  Object.defineProperty(request, 'query', requestDescriptor)
-
   return request
 })

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

@@ -1,10 +1,7 @@
 'use strict'
 
-const {
-  channel,
-  addHook,
-  AsyncResource
-} = require('./helpers/instrument')
+const { errorMonitor } = require('events')
+const { channel, addHook } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
 const startChannel = channel('apm:fs:operation:start')
@@ -191,35 +188,34 @@ function wrapCreateStream (original) {
   return function (path, options) {
     if (!startChannel.hasSubscribers) return original.apply(this, arguments)
 
-    const innerResource = new AsyncResource('bound-anonymous-fn')
-    const message = getMessage(name, ['path', 'options'], arguments)
-
-    return innerResource.runInAsyncScope(() => {
-      startChannel.publish(message)
+    const ctx = getMessage(name, ['path', 'options'], arguments)
 
+    return startChannel.runStores(ctx, () => {
       try {
         const stream = original.apply(this, arguments)
-        const onError = innerResource.bind(error => {
-          errorChannel.publish(error)
+        const onError = error => {
+          ctx.error = error
+          errorChannel.publish(ctx)
           onFinish()
-        })
-        const onFinish = innerResource.bind(() => {
-          finishChannel.publish()
-          stream.off('close', onFinish)
-          stream.off('end', onFinish)
-          stream.off('finish', onFinish)
-          stream.off('error', onError)
-        })
+        }
+        const onFinish = () => {
+          finishChannel.runStores(ctx, () => {})
+          stream.removeListener('close', onFinish)
+          stream.removeListener('end', onFinish)
+          stream.removeListener('finish', onFinish)
+          stream.removeListener(errorMonitor, onError)
+        }
 
         stream.once('close', onFinish)
         stream.once('end', onFinish)
         stream.once('finish', onFinish)
-        stream.once('error', onError)
+        stream.once(errorMonitor, onError)
 
         return stream
       } catch (error) {
-        errorChannel.publish(error)
-        finishChannel.publish()
+        ctx.error = error
+        errorChannel.publish(ctx)
+        finishChannel.runStores(ctx, () => {})
       }
     })
   }
@@ -239,17 +235,16 @@ function createWatchWrapFunction (override = '') {
     const operation = name
     return function () {
       if (!startChannel.hasSubscribers) return original.apply(this, arguments)
-      const message = getMessage(method, watchMethods[operation], arguments, this)
-      const innerResource = new AsyncResource('bound-anonymous-fn')
-      return innerResource.runInAsyncScope(() => {
-        startChannel.publish(message)
+      const ctx = getMessage(method, watchMethods[operation], arguments, this)
+      return startChannel.runStores(ctx, () => {
         try {
           const result = original.apply(this, arguments)
-          finishChannel.publish()
+          finishChannel.runStores(ctx, () => {})
           return result
         } catch (error) {
-          errorChannel.publish(error)
-          finishChannel.publish()
+          ctx.error = error
+          errorChannel.publish(ctx)
+          finishChannel.runStores(ctx, () => {})
           throw error
         }
       })
@@ -268,30 +263,25 @@ function createWrapFunction (prefix = '', override = '') {
 
       const lastIndex = arguments.length - 1
       const cb = typeof arguments[lastIndex] === 'function' && arguments[lastIndex]
-      const innerResource = new AsyncResource('bound-anonymous-fn')
       const params = getMethodParamsRelationByPrefix(prefix)[operation]
       const abortController = new AbortController()
-      const message = { ...getMessage(method, params, arguments, this), abortController }
+      const ctx = { ...getMessage(method, params, arguments, this), abortController }
 
-      const finish = innerResource.bind(function (error) {
+      const finish = function (error, cb = () => {}) {
         if (error !== null && typeof error === 'object') { // fs.exists receives a boolean
-          errorChannel.publish(error)
+          ctx.error = error
+          errorChannel.publish(ctx)
         }
-        finishChannel.publish()
-      })
+        return finishChannel.runStores(ctx, cb)
+      }
 
       if (cb) {
-        const outerResource = new AsyncResource('bound-anonymous-fn')
-
-        arguments[lastIndex] = shimmer.wrapFunction(cb, cb => innerResource.bind(function (e) {
-          finish(e)
-          return outerResource.runInAsyncScope(() => cb.apply(this, arguments))
-        }))
+        arguments[lastIndex] = shimmer.wrapFunction(cb, cb => function (e) {
+          return finish(e, () => cb.apply(this, arguments))
+        })
       }
 
-      return innerResource.runInAsyncScope(() => {
-        startChannel.publish(message)
-
+      return startChannel.runStores(ctx, () => {
         if (abortController.signal.aborted) {
           const error = abortController.signal.reason || new Error('Aborted')
 
@@ -318,23 +308,25 @@ function createWrapFunction (prefix = '', override = '') {
                 if (isFirstMethodReturningFileHandle(original)) {
                   wrapFileHandle(value)
                 }
-                finishChannel.publish()
+                finishChannel.runStores(ctx, () => {})
                 return value
               },
               error => {
-                errorChannel.publish(error)
-                finishChannel.publish()
+                ctx.error = error
+                errorChannel.publish(ctx)
+                finishChannel.runStores(ctx, () => {})
                 throw error
               }
             )
           }
 
-          finishChannel.publish()
+          finishChannel.runStores(ctx, () => {})
 
           return result
         } catch (error) {
-          errorChannel.publish(error)
-          finishChannel.publish()
+          ctx.error = error
+          errorChannel.publish(ctx)
+          finishChannel.runStores(ctx, () => {})
           throw error
         }
       })

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'),
@@ -70,6 +71,7 @@ module.exports = {
   knex: () => require('../knex'),
   koa: () => require('../koa'),
   'koa-router': () => require('../koa'),
+  '@confluentinc/kafka-javascript': () => require('../confluentinc-kafka-javascript'),
   kafkajs: () => require('../kafkajs'),
   langchain: () => require('../langchain'),
   ldapjs: () => require('../ldapjs'),

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

@@ -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) {
           // 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
@@ -140,12 +141,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}`,

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')
 
@@ -88,7 +89,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':

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()
+}

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

@@ -41,6 +41,7 @@ const testStartCh = channel('ci:jest:test:start')
 const testSkippedCh = channel('ci:jest:test:skip')
 const testFinishCh = channel('ci:jest:test:finish')
 const testErrCh = channel('ci:jest:test:err')
+const testFnCh = channel('ci:jest:test:fn')
 
 const skippableSuitesCh = channel('ci:jest:test-suite:skippable')
 const libraryConfigurationCh = channel('ci:jest:library-configuration')
@@ -79,7 +80,7 @@ let testManagementAttemptToFixRetries = 0
 
 const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 
-const asyncResources = new WeakMap()
+const testContexts = new WeakMap()
 const originalTestFns = new WeakMap()
 const originalHookFns = new WeakMap()
 const retriedTestsToNumAttempts = new Map()
@@ -307,8 +308,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         const testParameters = getTestParametersString(this.nameToParams, event.test.name)
         // Async resource for this test is created here
         // It is used later on by the test_done handler
-        const asyncResource = new AsyncResource('bound-anonymous-fn')
-        asyncResources.set(event.test, asyncResource)
         const testName = getJestTestName(event.test)
         const originalTestName = removeEfdStringFromTestName(removeAttemptToFixStringFromTestName(testName))
 
@@ -336,22 +335,24 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         }
 
         const isJestRetry = event.test?.invocations > 1
-        asyncResource.runInAsyncScope(() => {
-          testStartCh.publish({
-            name: originalTestName,
-            suite: this.testSuite,
-            testSourceFile: this.testSourceFile,
-            displayName: this.displayName,
-            testParameters,
-            frameworkVersion: jestVersion,
-            isNew: isNewTest,
-            isEfdRetry: numEfdRetry > 0,
-            isAttemptToFix,
-            isAttemptToFixRetry: numOfAttemptsToFixRetries > 0,
-            isJestRetry,
-            isDisabled,
-            isQuarantined
-          })
+        const ctx = {
+          name: originalTestName,
+          suite: this.testSuite,
+          testSourceFile: this.testSourceFile,
+          displayName: this.displayName,
+          testParameters,
+          frameworkVersion: jestVersion,
+          isNew: isNewTest,
+          isEfdRetry: numEfdRetry > 0,
+          isAttemptToFix,
+          isAttemptToFixRetry: numOfAttemptsToFixRetries > 0,
+          isJestRetry,
+          isDisabled,
+          isQuarantined
+        }
+        testContexts.set(event.test, ctx)
+
+        testStartCh.runStores(ctx, () => {
           for (const hook of event.test.parent.hooks) {
             let hookFn = hook.fn
             if (!originalHookFns.has(hook)) {
@@ -359,10 +360,21 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             } else {
               hookFn = originalHookFns.get(hook)
             }
-            hook.fn = asyncResource.bind(hookFn)
+            const wrapperHook = function () {
+              return testFnCh.runStores(ctx, () => hookFn.apply(this, arguments))
+            }
+            // If we don't do this, the timeout will be not be triggered
+            Object.defineProperty(wrapperHook, 'length', { value: hookFn.length })
+            hook.fn = wrapperHook
           }
-          originalTestFns.set(event.test, event.test.fn)
-          event.test.fn = asyncResource.bind(event.test.fn)
+          const originalFn = event.test.fn
+          originalTestFns.set(event.test, originalFn)
+          const wrapper = function () {
+            return testFnCh.runStores(ctx, () => originalFn.apply(this, arguments))
+          }
+          // If we don't do this, the timeout will be not be triggered
+          Object.defineProperty(wrapper, 'length', { value: originalFn.length })
+          event.test.fn = wrapper
         })
       }
 
@@ -408,6 +420,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         event.test.fn = originalTestFns.get(event.test)
 
         let attemptToFixPassed = false
+        let attemptToFixFailed = false
         let failedAllTests = false
         let isAttemptToFix = false
         if (this.isTestManagementTestsEnabled) {
@@ -425,6 +438,9 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             // If it is, we'll set the failedAllTests flag to true if all the tests failed
             // If all tests passed, we'll set the attemptToFixPassed flag to true
             if (testStatuses.length === testManagementAttemptToFixRetries + 1) {
+              if (testStatuses.some(status => status === 'fail')) {
+                attemptToFixFailed = true
+              }
               if (testStatuses.every(status => status === 'fail')) {
                 failedAllTests = true
               } else if (testStatuses.every(status => status === 'pass')) {
@@ -456,16 +472,15 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         const willBeRetried = numRetries > 0 && numTestExecutions - 1 < numRetries
         const mightHitBreakpoint = this.isDiEnabled && numTestExecutions >= 2
 
-        const asyncResource = asyncResources.get(event.test)
+        const ctx = testContexts.get(event.test)
 
         if (status === 'fail') {
           const shouldSetProbe = this.isDiEnabled && willBeRetried && numTestExecutions === 1
-          asyncResource.runInAsyncScope(() => {
-            testErrCh.publish({
-              error: formatJestError(event.test.errors[0]),
-              shouldSetProbe,
-              promises
-            })
+          testErrCh.publish({
+            ...ctx.currentStore,
+            error: formatJestError(event.test.errors[0]),
+            shouldSetProbe,
+            promises
           })
         }
 
@@ -484,14 +499,14 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           isAtrRetry = true
         }
 
-        asyncResource.runInAsyncScope(() => {
-          testFinishCh.publish({
-            status,
-            testStartLine: getTestLineStart(event.test.asyncError, this.testSuite),
-            attemptToFixPassed,
-            failedAllTests,
-            isAtrRetry
-          })
+        testFinishCh.publish({
+          ...ctx.currentStore,
+          status,
+          testStartLine: getTestLineStart(event.test.asyncError, this.testSuite),
+          attemptToFixPassed,
+          failedAllTests,
+          attemptToFixFailed,
+          isAtrRetry
         })
 
         if (promises.isProbeReady) {
@@ -620,7 +635,7 @@ addHook({
 })
 
 function cliWrapper (cli, jestVersion) {
-  const wrapped = shimmer.wrap(cli, 'runCLI', runCLI => async function () {
+  shimmer.wrap(cli, 'runCLI', runCLI => async function () {
     let onDone
     const configurationPromise = new Promise((resolve) => {
       onDone = resolve
@@ -859,8 +874,6 @@ function cliWrapper (cli, jestVersion) {
     return result
   })
 
-  cli.runCLI = wrapped.runCLI
-
   return cli
 }
 

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

@@ -7,6 +7,8 @@ const {
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
+const log = require('../../dd-trace/src/log')
+
 const producerStartCh = channel('apm:kafkajs:produce:start')
 const producerCommitCh = channel('apm:kafkajs:produce:commit')
 const producerFinishCh = channel('apm:kafkajs:produce:finish')
@@ -21,6 +23,8 @@ const batchConsumerStartCh = channel('apm:kafkajs:consume-batch:start')
 const batchConsumerFinishCh = channel('apm:kafkajs:consume-batch:finish')
 const batchConsumerErrorCh = channel('apm:kafkajs:consume-batch:error')
 
+const disabledHeaderWeakSet = new WeakSet()
+
 function commitsFromEvent (event) {
   const { payload: { groupId, topics } } = event
   const commitList = []
@@ -65,15 +69,14 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
 
           try {
             const { topic, messages = [] } = arguments[0]
-            for (const message of messages) {
-              if (message !== null && typeof message === 'object') {
-                message.headers = message.headers || {}
-              }
-            }
-            producerStartCh.publish({ topic, messages, bootstrapServers, clusterId })
-
+            producerStartCh.publish({
+              topic,
+              messages,
+              bootstrapServers,
+              clusterId,
+              disableHeaderInjection: disabledHeaderWeakSet.has(producer)
+            })
             const result = send.apply(this, arguments)
-
             result.then(
               innerAsyncResource.bind(res => {
                 producerFinishCh.publish(undefined)
@@ -81,6 +84,16 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
               }),
               innerAsyncResource.bind(err => {
                 if (err) {
+                  // Fixes bug where we would inject message headers for kafka brokers that don't support headers
+                  // (version <0.11). On the error, we disable header injection.
+                  // Tnfortunately the error name / type is not more specific.
+                  // This approach is implemented by other tracers as well.
+                  if (err.name === 'KafkaJSProtocolError' && err.type === 'UNKNOWN') {
+                    disabledHeaderWeakSet.add(producer)
+                    log.error('Kafka Broker responded with UNKNOWN_SERVER_ERROR (-1). ' +
+                      'Please look at broker logs for more information. ' +
+                      'Tracer message header injection for Kafka is disabled.')
+                  }
                   producerErrorCh.publish(err)
                 }
                 producerFinishCh.publish(undefined)