dd-trace 6.0.0-pre-5359bfc → 6.0.0-pre-8ec0cfe

package/README.md

@@ -194,38 +194,7 @@ Regardless of where you open the issue, someone at Datadog will try to help.
 
 ## Bundling
 
-Generally, `dd-trace` works by intercepting `require()` calls that a Node.js application makes when loading modules. This includes modules that are built-in to Node.js, like the `fs` module for accessing the filesystem, as well as modules installed from the npm registry, like the `pg` database module.
-
-Also generally, bundlers work by crawling all of the `require()` calls that an application makes to files on disk, replacing the `require()` calls with custom code, and then concatenating all of the resulting JavaScript into one "bundled" file. When a built-in module is loaded, like `require('fs')`, that call can then remain the same in the resulting bundle.
-
-Fundamentally APM tools like `dd-trace` stop working at this point. Perhaps they continue to intercept the calls for built-in modules but don't intercept calls to third party libraries. This means that by default when you bundle a `dd-trace` app with a bundler it is likely to capture information about disk access (via `fs`) and outbound HTTP requests (via `http`), but will otherwise omit calls to third party libraries (like extracting incoming request route information for the `express` framework or showing which query is run for the `mysql` database client).
-
-To get around this, one can treat all third party modules, or at least third party modules that the APM needs to instrument, as being "external" to the bundler. With this setting the instrumented modules remain on disk and continue to be loaded via `require()` while the non-instrumented modules are bundled. Sadly this results in a build with many extraneous files and starts to defeat the purpose of bundling. 
-
-For these reasons it's necessary to have custom-built bundler plugins. Such plugins are able to instruct the bundler on how to behave, injecting intermediary code and otherwise intercepting the "translated" `require()` calls. The result is that many more packages are then included in the bundled JavaScript file. Some applications can have 100% of modules bundled, however native modules still need to remain external to the bundle.
-
-### ESBuild Support
-
-This library provides experimental ESBuild support in the form of an ESBuild plugin. Require the `dd-trace/esbuild` module when building your bundle to enable the plugin.
-
-Here's an example of how one might use `dd-trace` with ESBuild:
-
-```javascript
-const ddPlugin = require('dd-trace/esbuild')
-const esbuild = require('esbuild')
-
-esbuild.build({
-  entryPoints: ['app.js'], 
-  bundle: true,
-  outfile: 'out.js',
-  plugins: [ddPlugin],
-  platform: 'node', // allows built-in modules to be required
-  target: ['node18']
-}).catch((err) => {
-  console.error(err)
-  process.exit(1)
-})
-```
+If you would like to trace your bundled application then please read this page on [bundling and dd-trace](https://docs.datadoghq.com/tracing/trace_collection/automatic_instrumentation/dd_libraries/nodejs/#bundling). It includes information on how to use our ESBuild plugin and includes caveats for other bundlers.
 
 
 ## Security Vulnerabilities

package/index.d.ts

@@ -143,6 +143,11 @@ export declare interface TraceOptions extends Analyzable {
    * The type of request.
    */
   type?: string
+
+  /**
+   * An array of span links
+   */
+  links?: Array<{ context: SpanContext, attributes?: Object }>
 }
 
 /**
@@ -154,6 +159,14 @@ export declare interface TraceOptions extends Analyzable {
  */
 export declare interface Span extends opentracing.Span {
   context (): SpanContext;
+
+  /**
+   * Causally links another span to the current span
+   * @param {SpanContext} context The context of the span to link to.
+   * @param {Object} attributes An optional key value pair of arbitrary values.
+   * @returns {void}
+   */
+  addLink (context: SpanContext, attributes?: Object): void;
 }
 
 /**
@@ -1903,6 +1916,14 @@ export namespace opentelemetry {
      *     use the current time.
      */
     recordException(exception: Exception, time?: TimeInput): void;
+
+    /**
+     * Causally links another span to the current span
+     * @param {otel.SpanContext} context The context of the span to link to.
+     * @param {SpanAttributes} attributes An optional key value pair of arbitrary values.
+     * @returns {void}
+     */
+    addLink (context: otel.SpanContext, attributes?: SpanAttributes): void;
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "6.0.0-pre-5359bfc",
+  "version": "6.0.0-pre-8ec0cfe",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -70,7 +70,7 @@
   },
   "dependencies": {
     "@datadog/native-appsec": "7.0.0",
-    "@datadog/native-iast-rewriter": "2.2.2",
+    "@datadog/native-iast-rewriter": "2.2.3",
     "@datadog/native-iast-taint-tracking": "1.6.4",
     "@datadog/native-metrics": "^2.0.0",
     "@datadog/pprof": "5.0.0",
@@ -78,7 +78,7 @@
     "@opentelemetry/api": "^1.0.0",
     "@opentelemetry/core": "^1.14.0",
     "crypto-randomuuid": "^1.0.0",
-    "dc-polyfill": "^0.1.2",
+    "dc-polyfill": "^0.1.4",
     "ignore": "^5.2.4",
     "import-in-the-middle": "^1.7.3",
     "int64-buffer": "^0.1.9",
@@ -106,7 +106,7 @@
     "@types/node": ">=18",
     "autocannon": "^4.5.2",
     "aws-sdk": "^2.1446.0",
-    "axios": "^0.21.2",
+    "axios": "^1.6.7",
     "benchmark": "^2.1.4",
     "body-parser": "^1.20.2",
     "chai": "^4.3.7",
@@ -130,7 +130,7 @@
     "jszip": "^3.5.0",
     "knex": "^2.4.2",
     "mkdirp": "^3.0.1",
-    "mocha": "8",
+    "mocha": "^9",
     "multer": "^1.4.5-lts.1",
     "nock": "^11.3.3",
     "nyc": "^15.1.0",

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

@@ -19,11 +19,31 @@ function wrapHandle (handle) {
 
 const wrapRouterMethod = createWrapRouterMethod('express')
 
+const responseJsonChannel = channel('datadog:express:response:json:start')
+
+function wrapResponseJson (json) {
+  return function wrappedJson (obj) {
+    if (responseJsonChannel.hasSubscribers) {
+      // backward compat as express 4.x supports deprecated 3.x signature
+      if (arguments.length === 2 && typeof arguments[1] !== 'number') {
+        obj = arguments[1]
+      }
+
+      responseJsonChannel.publish({ req: this.req, body: obj })
+    }
+
+    return json.apply(this, arguments)
+  }
+}
+
 addHook({ name: 'express', versions: ['>=4'] }, express => {
   shimmer.wrap(express.application, 'handle', wrapHandle)
   shimmer.wrap(express.Router, 'use', wrapRouterMethod)
   shimmer.wrap(express.Router, 'route', wrapRouterMethod)
 
+  shimmer.wrap(express.response, 'json', wrapResponseJson)
+  shimmer.wrap(express.response, 'jsonp', wrapResponseJson)
+
   return express
 })
 

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

@@ -15,54 +15,52 @@ const errorChannel = channel('apm:grpc:client:request:error')
 const finishChannel = channel('apm:grpc:client:request:finish')
 const emitChannel = channel('apm:grpc:client:request:emit')
 
-function createWrapMakeRequest (type) {
+function createWrapMakeRequest (type, hasPeer = false) {
   return function wrapMakeRequest (makeRequest) {
     return function (path) {
       const args = ensureMetadata(this, arguments, 4)
 
-      return callMethod(this, makeRequest, args, path, args[4], type)
+      return callMethod(this, makeRequest, args, path, args[4], type, hasPeer)
     }
   }
 }
 
-function createWrapLoadPackageDefinition () {
+function createWrapLoadPackageDefinition (hasPeer = false) {
   return function wrapLoadPackageDefinition (loadPackageDefinition) {
     return function (packageDef) {
       const result = loadPackageDefinition.apply(this, arguments)
 
       if (!result) return result
 
-      wrapPackageDefinition(result)
+      wrapPackageDefinition(result, hasPeer)
 
       return result
     }
   }
 }
 
-function createWrapMakeClientConstructor () {
+function createWrapMakeClientConstructor (hasPeer = false) {
   return function wrapMakeClientConstructor (makeClientConstructor) {
     return function (methods) {
       const ServiceClient = makeClientConstructor.apply(this, arguments)
-
-      wrapClientConstructor(ServiceClient, methods)
-
+      wrapClientConstructor(ServiceClient, methods, hasPeer)
       return ServiceClient
     }
   }
 }
 
-function wrapPackageDefinition (def) {
+function wrapPackageDefinition (def, hasPeer = false) {
   for (const name in def) {
     if (def[name].format) continue
     if (def[name].service && def[name].prototype) {
-      wrapClientConstructor(def[name], def[name].service)
+      wrapClientConstructor(def[name], def[name].service, hasPeer)
     } else {
-      wrapPackageDefinition(def[name])
+      wrapPackageDefinition(def[name], hasPeer)
     }
   }
 }
 
-function wrapClientConstructor (ServiceClient, methods) {
+function wrapClientConstructor (ServiceClient, methods, hasPeer = false) {
   const proto = ServiceClient.prototype
 
   if (typeof methods !== 'object' || 'format' in methods) return
@@ -76,24 +74,23 @@ function wrapClientConstructor (ServiceClient, methods) {
       const type = getType(methods[name])
 
       if (methods[name]) {
-        proto[name] = wrapMethod(proto[name], path, type)
+        proto[name] = wrapMethod(proto[name], path, type, hasPeer)
       }
 
       if (originalName) {
-        proto[originalName] = wrapMethod(proto[originalName], path, type)
+        proto[originalName] = wrapMethod(proto[originalName], path, type, hasPeer)
       }
     })
 }
 
-function wrapMethod (method, path, type) {
+function wrapMethod (method, path, type, hasPeer) {
   if (typeof method !== 'function' || patched.has(method)) {
     return method
   }
 
   const wrapped = function () {
     const args = ensureMetadata(this, arguments, 1)
-
-    return callMethod(this, method, args, path, args[1], type)
+    return callMethod(this, method, args, path, args[1], type, hasPeer)
   }
 
   Object.assign(wrapped, method)
@@ -117,7 +114,20 @@ function wrapCallback (ctx, callback = () => { }) {
   }
 }
 
-function createWrapEmit (ctx) {
+function createWrapEmit (ctx, hasPeer = false) {
+  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 onStatus = hasPeer ? onStatusWithPeer : onStatusWithoutPeer
+
   return function wrapEmit (emit) {
     return function (event, arg1) {
       switch (event) {
@@ -126,8 +136,7 @@ function createWrapEmit (ctx) {
           errorChannel.publish(ctx)
           break
         case 'status':
-          ctx.result = arg1
-          finishChannel.publish(ctx)
+          onStatus(ctx, arg1, this)
           break
       }
 
@@ -138,7 +147,7 @@ function createWrapEmit (ctx) {
   }
 }
 
-function callMethod (client, method, args, path, metadata, type) {
+function callMethod (client, method, args, path, metadata, type, hasPeer = false) {
   if (!startChannel.hasSubscribers) return method.apply(client, args)
 
   const length = args.length
@@ -159,7 +168,7 @@ function callMethod (client, method, args, path, metadata, type) {
       const call = method.apply(client, args)
 
       if (call && typeof call.emit === 'function') {
-        shimmer.wrap(call, 'emit', createWrapEmit(ctx))
+        shimmer.wrap(call, 'emit', createWrapEmit(ctx, hasPeer))
       }
 
       return call
@@ -223,34 +232,45 @@ function getGrpc (client) {
   } while ((proto = Object.getPrototypeOf(proto)))
 }
 
-function patch (grpc) {
-  const proto = grpc.Client.prototype
+function patch (hasPeer = false) {
+  return function patch (grpc) {
+    const proto = grpc.Client.prototype
 
-  instances.set(proto, grpc)
+    instances.set(proto, grpc)
 
-  shimmer.wrap(proto, 'makeBidiStreamRequest', createWrapMakeRequest(types.bidi))
-  shimmer.wrap(proto, 'makeClientStreamRequest', createWrapMakeRequest(types.clientStream))
-  shimmer.wrap(proto, 'makeServerStreamRequest', createWrapMakeRequest(types.serverStream))
-  shimmer.wrap(proto, 'makeUnaryRequest', createWrapMakeRequest(types.unary))
+    shimmer.wrap(proto, 'makeBidiStreamRequest', createWrapMakeRequest(types.bidi, hasPeer))
+    shimmer.wrap(proto, 'makeClientStreamRequest', createWrapMakeRequest(types.clientStream, hasPeer))
+    shimmer.wrap(proto, 'makeServerStreamRequest', createWrapMakeRequest(types.serverStream, hasPeer))
+    shimmer.wrap(proto, 'makeUnaryRequest', createWrapMakeRequest(types.unary, hasPeer))
 
-  return grpc
+    return grpc
+  }
 }
 
 if (nodeMajor <= 14) {
-  addHook({ name: 'grpc', versions: ['>=1.24.3'] }, patch)
+  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())
+    shimmer.wrap(client, 'makeClientConstructor', createWrapMakeClientConstructor(true))
 
     return client
   })
 }
 
-addHook({ name: '@grpc/grpc-js', versions: ['>=1.0.3'] }, patch)
+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 => {
+  shimmer.wrap(client, 'makeClientConstructor', createWrapMakeClientConstructor(false))
+  shimmer.wrap(client, 'loadPackageDefinition', createWrapLoadPackageDefinition(false))
+
+  return client
+})
+
+addHook({ name: '@grpc/grpc-js', versions: ['>=1.1.4'] }, patch(true))
 
-addHook({ name: '@grpc/grpc-js', versions: ['>=1.0.3'], file: 'build/src/make-client.js' }, client => {
-  shimmer.wrap(client, 'makeClientConstructor', createWrapMakeClientConstructor())
-  shimmer.wrap(client, 'loadPackageDefinition', createWrapLoadPackageDefinition())
+addHook({ name: '@grpc/grpc-js', versions: ['>=1.1.4'], file: 'build/src/make-client.js' }, client => {
+  shimmer.wrap(client, 'makeClientConstructor', createWrapMakeClientConstructor(true))
+  shimmer.wrap(client, 'loadPackageDefinition', createWrapLoadPackageDefinition(true))
 
   return client
 })

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

@@ -38,10 +38,12 @@ const testErrCh = channel('ci:jest:test:err')
 
 const skippableSuitesCh = channel('ci:jest:test-suite:skippable')
 const libraryConfigurationCh = channel('ci:jest:library-configuration')
+const knownTestsCh = channel('ci:jest:known-tests')
 
 const itrSkippedSuitesCh = channel('ci:jest:itr:skipped-suites')
 
 let skippableSuites = []
+let knownTests = []
 let isCodeCoverageEnabled = false
 let isSuitesSkippingEnabled = false
 let isUserCodeCoverageEnabled = false
@@ -49,6 +51,11 @@ let isSuitesSkipped = false
 let numSkippedSuites = 0
 let hasUnskippableSuites = false
 let hasForcedToRunSuites = false
+let isEarlyFlakeDetectionEnabled = false
+let earlyFlakeDetectionNumRetries = 0
+
+const EFD_STRING = "Retried by Datadog's Early Flake Detection"
+const EFD_TEST_NAME_REGEX = new RegExp(EFD_STRING + ' \\(#\\d+\\): ', 'g')
 
 const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 
@@ -62,6 +69,7 @@ const specStatusToTestStatus = {
 
 const asyncResources = new WeakMap()
 const originalTestFns = new WeakMap()
+const retriedTestsToNumAttempts = new Map()
 
 // based on https://github.com/facebook/jest/blob/main/packages/jest-circus/src/formatNodeAssertErrors.ts#L41
 function formatJestError (errors) {
@@ -90,6 +98,14 @@ function getTestEnvironmentOptions (config) {
   return {}
 }
 
+function getEfdTestName (testName, numAttempt) {
+  return `${EFD_STRING} (#${numAttempt}): ${testName}`
+}
+
+function removeEfdTestName (testName) {
+  return testName.replace(EFD_TEST_NAME_REGEX, '')
+}
+
 function getWrappedEnvironment (BaseEnvironment, jestVersion) {
   return class DatadogEnvironment extends BaseEnvironment {
     constructor (config, context) {
@@ -101,6 +117,38 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       this.global._ddtrace = global._ddtrace
 
       this.testEnvironmentOptions = getTestEnvironmentOptions(config)
+
+      this.isEarlyFlakeDetectionEnabled = this.testEnvironmentOptions._ddIsEarlyFlakeDetectionEnabled
+
+      if (this.isEarlyFlakeDetectionEnabled) {
+        earlyFlakeDetectionNumRetries = this.testEnvironmentOptions._ddEarlyFlakeDetectionNumRetries
+        try {
+          this.knownTestsForThisSuite = this.getKnownTestsForSuite(this.testEnvironmentOptions._ddKnownTests)
+        } catch (e) {
+          // If there has been an error parsing the tests, we'll disable Early Flake Deteciton
+          this.isEarlyFlakeDetectionEnabled = false
+        }
+      }
+    }
+
+    // Function that receives a list of known tests for a test service and
+    // returns the ones that belong to the current suite
+    getKnownTestsForSuite (knownTests) {
+      let knownTestsForSuite = knownTests
+      // If jest runs in band, the known tests are not serialized, so they're an array.
+      if (!Array.isArray(knownTests)) {
+        knownTestsForSuite = JSON.parse(knownTestsForSuite)
+      }
+      return knownTestsForSuite
+        .filter(test => test.includes(this.testSuite))
+        .map(test => test.replace(`jest.${this.testSuite}.`, '').trim())
+    }
+
+    // Add the `add_test` event we don't have the test object yet, so
+    // we use its describe block to get the full name
+    getTestNameFromAddTestEvent (event, state) {
+      const describeSuffix = getJestTestName(state.currentDescribeBlock)
+      return removeEfdTestName(`${describeSuffix} ${event.testName}`).trim()
     }
 
     async handleTestEvent (event, state) {
@@ -124,23 +172,55 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         }
       }
       if (event.name === 'test_start') {
+        let isNewTest = false
+        let numEfdRetry = null
         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)
+
+        if (this.isEarlyFlakeDetectionEnabled) {
+          const originalTestName = removeEfdTestName(testName)
+          isNewTest = retriedTestsToNumAttempts.has(originalTestName)
+          if (isNewTest) {
+            numEfdRetry = retriedTestsToNumAttempts.get(originalTestName)
+            retriedTestsToNumAttempts.set(originalTestName, numEfdRetry + 1)
+          }
+        }
+
         asyncResource.runInAsyncScope(() => {
           testStartCh.publish({
-            name: getJestTestName(event.test),
+            name: removeEfdTestName(testName),
             suite: this.testSuite,
             runner: 'jest-circus',
             testParameters,
-            frameworkVersion: jestVersion
+            frameworkVersion: jestVersion,
+            isNew: isNewTest,
+            isEfdRetry: numEfdRetry > 0
           })
           originalTestFns.set(event.test, event.test.fn)
           event.test.fn = asyncResource.bind(event.test.fn)
         })
       }
+      if (event.name === 'add_test') {
+        if (this.isEarlyFlakeDetectionEnabled) {
+          const testName = this.getTestNameFromAddTestEvent(event, state)
+          const isNew = !this.knownTestsForThisSuite?.includes(testName)
+          const isSkipped = event.mode === 'todo' || event.mode === 'skip'
+          if (isNew && !isSkipped && !retriedTestsToNumAttempts.has(testName)) {
+            retriedTestsToNumAttempts.set(testName, 0)
+            for (let retryIndex = 0; retryIndex < earlyFlakeDetectionNumRetries; retryIndex++) {
+              if (this.global.test) {
+                this.global.test(getEfdTestName(event.testName, retryIndex), event.fn, event.timeout)
+              } else {
+                log.error('Early flake detection could not retry test because global.test is undefined')
+              }
+            }
+          }
+        }
+      }
       if (event.name === 'test_done') {
         const asyncResource = asyncResources.get(event.test)
         asyncResource.runInAsyncScope(() => {
@@ -206,7 +286,7 @@ addHook({
     }
     // 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 rootDir = test?.context?.config?.rootDir
 
     const jestSuitesToRun = getJestSuitesToRun(skippableSuites, shardedTests, rootDir || process.cwd())
 
@@ -247,11 +327,32 @@ function cliWrapper (cli, jestVersion) {
       if (!err) {
         isCodeCoverageEnabled = libraryConfig.isCodeCoverageEnabled
         isSuitesSkippingEnabled = libraryConfig.isSuitesSkippingEnabled
+        isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
+        earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
       }
     } catch (err) {
       log.error(err)
     }
 
+    if (isEarlyFlakeDetectionEnabled) {
+      const knownTestsPromise = new Promise((resolve) => {
+        onDone = resolve
+      })
+
+      sessionAsyncResource.runInAsyncScope(() => {
+        knownTestsCh.publish({ onDone })
+      })
+
+      try {
+        const { err, knownTests: receivedKnownTests } = await knownTestsPromise
+        if (!err) {
+          knownTests = receivedKnownTests
+        }
+      } catch (err) {
+        log.error(err)
+      }
+    }
+
     if (isSuitesSkippingEnabled) {
       const skippableSuitesPromise = new Promise((resolve) => {
         onDone = resolve
@@ -322,7 +423,8 @@ function cliWrapper (cli, jestVersion) {
         numSkippedSuites,
         hasUnskippableSuites,
         hasForcedToRunSuites,
-        error
+        error,
+        isEarlyFlakeDetectionEnabled
       })
     })
 
@@ -438,6 +540,7 @@ function configureTestEnvironment (readConfigsResult) {
   // because `jestAdapterWrapper` runs in a different process. We have to go through `testEnvironmentOptions`
   configs.forEach(config => {
     config.testEnvironmentOptions._ddTestCodeCoverageEnabled = isCodeCoverageEnabled
+    config.testEnvironmentOptions._ddKnownTests = knownTests
   })
 
   isUserCodeCoverageEnabled = !!readConfigsResult.globalConfig.collectCoverage
@@ -498,6 +601,9 @@ addHook({
       _ddForcedToRun,
       _ddUnskippable,
       _ddItrCorrelationId,
+      _ddKnownTests,
+      _ddIsEarlyFlakeDetectionEnabled,
+      _ddEarlyFlakeDetectionNumRetries,
       ...restOfTestEnvironmentOptions
     } = testEnvironmentOptions
 

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

@@ -290,9 +290,23 @@ addHook({
   shimmer.massWrap(request.NextRequest.prototype, ['text', 'json'], function (originalMethod) {
     return async function wrappedJson () {
       const body = await originalMethod.apply(this, arguments)
-      bodyParsedChannel.publish({
-        body
-      })
+
+      bodyParsedChannel.publish({ body })
+
+      return body
+    }
+  })
+
+  shimmer.wrap(request.NextRequest.prototype, 'formData', function (originalFormData) {
+    return async function wrappedFormData () {
+      const body = await originalFormData.apply(this, arguments)
+
+      let normalizedBody = body
+      if (typeof body.entries === 'function') {
+        normalizedBody = Object.fromEntries(body.entries())
+      }
+      bodyParsedChannel.publish({ body: normalizedBody })
+
       return body
     }
   })

package/packages/datadog-plugin-cypress/src/plugin.js

@@ -45,7 +45,8 @@ const {
   GIT_REPOSITORY_URL,
   GIT_COMMIT_SHA,
   GIT_BRANCH,
-  CI_PROVIDER_NAME
+  CI_PROVIDER_NAME,
+  CI_WORKSPACE_PATH
 } = require('../../dd-trace/src/plugins/util/tags')
 const {
   OS_VERSION,
@@ -186,7 +187,8 @@ module.exports = (on, config) => {
     [RUNTIME_NAME]: runtimeName,
     [RUNTIME_VERSION]: runtimeVersion,
     [GIT_BRANCH]: branch,
-    [CI_PROVIDER_NAME]: ciProviderName
+    [CI_PROVIDER_NAME]: ciProviderName,
+    [CI_WORKSPACE_PATH]: repositoryRoot
   } = testEnvironmentMetadata
 
   const isUnsupportedCIProvider = !ciProviderName
@@ -205,7 +207,7 @@ module.exports = (on, config) => {
     testLevel: 'test'
   }
 
-  const codeOwnersEntries = getCodeOwnersFileEntries()
+  const codeOwnersEntries = getCodeOwnersFileEntries(repositoryRoot)
 
   let activeSpan = null
   let testSessionSpan = null

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

@@ -41,7 +41,6 @@ class GrpcClientPlugin extends ClientPlugin {
         'grpc.status.code': 0
       }
     }, false)
-
     // needed as precursor for peer.service
     if (method.service && method.package) {
       span.setTag('rpc.service', method.package + '.' + method.service)
@@ -68,7 +67,7 @@ class GrpcClientPlugin extends ClientPlugin {
     this.addError(error, span)
   }
 
-  finish ({ span, result }) {
+  finish ({ span, result, peer }) {
     if (!span) return
 
     const { code, metadata } = result || {}
@@ -80,6 +79,21 @@ class GrpcClientPlugin extends ClientPlugin {
       addMetadataTags(span, metadata, metadataFilter, 'response')
     }
 
+    if (peer) {
+      // The only scheme we want to support here is ipv[46]:port, although
+      // more are supported by the library
+      // https://github.com/grpc/grpc/blob/v1.60.0/doc/naming.md
+      const parts = peer.split(':')
+      if (parts[parts.length - 1].match(/^\d+/)) {
+        const port = parts[parts.length - 1]
+        const ip = parts.slice(0, -1).join(':')
+        span.setTag('network.destination.ip', ip)
+        span.setTag('network.destination.port', port)
+      } else {
+        span.setTag('network.destination.ip', peer)
+      }
+    }
+
     this.tagPeerService(span)
     span.finish()
   }

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

@@ -122,7 +122,7 @@ class HttpClientPlugin extends ClientPlugin {
       // conditions for no error:
       // 1. not using a custom agent instance with custom timeout specified
       // 2. no invocation of `req.setTimeout`
-      if (!args.options.agent?.options.timeout && !customRequestTimeout) return
+      if (!args.options.agent?.options?.timeout && !customRequestTimeout) return
 
       span.setTag('error', 1)
     }