dd-trace 4.18.0 → 5.6.0

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

@@ -16,7 +16,8 @@ const testSuiteStartCh = channel('ci:cucumber:test-suite:start')
 const testSuiteFinishCh = channel('ci:cucumber:test-suite:finish')
 const testSuiteCodeCoverageCh = channel('ci:cucumber:test-suite:code-coverage')
 
-const itrConfigurationCh = channel('ci:cucumber:itr-configuration')
+const libraryConfigurationCh = channel('ci:cucumber:library-configuration')
+const knownTestsCh = channel('ci:cucumber:known-tests')
 const skippableSuitesCh = channel('ci:cucumber:test-suite:skippable')
 const sessionStartCh = channel('ci:cucumber:session:start')
 const sessionFinishCh = channel('ci:cucumber:session:finish')
@@ -41,11 +42,18 @@ const originalCoverageMap = createCoverageMap()
 // TODO: remove in a later major version
 const patched = new WeakSet()
 
+const lastStatusByPickleId = new Map()
+const numRetriesByPickleId = new Map()
+
 let pickleByFile = {}
 const pickleResultByFile = {}
 let skippableSuites = []
+let itrCorrelationId = ''
 let isForcedToRun = false
 let isUnskippable = false
+let isEarlyFlakeDetectionEnabled = false
+let earlyFlakeDetectionNumRetries = 0
+let knownTests = []
 
 function getSuiteStatusFromTestStatuses (testStatuses) {
   if (testStatuses.some(status => status === 'fail')) {
@@ -83,6 +91,21 @@ function getStatusFromResultLatest (result) {
   return { status: 'fail', errorMessage: result.message }
 }
 
+function isNewTest (testSuite, testName) {
+  const testsForSuite = knownTests.cucumber?.[testSuite] || []
+  return !testsForSuite.includes(testName)
+}
+
+function getTestStatusFromRetries (testStatuses) {
+  if (testStatuses.every(status => status === 'fail')) {
+    return 'fail'
+  }
+  if (testStatuses.some(status => status === 'pass')) {
+    return 'pass'
+  }
+  return 'pass'
+}
+
 function wrapRun (pl, isLatestVersion) {
   if (patched.has(pl)) return
 
@@ -95,24 +118,13 @@ function wrapRun (pl, isLatestVersion) {
 
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     return asyncResource.runInAsyncScope(() => {
-      const testSuiteFullPath = this.pickle.uri
+      const testFileAbsolutePath = this.pickle.uri
 
-      if (!pickleResultByFile[testSuiteFullPath]) { // first test in suite
-        isUnskippable = isMarkedAsUnskippable(this.pickle)
-        const testSuitePath = getTestSuitePath(testSuiteFullPath, process.cwd())
-        isForcedToRun = isUnskippable && skippableSuites.includes(testSuitePath)
-
-        testSuiteStartCh.publish({ testSuitePath, isUnskippable, isForcedToRun })
-      }
-
-      const testSourceLine = this.gherkinDocument &&
-        this.gherkinDocument.feature &&
-        this.gherkinDocument.feature.location &&
-        this.gherkinDocument.feature.location.line
+      const testSourceLine = this.gherkinDocument?.feature?.location?.line
 
       testStartCh.publish({
         testName: this.pickle.name,
-        fullTestSuite: testSuiteFullPath,
+        testFileAbsolutePath,
         testSourceLine
       })
       try {
@@ -122,30 +134,20 @@ function wrapRun (pl, isLatestVersion) {
           const { status, skipReason, errorMessage } = isLatestVersion
             ? getStatusFromResultLatest(result) : getStatusFromResult(result)
 
-          if (!pickleResultByFile[testSuiteFullPath]) {
-            pickleResultByFile[testSuiteFullPath] = [status]
+          if (lastStatusByPickleId.has(this.pickle.id)) {
+            lastStatusByPickleId.get(this.pickle.id).push(status)
           } else {
-            pickleResultByFile[testSuiteFullPath].push(status)
+            lastStatusByPickleId.set(this.pickle.id, [status])
           }
-          testFinishCh.publish({ status, skipReason, errorMessage })
-          // last test in suite
-          if (pickleResultByFile[testSuiteFullPath].length === pickleByFile[testSuiteFullPath].length) {
-            const testSuiteStatus = getSuiteStatusFromTestStatuses(pickleResultByFile[testSuiteFullPath])
-            if (global.__coverage__) {
-              const coverageFiles = getCoveredFilenamesFromCoverage(global.__coverage__)
-
-              testSuiteCodeCoverageCh.publish({
-                coverageFiles,
-                suiteFile: testSuiteFullPath
-              })
-              // We need to reset coverage to get a code coverage per suite
-              // Before that, we preserve the original coverage
-              mergeCoverage(global.__coverage__, originalCoverageMap)
-              resetCoverage(global.__coverage__)
-            }
-
-            testSuiteFinishCh.publish(testSuiteStatus)
+          let isNew = false
+          let isEfdRetry = false
+          if (isEarlyFlakeDetectionEnabled && status !== 'skip') {
+            const numRetries = numRetriesByPickleId.get(this.pickle.id)
+
+            isNew = numRetries !== undefined
+            isEfdRetry = numRetries > 0
           }
+          testFinishCh.publish({ status, skipReason, errorMessage, isNew, isEfdRetry })
         })
         return promise
       } catch (err) {
@@ -257,12 +259,11 @@ function getPickleByFile (runtime) {
   }, {})
 }
 
-addHook({
-  name: '@cucumber/cucumber',
-  versions: ['>=7.0.0'],
-  file: 'lib/runtime/index.js'
-}, (runtimePackage, frameworkVersion) => {
-  shimmer.wrap(runtimePackage.default.prototype, 'start', start => async function () {
+function getWrappedStart (start, frameworkVersion) {
+  return async function () {
+    if (!libraryConfigurationCh.hasSubscribers) {
+      return start.apply(this, arguments)
+    }
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     let onDone
 
@@ -271,10 +272,26 @@ addHook({
     })
 
     asyncResource.runInAsyncScope(() => {
-      itrConfigurationCh.publish({ onDone })
+      libraryConfigurationCh.publish({ onDone })
     })
 
-    await configPromise
+    const configurationResponse = await configPromise
+
+    isEarlyFlakeDetectionEnabled = configurationResponse.libraryConfig?.isEarlyFlakeDetectionEnabled
+    earlyFlakeDetectionNumRetries = configurationResponse.libraryConfig?.earlyFlakeDetectionNumRetries
+
+    if (isEarlyFlakeDetectionEnabled) {
+      const knownTestsPromise = new Promise(resolve => {
+        onDone = resolve
+      })
+      asyncResource.runInAsyncScope(() => {
+        knownTestsCh.publish({ onDone })
+      })
+      const knownTestsResponse = await knownTestsPromise
+      if (!knownTestsResponse.err) {
+        knownTests = knownTestsResponse.knownTests
+      }
+    }
 
     const skippableSuitesPromise = new Promise(resolve => {
       onDone = resolve
@@ -304,6 +321,7 @@ addHook({
       this.pickleIds = picklesToRun
 
       skippedSuites = Array.from(filteredPickles.skippedSuites)
+      itrCorrelationId = skippableResponse.itrCorrelationId
     }
 
     pickleByFile = getPickleByFile(this)
@@ -340,11 +358,110 @@ addHook({
         testCodeCoverageLinesTotal,
         numSkippedSuites: skippedSuites.length,
         hasUnskippableSuites: isUnskippable,
-        hasForcedToRunSuites: isForcedToRun
+        hasForcedToRunSuites: isForcedToRun,
+        isEarlyFlakeDetectionEnabled
       })
     })
     return success
-  })
+  }
+}
+
+function getWrappedRunTest (runTestFunction) {
+  return async function (pickleId) {
+    const test = this.eventDataCollector.getPickle(pickleId)
+
+    const testFileAbsolutePath = test.uri
+    const testSuitePath = getTestSuitePath(testFileAbsolutePath, process.cwd())
+
+    if (!pickleResultByFile[testFileAbsolutePath]) { // first test in suite
+      isUnskippable = isMarkedAsUnskippable(test)
+      isForcedToRun = isUnskippable && skippableSuites.includes(testSuitePath)
+
+      testSuiteStartCh.publish({ testSuitePath, isUnskippable, isForcedToRun, itrCorrelationId })
+    }
+
+    let isNew = false
+
+    if (isEarlyFlakeDetectionEnabled) {
+      isNew = isNewTest(testSuitePath, test.name)
+      if (isNew) {
+        numRetriesByPickleId.set(pickleId, 0)
+      }
+    }
+    const runTestCaseResult = await runTestFunction.apply(this, arguments)
+
+    const testStatuses = lastStatusByPickleId.get(pickleId)
+    const lastTestStatus = testStatuses[testStatuses.length - 1]
+    // If it's a new test and it hasn't been skipped, we run it again
+    if (isEarlyFlakeDetectionEnabled && lastTestStatus !== 'skip' && isNew) {
+      for (let retryIndex = 0; retryIndex < earlyFlakeDetectionNumRetries; retryIndex++) {
+        numRetriesByPickleId.set(pickleId, retryIndex + 1)
+        await runTestFunction.apply(this, arguments)
+      }
+    }
+    let testStatus = lastTestStatus
+    if (isEarlyFlakeDetectionEnabled) {
+      /**
+       * If Early Flake Detection (EFD) is enabled the logic is as follows:
+       * - If all attempts for a test are failing, the test has failed and we will let the test process fail.
+       * - If just a single attempt passes, we will prevent the test process from failing.
+       * The rationale behind is the following: you may still be able to block your CI pipeline by gating
+       * on flakiness (the test will be considered flaky), but you may choose to unblock the pipeline too.
+       */
+      testStatus = getTestStatusFromRetries(testStatuses)
+      if (testStatus === 'pass') {
+        this.success = true
+      }
+    }
+
+    if (!pickleResultByFile[testFileAbsolutePath]) {
+      pickleResultByFile[testFileAbsolutePath] = [testStatus]
+    } else {
+      pickleResultByFile[testFileAbsolutePath].push(testStatus)
+    }
+
+    // last test in suite
+    if (pickleResultByFile[testFileAbsolutePath].length === pickleByFile[testFileAbsolutePath].length) {
+      const testSuiteStatus = getSuiteStatusFromTestStatuses(pickleResultByFile[testFileAbsolutePath])
+      if (global.__coverage__) {
+        const coverageFiles = getCoveredFilenamesFromCoverage(global.__coverage__)
+
+        testSuiteCodeCoverageCh.publish({
+          coverageFiles,
+          suiteFile: testFileAbsolutePath
+        })
+        // We need to reset coverage to get a code coverage per suite
+        // Before that, we preserve the original coverage
+        mergeCoverage(global.__coverage__, originalCoverageMap)
+        resetCoverage(global.__coverage__)
+      }
+
+      testSuiteFinishCh.publish(testSuiteStatus)
+    }
+
+    return runTestCaseResult
+  }
+}
+
+// From 7.3.0 onwards, runPickle becomes runTestCase
+addHook({
+  name: '@cucumber/cucumber',
+  versions: ['>=7.3.0'],
+  file: 'lib/runtime/index.js'
+}, (runtimePackage, frameworkVersion) => {
+  shimmer.wrap(runtimePackage.default.prototype, 'runTestCase', runTestCase => getWrappedRunTest(runTestCase))
+  shimmer.wrap(runtimePackage.default.prototype, 'start', start => getWrappedStart(start, frameworkVersion))
+
+  return runtimePackage
+})
+
+addHook({
+  name: '@cucumber/cucumber',
+  versions: ['>=7.0.0 <7.3.0'],
+  file: 'lib/runtime/index.js'
+}, (runtimePackage, frameworkVersion) => {
+  shimmer.wrap(runtimePackage.default.prototype, 'runPickle', runPickle => getWrappedRunTest(runPickle))
+  shimmer.wrap(runtimePackage.default.prototype, 'start', start => getWrappedStart(start, frameworkVersion))
 
   return runtimePackage
 })

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

@@ -18,8 +18,9 @@ const rrtypes = {
 }
 
 const rrtypeMap = new WeakMap()
+const names = ['dns', 'node:dns']
 
-addHook({ name: 'dns' }, dns => {
+addHook({ name: names }, dns => {
   dns.lookup = wrap('apm:dns:lookup', dns.lookup, 2)
   dns.lookupService = wrap('apm:dns:lookup_service', dns.lookupService, 3)
   dns.resolve = wrap('apm:dns:resolve', dns.resolve, 2)

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

@@ -1,5 +1,7 @@
 'use strict'
 
+const { AbortController } = require('node-abort-controller')
+
 const {
   addHook,
   channel,
@@ -37,6 +39,13 @@ const validateStartCh = channel('apm:graphql:validate:start')
 const validateFinishCh = channel('apm:graphql:validate:finish')
 const validateErrorCh = channel('apm:graphql:validate:error')
 
+class AbortError extends Error {
+  constructor (message) {
+    super(message)
+    this.name = 'AbortError'
+  }
+}
+
 function getOperation (document, operationName) {
   if (!document || !Array.isArray(document.definitions)) {
     return
@@ -175,11 +184,11 @@ function wrapExecute (execute) {
           docSource: documentSources.get(document)
         })
 
-        const context = { source, asyncResource, fields: {} }
+        const context = { source, asyncResource, fields: {}, abortController: new AbortController() }
 
         contexts.set(contextValue, context)
 
-        return callInAsyncScope(exe, asyncResource, this, arguments, (err, res) => {
+        return callInAsyncScope(exe, asyncResource, this, arguments, context.abortController, (err, res) => {
           if (finishResolveCh.hasSubscribers) finishResolvers(context)
 
           const error = err || (res && res.errors && res.errors[0])
@@ -207,7 +216,7 @@ function wrapResolve (resolve) {
 
     const field = assertField(context, info, args)
 
-    return callInAsyncScope(resolve, field.asyncResource, this, arguments, (err) => {
+    return callInAsyncScope(resolve, field.asyncResource, this, arguments, context.abortController, (err) => {
       updateFieldCh.publish({ field, info, err })
     })
   }
@@ -217,10 +226,15 @@ function wrapResolve (resolve) {
   return resolveAsync
 }
 
-function callInAsyncScope (fn, aR, thisArg, args, cb) {
+function callInAsyncScope (fn, aR, thisArg, args, abortController, cb) {
   cb = cb || (() => {})
 
   return aR.runInAsyncScope(() => {
+    if (abortController?.signal.aborted) {
+      cb(null, null)
+      throw new AbortError('Aborted')
+    }
+
     try {
       const result = fn.apply(thisArg, args)
       if (result && typeof result.then === 'function') {

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/grpc/server.js

@@ -92,7 +92,9 @@ function createWrapEmit (call, ctx, onCancel) {
           finishChannel.publish(ctx)
           call.removeListener('cancelled', onCancel)
           break
-        case 'finish':
+        // Streams are always cancelled before `finish` since 1.10.0 so we have
+        // to use `prefinish` instead to avoid cancellation false positives.
+        case 'prefinish':
           if (call.status) {
             updateChannel.publish(call.status)
           }

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

@@ -1,7 +1,6 @@
 'use strict'
 
-// eslint-disable-next-line n/no-restricted-require
-const dc = require('diagnostics_channel')
+const dc = require('dc-polyfill')
 
 const {
   filename,

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

@@ -1,6 +1,8 @@
 'use strict'
 
 module.exports = {
+  '@apollo/server': () => require('../apollo-server'),
+  'apollo-server-core': () => require('../apollo-server-core'),
   '@aws-sdk/smithy-client': () => require('../aws-sdk'),
   '@cucumber/cucumber': () => require('../cucumber'),
   '@playwright/test': () => require('../playwright'),
@@ -20,6 +22,7 @@ module.exports = {
   '@opentelemetry/sdk-trace-node': () => require('../otel-sdk-trace'),
   '@redis/client': () => require('../redis'),
   '@smithy/smithy-client': () => require('../aws-sdk'),
+  'aerospike': () => require('../aerospike'),
   'amqp10': () => require('../amqp10'),
   'amqplib': () => require('../amqplib'),
   'aws-sdk': () => require('../aws-sdk'),
@@ -27,8 +30,7 @@ module.exports = {
   'body-parser': () => require('../body-parser'),
   'bunyan': () => require('../bunyan'),
   'cassandra-driver': () => require('../cassandra-driver'),
-  'child_process': () => require('../child-process'),
-  'node:child_process': () => require('../child-process'),
+  'child_process': () => require('../child_process'),
   'connect': () => require('../connect'),
   'cookie': () => require('../cookie'),
   'cookie-parser': () => require('../cookie-parser'),
@@ -42,7 +44,6 @@ module.exports = {
   'fastify': () => require('../fastify'),
   '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'),
@@ -72,10 +73,18 @@ module.exports = {
   'mongodb': () => require('../mongodb'),
   'mongodb-core': () => require('../mongodb-core'),
   'mongoose': () => require('../mongoose'),
+  'mquery': () => require('../mquery'),
   'mysql': () => require('../mysql'),
   'mysql2': () => require('../mysql2'),
   'net': () => require('../net'),
   'next': () => require('../next'),
+  'node:child_process': () => require('../child_process'),
+  'node:crypto': () => require('../crypto'),
+  'node:dns': () => require('../dns'),
+  'node:http': () => require('../http'),
+  'node:http2': () => require('../http2'),
+  'node:https': () => require('../http'),
+  'node:net': () => require('../net'),
   'oracledb': () => require('../oracledb'),
   'openai': () => require('../openai'),
   'paperplane': () => require('../paperplane'),