dd-trace 2.42.0 → 2.43.0

package/MIGRATING.md

@@ -29,20 +29,6 @@ switching to `jest-circus` to anyone still using `jest-jasmine2`.
 
 We now support only Next.js 10.2 and up.
 
-### W3C headers are now prioritized over Datadog headers
-
-As we move towards open standards, we have decided to prioritize W3C Trace
-Context headers over our own vendor-specific headers for context propagation
-across services. For most applications this shouldn't change anything and
-distributed tracing should continue to work seamlessly.
-
-In some rare cases it's possible that some of the services involved in a trace
-are not instrumented by Datadog at all which can cause spans within the trace to
-become disconnected. While the data would still be available in the UI, the
-relationship between spans would no longer be visible. This can be addressed by
-restoring the previous behaviour using
-`DD_TRACE_PROPAGATION_STYLE='datadog,tracecontext'`.
-
 ## 2.0 to 3.0
 
 ### Node 12 is no longer supported

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "2.42.0",
+  "version": "2.43.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -77,10 +77,10 @@
     "@opentelemetry/core": "<1.4.0",
     "crypto-randomuuid": "^1.0.0",
     "diagnostics_channel": "^1.1.0",
-    "ignore": "^5.2.0",
-    "import-in-the-middle": "^1.3.5",
+    "ignore": "^5.2.4",
+    "import-in-the-middle": "^1.4.1",
     "int64-buffer": "^0.1.9",
-    "ipaddr.js": "^2.0.1",
+    "ipaddr.js": "^2.1.0",
     "istanbul-lib-coverage": "3.2.0",
     "koalas": "^1.0.2",
     "limiter": "^1.1.4",
@@ -92,23 +92,23 @@
     "methods": "^1.1.2",
     "module-details-from-path": "^1.0.3",
     "msgpack-lite": "^0.1.26",
-    "node-abort-controller": "^3.0.1",
+    "node-abort-controller": "^3.1.1",
     "opentracing": ">=0.12.1",
     "path-to-regexp": "^0.1.2",
     "protobufjs": "^7.2.4",
-    "retry": "^0.10.1",
-    "semver": "^7.3.8"
+    "retry": "^0.13.1",
+    "semver": "^7.5.4"
   },
   "devDependencies": {
     "autocannon": "^4.5.2",
     "axios": "^0.21.2",
     "benchmark": "^2.1.4",
-    "body-parser": "^1.18.2",
-    "chai": "^4.2.0",
-    "chalk": "^3.0.0",
-    "checksum": "^0.1.1",
-    "cli-table3": "^0.5.1",
-    "dotenv": "8.2.0",
+    "body-parser": "^1.20.2",
+    "chai": "^4.3.7",
+    "chalk": "^5.3.0",
+    "checksum": "^1.0.0",
+    "cli-table3": "^0.6.3",
+    "dotenv": "16.3.1",
     "esbuild": "0.16.12",
     "eslint": "^8.23.0",
     "eslint-config-standard": "^11.0.0-beta.0",
@@ -117,13 +117,13 @@
     "eslint-plugin-node": "^5.2.1",
     "eslint-plugin-promise": "^3.6.0",
     "eslint-plugin-standard": "^3.0.1",
-    "express": "^4.16.2",
+    "express": "^4.18.2",
     "get-port": "^3.2.0",
     "glob": "^7.1.6",
     "graphql": "0.13.2",
     "jszip": "^3.5.0",
     "knex": "^2.4.2",
-    "mkdirp": "^0.5.1",
+    "mkdirp": "^3.0.1",
     "mocha": "8",
     "multer": "^1.4.5-lts.1",
     "nock": "^11.3.3",
@@ -131,9 +131,9 @@
     "pprof-format": "^2.0.7",
     "proxyquire": "^1.8.0",
     "rimraf": "^3.0.0",
-    "sinon": "^11.1.2",
+    "sinon": "^15.2.0",
     "sinon-chai": "^3.7.0",
-    "tap": "^16.3.4",
-    "tape": "^4.9.1"
+    "tap": "^16.3.7",
+    "tape": "^5.6.5"
   }
 }

package/packages/datadog-esbuild/index.js

@@ -2,73 +2,105 @@
 
 /* eslint-disable no-console */
 
-const NAMESPACE = 'datadog'
-
-const instrumented = Object.keys(require('../datadog-instrumentations/src/helpers/hooks.js'))
-const rawBuiltins = require('module').builtinModules
+const instrumentations = require('../datadog-instrumentations/src/helpers/instrumentations.js')
+const hooks = require('../datadog-instrumentations/src/helpers/hooks.js')
 
 warnIfUnsupported()
 
+for (const hook of Object.values(hooks)) {
+  hook()
+}
+
+const modulesOfInterest = new Set()
+
+for (const instrumentation of Object.values(instrumentations)) {
+  for (const entry of instrumentation) {
+    if (!entry.file) {
+      modulesOfInterest.add(entry.name) // e.g. "redis"
+    } else {
+      modulesOfInterest.add(`${entry.name}/${entry.file}`) // e.g. "redis/my/file.js"
+    }
+  }
+}
+
+const NAMESPACE = 'datadog'
+const NM = 'node_modules/'
+const INSTRUMENTED = Object.keys(instrumentations)
+const RAW_BUILTINS = require('module').builtinModules
+const CHANNEL = 'dd-trace:bundler:load'
+
 const builtins = new Set()
 
-for (const builtin of rawBuiltins) {
+for (const builtin of RAW_BUILTINS) {
   builtins.add(builtin)
   builtins.add(`node:${builtin}`)
 }
 
-const packagesOfInterest = new Set()
-
 const DEBUG = !!process.env.DD_TRACE_DEBUG
 
-// We don't want to handle any built-in packages via DCITM
+// We don't want to handle any built-in packages
 // Those packages will still be handled via RITM
 // Attempting to instrument them would fail as they have no package.json file
-for (const pkg of instrumented) {
+for (const pkg of INSTRUMENTED) {
   if (builtins.has(pkg)) continue
   if (pkg.startsWith('node:')) continue
-  packagesOfInterest.add(pkg)
+  modulesOfInterest.add(pkg)
 }
 
-const DC_CHANNEL = 'dd-trace:bundledModuleLoadStart'
-
 module.exports.name = 'datadog-esbuild'
 
 module.exports.setup = function (build) {
   build.onResolve({ filter: /.*/ }, args => {
+    let fullPathToModule
+    try {
+      fullPathToModule = dotFriendlyResolve(args.path, args.resolveDir)
+    } catch (err) {
+      console.warn(`Unable to find "${args.path}". Is the package dead code?`)
+      return
+    }
+    const extracted = extractPackageAndModulePath(fullPathToModule)
     const packageName = args.path
 
-    if (args.namespace === 'file' && packagesOfInterest.has(packageName)) {
+    const internal = builtins.has(args.path)
+
+    if (args.namespace === 'file' && (
+      modulesOfInterest.has(packageName) || modulesOfInterest.has(`${extracted.pkg}/${extracted.path}`))
+    ) {
       // The file namespace is used when requiring files from disk in userland
 
       let pathToPackageJson
       try {
-        pathToPackageJson = require.resolve(`${packageName}/package.json`, { paths: [ args.resolveDir ] })
+        pathToPackageJson = require.resolve(`${extracted.pkg}/package.json`, { paths: [ args.resolveDir ] })
       } catch (err) {
         if (err.code === 'MODULE_NOT_FOUND') {
-          console.warn(`Unable to open "${packageName}/package.json". Is the "${packageName}" package dead code?`)
+          if (!internal) {
+            console.warn(`Unable to find "${extracted.pkg}/package.json". Is the package dead code?`)
+          }
           return
         } else {
           throw err
         }
       }
 
-      const pkg = require(pathToPackageJson)
+      const packageJson = require(pathToPackageJson)
 
-      if (DEBUG) {
-        console.log(`resolve ${packageName}@${pkg.version}`)
-      }
+      if (DEBUG) console.log(`RESOLVE ${packageName}@${packageJson.version}`)
 
       // https://esbuild.github.io/plugins/#on-resolve-arguments
       return {
-        path: packageName,
+        path: fullPathToModule,
         namespace: NAMESPACE,
         pluginData: {
-          version: pkg.version
+          version: packageJson.version,
+          pkg: extracted.pkg,
+          path: extracted.path,
+          full: fullPathToModule,
+          raw: packageName,
+          internal
         }
       }
-    } else if (args.namespace === 'datadog') {
+    } else if (args.namespace === NAMESPACE) {
       // The datadog namespace is used when requiring files that are injected during the onLoad stage
-      // see note in onLoad
 
       if (builtins.has(packageName)) return
 
@@ -80,23 +112,28 @@ module.exports.setup = function (build) {
   })
 
   build.onLoad({ filter: /.*/, namespace: NAMESPACE }, args => {
-    if (DEBUG) {
-      console.log(`load ${args.path}@${args.pluginData.version}`)
-    }
+    const data = args.pluginData
+
+    if (DEBUG) console.log(`LOAD ${data.pkg}@${data.version}, pkg "${data.path}"`)
+
+    const path = data.raw !== data.pkg
+      ? `${data.pkg}/${data.path}`
+      : data.pkg
 
-    // JSON.stringify adds double quotes. For perf gain could simply add in quotes when we know it's safe.
     const contents = `
       const dc = require('diagnostics_channel');
-      const ch = dc.channel(${JSON.stringify(DC_CHANNEL + ':' + args.path)});
-      const mod = require(${JSON.stringify(args.path)});
+      const ch = dc.channel('${CHANNEL}');
+      const mod = require('${args.path}');
       const payload = {
         module: mod,
-        path: ${JSON.stringify(args.path)},
-        version: ${JSON.stringify(args.pluginData.version)}
+        version: '${data.version}',
+        package: '${data.pkg}',
+        path: '${path}'
       };
       ch.publish(payload);
       module.exports = payload.module;
     `
+
     // https://esbuild.github.io/plugins/#on-load-results
     return {
       contents,
@@ -121,3 +158,44 @@ function warnIfUnsupported () {
     console.error('more recent version is used at runtime, third party packages won\'t be instrumented.')
   }
 }
+
+// @see https://github.com/nodejs/node/issues/47000
+function dotFriendlyResolve (path, directory) {
+  if (path === '.') {
+    path = './'
+  } else if (path === '..') {
+    path = '../'
+  }
+
+  return require.resolve(path, { paths: [ directory ] })
+}
+
+/**
+ * For a given full path to a module,
+ *   return the package name it belongs to and the local path to the module
+ *   input: '/foo/node_modules/@co/stuff/foo/bar/baz.js'
+ *   output: { pkg: '@co/stuff', path: 'foo/bar/baz.js' }
+ */
+function extractPackageAndModulePath (fullPath) {
+  const nm = fullPath.lastIndexOf(NM)
+  if (nm < 0) {
+    return { pkg: null, path: null }
+  }
+
+  const subPath = fullPath.substring(nm + NM.length)
+  const firstSlash = subPath.indexOf('/')
+
+  if (subPath[0] === '@') {
+    const secondSlash = subPath.substring(firstSlash + 1).indexOf('/')
+
+    return {
+      pkg: subPath.substring(0, firstSlash + 1 + secondSlash),
+      path: subPath.substring(firstSlash + 1 + secondSlash + 1)
+    }
+  }
+
+  return {
+    pkg: subPath.substring(0, firstSlash),
+    path: subPath.substring(firstSlash + 1)
+  }
+}

package/packages/datadog-instrumentations/index.js

@@ -1,3 +1,4 @@
 'use strict'
 
+require('./src/helpers/bundler-register')
 require('./src/helpers/register')

package/packages/datadog-instrumentations/src/aws-sdk.js

@@ -177,7 +177,6 @@ addHook({ name: '@aws-sdk/smithy-client', versions: ['>=3'] }, smithy => {
 })
 
 addHook({ name: 'aws-sdk', versions: ['>=2.3.0'] }, AWS => {
-  shimmer.wrap(AWS.Request.prototype, 'promise', wrapRequest)
   shimmer.wrap(AWS.config, 'setPromisesDependency', setPromisesDependency => {
     return function wrappedSetPromisesDependency (dep) {
       const result = setPromisesDependency.apply(this, arguments)
@@ -188,9 +187,14 @@ addHook({ name: 'aws-sdk', versions: ['>=2.3.0'] }, AWS => {
   return AWS
 })
 
+addHook({ name: 'aws-sdk', file: 'lib/core.js', versions: ['>=2.3.0'] }, AWS => {
+  shimmer.wrap(AWS.Request.prototype, 'promise', wrapRequest)
+  return AWS
+})
+
 // <2.1.35 has breaking changes for instrumentation
 // https://github.com/aws/aws-sdk-js/pull/629
-addHook({ name: 'aws-sdk', versions: ['>=2.1.35'] }, AWS => {
+addHook({ name: 'aws-sdk', file: 'lib/core.js', versions: ['>=2.1.35'] }, AWS => {
   shimmer.wrap(AWS.Request.prototype, 'send', wrapRequest)
   return AWS
 })

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

@@ -17,29 +17,32 @@ function wrapFetch (fetch, Request) {
     const headers = req.headers
     const message = { req, headers }
 
-    startChannel.publish(message)
-
-    // Request object is read-only so we need new objects to change headers.
-    arguments[0] = message.req
-    arguments[1] = { headers: message.headers }
-
-    return fetch.apply(this, arguments)
-      .then(
-        res => {
-          finishChannel.publish({ req, res })
-
-          return res
-        },
-        err => {
-          if (err.name !== 'AbortError') {
-            errorChannel.publish(err)
-          }
+    return startChannel.runStores(message, () => {
+      // Request object is read-only so we need new objects to change headers.
+      arguments[0] = message.req
+      arguments[1] = { headers: message.headers }
+
+      return fetch.apply(this, arguments)
+        .then(
+          res => {
+            message.res = res
+
+            finishChannel.publish(message)
 
-          finishChannel.publish({ req })
+            return res
+          },
+          err => {
+            if (err.name !== 'AbortError') {
+              message.error = err
+              errorChannel.publish(message)
+            }
 
-          throw err
-        }
-      )
+            finishChannel.publish(message)
+
+            throw err
+          }
+        )
+    })
   }
 }
 

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

@@ -0,0 +1,54 @@
+'use strict'
+
+// eslint-disable-next-line n/no-restricted-require
+const dc = require('diagnostics_channel')
+
+const {
+  filename,
+  loadChannel,
+  matchVersion
+} = require('./register.js')
+const hooks = require('./hooks')
+const instrumentations = require('./instrumentations')
+const log = require('../../../dd-trace/src/log')
+
+const CHANNEL = 'dd-trace:bundler:load'
+
+if (!dc.subscribe) {
+  dc.subscribe = (channel, cb) => {
+    dc.channel(channel).subscribe(cb)
+  }
+}
+if (!dc.unsubscribe) {
+  dc.unsubscribe = (channel, cb) => {
+    if (dc.channel(channel).hasSubscribers) {
+      dc.channel(channel).unsubscribe(cb)
+    }
+  }
+}
+
+dc.subscribe(CHANNEL, (payload) => {
+  try {
+    hooks[payload.package]()
+  } catch (err) {
+    log.error(`esbuild-wrapped ${payload.package} missing in list of hooks`)
+    throw err
+  }
+
+  if (!instrumentations[payload.package]) {
+    log.error(`esbuild-wrapped ${payload.package} missing in list of instrumentations`)
+    return
+  }
+
+  for (const { name, file, versions, hook } of instrumentations[payload.package]) {
+    if (payload.path !== filename(name, file)) continue
+    if (!matchVersion(payload.version, versions)) continue
+
+    try {
+      loadChannel.publish({ name, version: payload.version, file })
+      payload.module = hook(payload.module, payload.version)
+    } catch (e) {
+      log.error(e)
+    }
+  }
+})

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

@@ -3,10 +3,9 @@
 const path = require('path')
 const iitm = require('../../../dd-trace/src/iitm')
 const ritm = require('../../../dd-trace/src/ritm')
-const dcitm = require('../../../dd-trace/src/dcitm')
 
 /**
- * This is called for every module that dd-trace supports instrumentation for.
+ * This is called for every package/internal-module that dd-trace supports instrumentation for
  * In practice, `modules` is always an array with a single entry.
  *
  * @param {string[]} modules list of modules to hook into
@@ -41,13 +40,11 @@ function Hook (modules, onrequire) {
       return safeHook(moduleExports, moduleName, moduleBaseDir)
     }
   })
-  this._dcitmHook = dcitm(modules, {}, safeHook)
 }
 
 Hook.prototype.unhook = function () {
   this._ritmHook.unhook()
   this._iitmHook.unhook()
-  this._dcitmHook.unhook()
   this._patched = Object.create(null)
 }
 

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

@@ -11,6 +11,8 @@ module.exports = {
   '@hapi/hapi': () => require('../hapi'),
   '@jest/core': () => require('../jest'),
   '@jest/reporters': () => require('../jest'),
+  '@jest/test-sequencer': () => require('../jest'),
+  '@jest/transform': () => require('../jest'),
   '@koa/router': () => require('../koa'),
   '@node-redis/client': () => require('../redis'),
   '@opensearch-project/opensearch': () => require('../opensearch'),
@@ -38,6 +40,7 @@ module.exports = {
   'find-my-way': () => require('../find-my-way'),
   'fs': () => require('../fs'),
   'node:fs': () => require('../fs'),
+  'generic-pool': () => require('../generic-pool'),
   'graphql': () => require('../graphql'),
   'grpc': () => require('../grpc'),
   'hapi': () => require('../hapi'),
@@ -51,6 +54,7 @@ module.exports = {
   'jest-environment-jsdom': () => require('../jest'),
   'jest-jasmine2': () => require('../jest'),
   'jest-worker': () => require('../jest'),
+  'knex': () => require('../knex'),
   'koa': () => require('../koa'),
   'koa-router': () => require('../koa'),
   'kafkajs': () => require('../kafkajs'),

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

@@ -20,7 +20,9 @@ const disabledInstrumentations = new Set(
 const loadChannel = channel('dd-trace:instrumentation:load')
 
 // Globals
-require('../fetch')
+if (!disabledInstrumentations.has('fetch')) {
+  require('../fetch')
+}
 
 // TODO: make this more efficient
 
@@ -30,6 +32,7 @@ for (const packageName of names) {
   Hook([packageName], (moduleExports, moduleName, moduleBaseDir, moduleVersion) => {
     moduleName = moduleName.replace(pathSepExpr, '/')
 
+    // This executes the integration file thus adding its entries to `instrumentations`
     hooks[packageName]()
 
     if (!instrumentations[packageName]) {
@@ -74,5 +77,7 @@ function filename (name, file) {
 
 module.exports = {
   filename,
-  pathSepExpr
+  pathSepExpr,
+  loadChannel,
+  matchVersion
 }

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

@@ -3,18 +3,16 @@
 /* eslint-disable no-fallthrough */
 
 const url = require('url')
-const {
-  channel,
-  addHook,
-  AsyncResource
-} = require('../helpers/instrument')
+const { channel, addHook } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 
 const log = require('../../../dd-trace/src/log')
 
-const startClientCh = channel('apm:http:client:request:start')
-const finishClientCh = channel('apm:http:client:request:finish')
-const errorClientCh = channel('apm:http:client:request:error')
+const startChannel = channel('apm:http:client:request:start')
+const finishChannel = channel('apm:http:client:request:finish')
+const endChannel = channel('apm:http:client:request:end')
+const asyncStartChannel = channel('apm:http:client:request:asyncStart')
+const errorChannel = channel('apm:http:client:request:error')
 
 addHook({ name: 'https' }, hookFn)
 
@@ -32,7 +30,7 @@ function patch (http, methodName) {
 
   function instrumentRequest (request) {
     return function () {
-      if (!startClientCh.hasSubscribers) {
+      if (!startChannel.hasSubscribers) {
         return request.apply(this, arguments)
       }
 
@@ -45,57 +43,68 @@ function patch (http, methodName) {
         return request.apply(this, arguments)
       }
 
-      const callbackResource = new AsyncResource('bound-anonymous-fn')
-      const asyncResource = new AsyncResource('bound-anonymous-fn')
-
-      return asyncResource.runInAsyncScope(() => {
-        startClientCh.publish({ args, http })
+      const ctx = { args, http }
 
+      return startChannel.runStores(ctx, () => {
         let finished = false
         let callback = args.callback
 
         if (callback) {
-          callback = callbackResource.bind(callback)
+          callback = function () {
+            return asyncStartChannel.runStores(ctx, () => {
+              return args.callback.apply(this, arguments)
+            })
+          }
         }
 
         const options = args.options
-        const req = request.call(this, options, callback)
-        const emit = req.emit
-
-        const finish = (req, res) => {
+        const finish = () => {
           if (!finished) {
             finished = true
-            finishClientCh.publish({ req, res })
+            finishChannel.publish(ctx)
           }
         }
 
-        req.emit = function (eventName, arg) {
-          asyncResource.runInAsyncScope(() => {
+        try {
+          const req = request.call(this, options, callback)
+          const emit = req.emit
+
+          ctx.req = req
+
+          req.emit = function (eventName, arg) {
             switch (eventName) {
               case 'response': {
                 const res = arg
-                const listener = asyncResource.bind(() => finish(req, res))
-                res.on('end', listener)
-                res.on('error', listener)
+                ctx.res = res
+                res.on('end', finish)
+                res.on('error', finish)
                 break
               }
               case 'connect':
               case 'upgrade':
-                finish(req, arg)
+                ctx.res = arg
+                finish()
                 break
               case 'error':
               case 'timeout':
-                errorClientCh.publish(arg)
+                ctx.error = arg
+                errorChannel.publish(ctx)
               case 'abort': // deprecated and replaced by `close` in node 17
               case 'close':
-                finish(req)
+                finish()
             }
-          })
 
-          return emit.apply(this, arguments)
-        }
+            return emit.apply(this, arguments)
+          }
 
-        return req
+          return req
+        } catch (e) {
+          ctx.error = e
+          errorChannel.publish(ctx)
+          throw e
+        } finally {
+          endChannel.publish(ctx)
+        }
       })
     }
   }

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

@@ -42,6 +42,7 @@ function createWrapRequest (authority, options) {
         } catch (e) {
           ctx.error = e
           errorChannel.publish(ctx)
+          throw e
         } finally {
           endChannel.publish(ctx)
         }

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

@@ -188,6 +188,31 @@ addHook({
   versions: ['>=24.8.0']
 }, getTestEnvironment)
 
+addHook({
+  name: '@jest/test-sequencer',
+  versions: ['>=24.8.0']
+}, sequencerPackage => {
+  shimmer.wrap(sequencerPackage.default.prototype, 'shard', shard => function () {
+    const shardedTests = shard.apply(this, arguments)
+
+    if (!shardedTests.length) {
+      return shardedTests
+    }
+    // TODO: could we get the rootDir from each test?
+    const [test] = shardedTests
+    const rootDir = test && test.context && test.context.config && test.context.config.rootDir
+
+    const filteredTests = getJestSuitesToRun(skippableSuites, shardedTests, rootDir || process.cwd())
+
+    isSuitesSkipped = filteredTests.length !== shardedTests.length
+
+    skippableSuites = []
+
+    return filteredTests
+  })
+  return sequencerPackage
+})
+
 function cliWrapper (cli, jestVersion) {
   const wrapped = shimmer.wrap(cli, 'runCLI', runCLI => async function () {
     let onDone
@@ -410,6 +435,32 @@ function jestConfigSyncWrapper (jestConfig) {
   return jestConfig
 }
 
+addHook({
+  name: '@jest/transform',
+  versions: ['>=24.8.0'],
+  file: 'build/ScriptTransformer.js'
+}, transformPackage => {
+  const originalCreateScriptTransformer = transformPackage.createScriptTransformer
+
+  transformPackage.createScriptTransformer = async function (config) {
+    const { testEnvironmentOptions, ...restOfConfig } = config
+    const {
+      _ddTestModuleId,
+      _ddTestSessionId,
+      _ddTestCommand,
+      ...restOfTestEnvironmentOptions
+    } = testEnvironmentOptions
+
+    restOfConfig.testEnvironmentOptions = restOfTestEnvironmentOptions
+
+    arguments[0] = restOfConfig
+
+    return originalCreateScriptTransformer.apply(this, arguments)
+  }
+
+  return transformPackage
+})
+
 /**
  * Hook to remove the test paths (test suite) that are part of `skippableSuites`
  */
@@ -425,7 +476,18 @@ addHook({
       return getTestPaths.apply(this, arguments)
     }
 
-    const [{ rootDir }] = arguments
+    const [{ rootDir, shard }] = arguments
+
+    if (shard && shard.shardIndex) {
+      // If the user is using jest sharding, we want to apply the filtering of tests in the shard process.
+      // The reason for this is the following:
+      // The tests for different shards are likely being run in different CI jobs so
+      // the requests to the skippable endpoint might be done at different times and their responses might be different.
+      // If the skippable endpoint is returning different suites and we filter the list of tests here,
+      // the base list of tests that is used for sharding might be different,
+      // causing the shards to potentially run the same suite.
+      return getTestPaths.apply(this, arguments)
+    }
 
     const testPaths = await getTestPaths.apply(this, arguments)
     const { tests } = testPaths

package/packages/datadog-plugin-fetch/src/index.js

@@ -1,35 +1,30 @@
 'use strict'
 
 const HttpClientPlugin = require('../../datadog-plugin-http/src/client')
-const { HTTP_HEADERS } = require('../../../ext/formats')
 
 class FetchPlugin extends HttpClientPlugin {
   static get id () { return 'fetch' }
+  static get prefix () { return `apm:fetch:request` }
 
   addTraceSub (eventName, handler) {
     this.addSub(`apm:${this.constructor.id}:${this.operation}:${eventName}`, handler)
   }
 
-  start (message) {
+  bindStart (message) {
     const req = message.req
     const options = new URL(req.url)
     const headers = options.headers = Object.fromEntries(req.headers.entries())
 
-    const args = { options }
+    options.method = req.method
 
-    super.start({ args })
+    message.args = { options }
 
-    message.req = new globalThis.Request(req, { headers })
-  }
+    const store = super.bindStart(message)
 
-  _inject (span, headers) {
-    const carrier = {}
-
-    this.tracer.inject(span, HTTP_HEADERS, carrier)
+    message.headers = headers
+    message.req = new globalThis.Request(req, { headers })
 
-    for (const name in carrier) {
-      headers.append(name, carrier[name])
-    }
+    return store
   }
 }
 

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

@@ -16,15 +16,11 @@ const HTTP_REQUEST_HEADERS = tags.HTTP_REQUEST_HEADERS
 const HTTP_RESPONSE_HEADERS = tags.HTTP_RESPONSE_HEADERS
 
 class HttpClientPlugin extends ClientPlugin {
-  static get id () {
-    return 'http'
-  }
-
-  addTraceSub (eventName, handler) {
-    this.addSub(`apm:${this.constructor.id}:client:${this.operation}:${eventName}`, handler)
-  }
+  static get id () { return 'http' }
+  static get prefix () { return `apm:http:client:request` }
 
-  start ({ args, http = {} }) {
+  bindStart (message) {
+    const { args, http = {} } = message
     const store = storage.getStore()
     const options = args.options
     const agent = options.agent || options._defaultAgent || http.globalAgent || {}
@@ -55,7 +51,7 @@ class HttpClientPlugin extends ClientPlugin {
       metrics: {
         [CLIENT_PORT_KEY]: parseInt(options.port)
       }
-    })
+    }, false)
 
     // TODO: Figure out a better way to do this for any span.
     if (!allowed) {
@@ -67,11 +63,19 @@ class HttpClientPlugin extends ClientPlugin {
     }
 
     analyticsSampler.sample(span, this.config.measured)
-    this.enter(span, store)
+
+    message.span = span
+    message.parentStore = store
+    message.currentStore = { ...store, span }
+
+    return message.currentStore
   }
 
-  finish ({ req, res }) {
-    const span = storage.getStore().span
+  bindAsyncStart ({ parentStore }) {
+    return parentStore
+  }
+
+  finish ({ req, res, span }) {
     if (res) {
       const status = res.status || res.statusCode
 
@@ -87,17 +91,18 @@ class HttpClientPlugin extends ClientPlugin {
     addRequestHeaders(req, span, this.config)
 
     this.config.hooks.request(span, req, res)
-    super.finish()
-  }
 
-  error (err) {
-    const span = storage.getStore().span
+    this.tagPeerService(span)
+
+    span.finish()
+  }
 
-    if (err) {
+  error ({ span, error }) {
+    if (error) {
       span.addTags({
-        [ERROR_TYPE]: err.name,
-        [ERROR_MESSAGE]: err.message || err.code,
-        [ERROR_STACK]: err.stack
+        [ERROR_TYPE]: error.name,
+        [ERROR_MESSAGE]: error.message || error.code,
+        [ERROR_STACK]: error.stack
       })
     } else {
       span.setTag('error', 1)

package/packages/datadog-plugin-mongodb-core/src/index.js

@@ -57,7 +57,7 @@ function truncate (input) {
 }
 
 function shouldSimplify (input) {
-  return !isObject(input)
+  return !isObject(input) || typeof input.toJSON === 'function'
 }
 
 function shouldHide (input) {

package/packages/dd-trace/src/appsec/iast/analyzers/weak-hash-analyzer.js

@@ -2,6 +2,7 @@
 
 const path = require('path')
 
+const { getNodeModulesPaths } = require('../path-line')
 const Analyzer = require('./vulnerability-analyzer')
 const { WEAK_HASH } = require('../vulnerabilities')
 
@@ -11,13 +12,16 @@ const INSECURE_HASH_ALGORITHMS = new Set([
   'RSA-SHA1', 'RSA-SHA1-2', 'sha1', 'md5-sha1', 'sha1WithRSAEncryption', 'ssl3-sha1'
 ].map(algorithm => algorithm.toLowerCase()))
 
-const EXCLUDED_LOCATIONS = [
-  path.join('node_modules', 'etag', 'index.js'),
-  path.join('node_modules', 'redlock', 'dist', 'cjs'),
-  path.join('node_modules', 'ws', 'lib', 'websocket-server.js'),
-  path.join('node_modules', 'mysql2', 'lib', 'auth_41.js'),
-  path.join('node_modules', '@mikro-orm', 'core', 'utils', 'Utils.js')
-]
+const EXCLUDED_LOCATIONS = getNodeModulesPaths(
+  'etag/index.js',
+  '@mikro-orm/core/utils/Utils.js',
+  'mongodb/lib/core/connection/connection.js',
+  'mysql2/lib/auth_41.js',
+  'pusher/lib/utils.js',
+  'redlock/dist/cjs',
+  'sqreen/lib/package-reader/index.js',
+  'ws/lib/websocket-server.js'
+)
 
 const EXCLUDED_PATHS_FROM_STACK = [
   path.join('node_modules', 'object-hash', path.sep)

package/packages/dd-trace/src/appsec/passport.js

@@ -69,7 +69,7 @@ function parseUser (login, passportUser, mode) {
   if (mode === 'safe') {
     // Remove PII in safe mode
     if (!regexUsername.test(user['usr.id'])) {
-      user['usr.id'] = ' '
+      user['usr.id'] = ''
     }
   }
 

package/packages/dd-trace/src/config.js

@@ -11,6 +11,7 @@ const tagger = require('./tagger')
 const { isTrue, isFalse } = require('./util')
 const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('./plugins/util/tags')
 const { getGitMetadataFromGitProperties } = require('./git_properties')
+const { getIsGCPFunction, getIsAzureFunctionConsumptionPlan } = require('./serverless')
 
 const fromEntries = Object.fromEntries || (entries =>
   entries.reduce((obj, [k, v]) => Object.assign(obj, { [k]: v }), {}))
@@ -186,6 +187,7 @@ class Config {
       process.env.AWS_LAMBDA_FUNCTION_NAME ||
       process.env.FUNCTION_NAME || // Google Cloud Function Name set by deprecated runtimes
       process.env.K_SERVICE || // Google Cloud Function Name set by newer runtimes
+      process.env.WEBSITE_SITE_NAME || // set by Azure Functions
       pkg.name ||
       'node'
     const DD_SERVICE_MAPPING = coalesce(
@@ -224,11 +226,10 @@ class Config {
 
     const inAWSLambda = process.env.AWS_LAMBDA_FUNCTION_NAME !== undefined
 
-    const isDeprecatedGCPFunction = process.env.FUNCTION_NAME !== undefined && process.env.GCP_PROJECT !== undefined
-    const isNewerGCPFunction = process.env.K_SERVICE !== undefined && process.env.FUNCTION_TARGET !== undefined
-    const isGCPFunction = isDeprecatedGCPFunction || isNewerGCPFunction
+    const isGCPFunction = getIsGCPFunction()
+    const isAzureFunctionConsumptionPlan = getIsAzureFunctionConsumptionPlan()
 
-    const inServerlessEnvironment = inAWSLambda || isGCPFunction
+    const inServerlessEnvironment = inAWSLambda || isGCPFunction || isAzureFunctionConsumptionPlan
 
     const DD_TRACE_TELEMETRY_ENABLED = coalesce(
       process.env.DD_TRACE_TELEMETRY_ENABLED,
@@ -359,7 +360,7 @@ class Config {
     const DD_TRACE_STATS_COMPUTATION_ENABLED = coalesce(
       options.stats,
       process.env.DD_TRACE_STATS_COMPUTATION_ENABLED,
-      isGCPFunction
+      isGCPFunction || isAzureFunctionConsumptionPlan
     )
 
     const DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED = coalesce(
@@ -675,6 +676,7 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
     this.traceId128BitLoggingEnabled = isTrue(DD_TRACE_128_BIT_TRACEID_LOGGING_ENABLED)
 
     this.isGCPFunction = isGCPFunction
+    this.isAzureFunctionConsumptionPlan = isAzureFunctionConsumptionPlan
 
     tagger.add(this.tags, {
       service: this.service,

package/packages/dd-trace/src/plugin_manager.js

@@ -135,7 +135,8 @@ module.exports = class PluginManager {
       site,
       url,
       dbmPropagationMode,
-      dsmEnabled
+      dsmEnabled,
+      clientIpEnabled
     } = this._tracerConfig
 
     const sharedConfig = {}
@@ -155,6 +156,10 @@ module.exports = class PluginManager {
       sharedConfig.service = serviceMapping[name]
     }
 
+    if (clientIpEnabled !== undefined) {
+      sharedConfig.clientIpEnabled = clientIpEnabled
+    }
+
     sharedConfig.site = site
     sharedConfig.url = url
 

package/packages/dd-trace/src/plugins/index.js

@@ -10,6 +10,8 @@ module.exports = {
   get '@grpc/grpc-js' () { return require('../../../datadog-plugin-grpc/src') },
   get '@hapi/hapi' () { return require('../../../datadog-plugin-hapi/src') },
   get '@jest/core' () { return require('../../../datadog-plugin-jest/src') },
+  get '@jest/test-sequencer' () { return require('../../../datadog-plugin-jest/src') },
+  get '@jest/transform' () { return require('../../../datadog-plugin-jest/src') },
   get '@koa/router' () { return require('../../../datadog-plugin-koa/src') },
   get '@node-redis/client' () { return require('../../../datadog-plugin-redis/src') },
   get '@opensearch-project/opensearch' () { return require('../../../datadog-plugin-opensearch/src') },

package/packages/dd-trace/src/proxy.js

@@ -30,8 +30,8 @@ class Tracer extends NoopProxy {
         remoteConfig.enable(config)
       }
 
-      if (config.isGCPFunction) {
-        require('./serverless').maybeStartServerlessMiniAgent()
+      if (config.isGCPFunction || config.isAzureFunctionConsumptionPlan) {
+        require('./serverless').maybeStartServerlessMiniAgent(config)
       }
 
       if (config.profiling.enabled) {

package/packages/dd-trace/src/serverless.js

@@ -1,14 +1,19 @@
 'use strict'
 
-function maybeStartServerlessMiniAgent () {
-  let rustBinaryPath =
-    '/workspace/node_modules/@datadog/sma/datadog-serverless-agent-linux-amd64/datadog-serverless-trace-mini-agent'
-  if (process.env.DD_MINI_AGENT_PATH !== undefined) {
-    rustBinaryPath = process.env.DD_MINI_AGENT_PATH
+const log = require('./log')
+
+function maybeStartServerlessMiniAgent (config) {
+  if (process.platform !== 'win32' && process.platform !== 'linux') {
+    log.error(`Serverless Mini Agent is only supported on Windows and Linux.`)
+    return
   }
-  const log = require('./log')
+
+  const rustBinaryPath = getRustBinaryPath(config)
+
   const fs = require('fs')
 
+  log.debug(`Trying to spawn the Serverless Mini Agent at path: ${rustBinaryPath}`)
+
   // trying to spawn with an invalid path will return a non-descriptive error, so we want to catch
   // invalid paths and log our own error.
   if (!fs.existsSync(rustBinaryPath)) {
@@ -22,4 +27,43 @@ function maybeStartServerlessMiniAgent () {
   }
 }
 
-module.exports = { maybeStartServerlessMiniAgent }
+function getRustBinaryPath (config) {
+  if (process.env.DD_MINI_AGENT_PATH !== undefined) {
+    return process.env.DD_MINI_AGENT_PATH
+  }
+
+  const rustBinaryPathRoot = config.isGCPFunction ? '/workspace' : '/home/site/wwwroot'
+  const rustBinaryPathOsFolder = process.platform === 'win32'
+    ? 'datadog-serverless-agent-windows-amd64' : 'datadog-serverless-agent-linux-amd64'
+
+  const rustBinaryExtension = process.platform === 'win32' ? '.exe' : ''
+
+  const rustBinaryPath =
+    `${rustBinaryPathRoot}/node_modules/@datadog/sma/${rustBinaryPathOsFolder}/\
+datadog-serverless-trace-mini-agent${rustBinaryExtension}`
+
+  return rustBinaryPath
+}
+
+function getIsGCPFunction () {
+  const isDeprecatedGCPFunction = process.env.FUNCTION_NAME !== undefined && process.env.GCP_PROJECT !== undefined
+  const isNewerGCPFunction = process.env.K_SERVICE !== undefined && process.env.FUNCTION_TARGET !== undefined
+
+  return isDeprecatedGCPFunction || isNewerGCPFunction
+}
+
+function getIsAzureFunctionConsumptionPlan () {
+  const isAzureFunction =
+    process.env.FUNCTIONS_EXTENSION_VERSION !== undefined && process.env.FUNCTIONS_WORKER_RUNTIME !== undefined
+  const azureWebsiteSKU = process.env.WEBSITE_SKU
+  const isConsumptionPlan = azureWebsiteSKU === undefined || azureWebsiteSKU === 'Dynamic'
+
+  return isAzureFunction && isConsumptionPlan
+}
+
+module.exports = {
+  maybeStartServerlessMiniAgent,
+  getIsGCPFunction,
+  getIsAzureFunctionConsumptionPlan,
+  getRustBinaryPath
+}

package/packages/diagnostics_channel/src/index.js

@@ -64,7 +64,7 @@ if (!Channel.prototype.runStores) {
     this._stores.set(store, transform)
   }
 
-  Channel.prototype.unbindStore = ActiveChannelPrototype.runStores = function (store) {
+  Channel.prototype.unbindStore = ActiveChannelPrototype.unbindStore = function (store) {
     if (!this._stores) return
     this._stores.delete(store)
   }

package/packages/dd-trace/src/dcitm.js

@@ -1,53 +0,0 @@
-'use strict'
-
-// TODO: Figure out why we can't use the internal version.
-// eslint-disable-next-line n/no-restricted-require
-const dc = require('diagnostics_channel')
-
-const CHANNEL_PREFIX = 'dd-trace:bundledModuleLoadStart'
-
-if (!dc.subscribe) {
-  dc.subscribe = (channel, cb) => {
-    dc.channel(channel).subscribe(cb)
-  }
-}
-if (!dc.unsubscribe) {
-  dc.unsubscribe = (channel, cb) => {
-    if (dc.channel(channel).hasSubscribers) {
-      dc.channel(channel).unsubscribe(cb)
-    }
-  }
-}
-
-module.exports = DcitmHook
-
-/**
- * This allows for listening to diagnostic channel events when a module is loaded.
- * Currently it's intended use is for situations like when code runs through a bundler.
- *
- * Unlike RITM and IITM, which have files available on a filesystem at runtime, DCITM
- * requires access to a package's version ahead of time as the package.json file likely
- * won't be available.
- *
- * This function runs many times at startup, once for every module that dd-trace may trace.
- * As it runs on a per-module basis we're creating per-module channels.
- */
-function DcitmHook (moduleNames, options, onrequire) {
-  if (!(this instanceof DcitmHook)) return new DcitmHook(moduleNames, options, onrequire)
-
-  function onModuleLoad (payload) {
-    payload.module = onrequire(payload.module, payload.path, undefined, payload.version)
-  }
-
-  for (const moduleName of moduleNames) {
-    // dc.channel(`${CHANNEL_PREFIX}:${moduleName}`).subscribe(onModuleLoad)
-    dc.subscribe(`${CHANNEL_PREFIX}:${moduleName}`, onModuleLoad)
-  }
-
-  this.unhook = function dcitmUnload () {
-    for (const moduleName of moduleNames) {
-      // dc.channel(`${CHANNEL_PREFIX}:${moduleName}`).unsubscribe(onModuleLoad)
-      dc.unsubscribe(`${CHANNEL_PREFIX}:${moduleName}`, onModuleLoad)
-    }
-  }
-}