Merge branch 'master' into mario.vidal/support_happy_dom_jest

Author: Mariovido

.github/workflows/test-optimization.yml

@@ -19,23 +19,22 @@ jobs:
   benchmarks-e2e:
     name: Performance and correctness tests
     runs-on: ubuntu-latest
+    permissions:
+      id-token: write
     steps:
-      - uses: actions/create-github-app-token@df432ceedc7162793a195dd1713ff69aefc7379e # v2.0.6
-        id: app-token
+      - uses: DataDog/dd-octo-sts-action@08f2144903ced3254a3dafec2592563409ba2aa0 # v1.0.1
+        id: octo-sts
         with:
-          app-id: ${{ vars.APP_ID }}
-          private-key: ${{ secrets.PRIVATE_KEY }}
-          repositories: |
-            dd-trace-js
-            test-environment
+          scope: DataDog/test-environment
+          policy: dd-trace-js
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
-          token: ${{ steps.app-token.outputs.token }}
+          token: ${{ steps.octo-sts.outputs.token }}
       - uses: ./.github/actions/node/oldest-maintenance-lts
       - name: Test Optimization Performance Overhead Test
         run: yarn bench:e2e:test-optimization
         env:
-          GITHUB_TOKEN: ${{ steps.app-token.outputs.token }}
+          GITHUB_TOKEN: ${{ steps.octo-sts.outputs.token }}
 
   integration:
     strategy:

.gitignore

@@ -121,5 +121,7 @@ packages/datadog-plugin-next/test/yarn.lock
 packages/dd-trace/test/appsec/next/*/package.json
 packages/dd-trace/test/appsec/next/*/node_modules
 packages/dd-trace/test/appsec/next/*/yarn.lock
+packages/dd-trace/test/plugins/versions/node_modules
+packages/dd-trace/test/plugins/versions/yarn.lock
 !packages/dd-trace/**/telemetry/logs
 packages/datadog-plugin-azure-functions/test/integration-test/fixtures/node_modules

integration-tests/appsec/graphql.spec.js

@@ -14,7 +14,7 @@ describe('graphql', () => {
   let sandbox, cwd, agent, webFile, proc
 
   before(async function () {
-    sandbox = await createSandbox(['@apollo/server@4', 'graphql', 'koalas'])
+    sandbox = await createSandbox(['@apollo/server', 'graphql', 'koalas'])
     cwd = sandbox.folder
     webFile = path.join(cwd, 'graphql/index.js')
   })
@@ -43,7 +43,8 @@ describe('graphql', () => {
       assert.propertyVal(headers, 'host', `127.0.0.1:${agent.port}`)
       assert.isArray(payload)
       assert.strictEqual(payload.length, 2)
-      assert.propertyVal(payload[1][0], 'name', 'express.request')
+      // Apollo server 5 is using Node.js http server instead of express
+      assert.propertyVal(payload[1][0], 'name', 'web.request')
       assert.propertyVal(payload[1][0].metrics, '_dd.appsec.enabled', 1)
       assert.property(payload[1][0].metrics, '_dd.appsec.waf.duration')
       assert.notProperty(payload[1][0].meta, '_dd.appsec.event')
@@ -104,7 +105,8 @@ describe('graphql', () => {
       assert.propertyVal(headers, 'host', `127.0.0.1:${agent.port}`)
       assert.isArray(payload)
       assert.strictEqual(payload.length, 2)
-      assert.propertyVal(payload[1][0], 'name', 'express.request')
+      // Apollo server 5 is using Node.js http server instead of express
+      assert.propertyVal(payload[1][0], 'name', 'web.request')
       assert.propertyVal(payload[1][0].metrics, '_dd.appsec.enabled', 1)
       assert.property(payload[1][0].metrics, '_dd.appsec.waf.duration')
       assert.propertyVal(payload[1][0].meta, 'appsec.event', 'true')

integration-tests/helpers/index.js

@@ -6,13 +6,15 @@ const { fork, spawn } = childProcess
 const exec = promisify(childProcess.exec)
 const http = require('http')
 const fs = require('fs')
+const { builtinModules } = require('module')
 const os = require('os')
 const path = require('path')
 const assert = require('assert')
 const rimraf = promisify(require('rimraf'))
 const FakeAgent = require('./fake-agent')
 const id = require('../../packages/dd-trace/src/id')
 const { version } = require('../../package.json')
+const { getCappedRange } = require('../../packages/dd-trace/test/plugins/versions')
 
 const hookFile = 'dd-trace/loader-hook.mjs'
 
@@ -169,6 +171,17 @@ function spawnProc (filename, options = {}, stdioHandler, stderrHandler) {
 
 async function createSandbox (dependencies = [], isGitRepo = false,
   integrationTestsPaths = ['./integration-tests/*'], followUpCommand) {
+  const cappedDependencies = dependencies.map(dep => {
+    if (builtinModules.includes(dep)) return dep
+
+    const match = dep.replaceAll(/['"]/g, '').match(/^(@?[^@]+)(@(.+))?$/)
+    const name = match[1]
+    const range = match[3] || ''
+    const cappedRange = getCappedRange(name, range)
+
+    return `"${name}@${cappedRange}"`
+  })
+
   // We might use NODE_OPTIONS to init the tracer. We don't want this to affect this operations
   const { NODE_OPTIONS, ...restOfEnv } = process.env
   const noSandbox = String(process.env.TESTING_NO_INTEGRATION_SANDBOX)
@@ -184,7 +197,7 @@ async function createSandbox (dependencies = [], isGitRepo = false,
   }
   const folder = path.join(os.tmpdir(), id().toString())
   const out = path.join(folder, `dd-trace-${version}.tgz`)
-  const allDependencies = [`file:${out}`].concat(dependencies)
+  const allDependencies = [`file:${out}`].concat(cappedDependencies)
 
   fs.mkdirSync(folder)
   const preferOfflineFlag = process.env.OFFLINE === '1' || process.env.OFFLINE === 'true' ? ' --prefer-offline' : ''

packages/datadog-instrumentations/src/apollo-server.js

@@ -6,6 +6,7 @@ const { addHook } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
 const graphqlMiddlewareChannel = dc.tracingChannel('datadog:apollo:middleware')
+const apolloHttpServerChannel = dc.tracingChannel('datadog:apollo:httpserver')
 
 const requestChannel = dc.tracingChannel('datadog:apollo:request')
 
@@ -77,17 +78,58 @@ function apolloServerHook (apolloServer) {
   return apolloServer
 }
 
-addHook(
-  { name: '@apollo/server', file: 'dist/cjs/ApolloServer.js', versions: ['>=4.0.0 <5.0.0'] },
-  apolloServerHook
-)
+function wrapEmit (emit) {
+  return function wrappedEmit (event, req, res) {
+    if (event === 'request' && req && res && apolloHttpServerChannel.start.hasSubscribers) {
+      return apolloHttpServerChannel.traceSync(emit, { req }, this, ...arguments)
+    }
+
+    return emit.apply(this, arguments)
+  }
+}
+
+function wrapListen (originalListen) {
+  return function wrappedListen () {
+    shimmer.wrap(this, 'emit', wrapEmit)
+
+    return originalListen.apply(this, arguments)
+  }
+}
+
+function wrapHttpServer (original) {
+  return function wrappedHttpServer (options) {
+    if (options.httpServer && typeof options.httpServer.listen === 'function') {
+      shimmer.wrap(options.httpServer, 'listen', wrapListen)
+    }
+
+    return original.apply(this, arguments)
+  }
+}
+
+function apolloDrainHttpServerHook (drainModule) {
+  shimmer.wrap(drainModule, 'ApolloServerPluginDrainHttpServer', wrapHttpServer)
+
+  return drainModule
+}
+
+addHook({ name: '@apollo/server', file: 'dist/cjs/ApolloServer.js', versions: ['4'] }, apolloServerHook)
+
+addHook({ name: '@apollo/server', file: 'dist/cjs/express4/index.js', versions: ['4'] }, apolloExpress4Hook)
+
+addHook({ name: '@apollo/server', file: 'dist/cjs/utils/HeaderMap.js', versions: ['4'] }, apolloHeaderMapHook)
 
 addHook(
-  { name: '@apollo/server', file: 'dist/cjs/express4/index.js', versions: ['>=4.0.0 <5.0.0'] },
-  apolloExpress4Hook
+  { name: '@apollo/server', file: 'dist/cjs/plugin/drainHttpServer/index.js', versions: ['>=5.0.0'] },
+  apolloDrainHttpServerHook
 )
 
 addHook(
-  { name: '@apollo/server', file: 'dist/cjs/utils/HeaderMap.js', versions: ['>=4.0.0 <5.0.0'] },
-  apolloHeaderMapHook
+  { name: '@apollo/server', file: 'dist/cjs/runHttpQuery.js', versions: ['>=5.0.0'] },
+  (runHttpQueryModule) => {
+    shimmer.wrap(runHttpQueryModule, 'runHttpQuery', function wrapRunHttpQuery (originalRunHttpQuery) {
+      return wrapExecuteHTTPGraphQLRequest(originalRunHttpQuery)
+    })
+
+    return runHttpQueryModule
+  }
 )

packages/datadog-instrumentations/src/http2/server.js

@@ -5,14 +5,13 @@
 
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 
 const startServerCh = channel('apm:http2:server:request:start')
 const errorServerCh = channel('apm:http2:server:request:error')
-const finishServerCh = channel('apm:http2:server:request:finish')
+const emitCh = channel('apm:http2:server:response:emit')
 
 const names = ['http2', 'node:http2']
 
@@ -30,18 +29,14 @@ function wrapCreateServer (createServer) {
   }
 }
 
-function wrapResponseEmit (emit) {
-  const asyncResource = new AsyncResource('bound-anonymous-fn')
+function wrapResponseEmit (emit, ctx) {
   return function (eventName, event) {
-    return asyncResource.runInAsyncScope(() => {
-      if (eventName === 'close' && finishServerCh.hasSubscribers) {
-        finishServerCh.publish({ req: this.req })
-      }
-
-      return emit.apply(this, arguments)
-    })
+    ctx.req = this.req
+    ctx.eventName = eventName
+    return emitCh.runStores(ctx, emit, this, ...arguments)
   }
 }
+
 function wrapEmit (emit) {
   return function (eventName, req, res) {
     if (!startServerCh.hasSubscribers) {
@@ -51,18 +46,17 @@ function wrapEmit (emit) {
     if (eventName === 'request') {
       res.req = req
 
-      const asyncResource = new AsyncResource('bound-anonymous-fn')
-      return asyncResource.runInAsyncScope(() => {
-        startServerCh.publish({ req, res })
-
-        shimmer.wrap(res, 'emit', wrapResponseEmit)
+      const ctx = { req, res }
+      return startServerCh.runStores(ctx, () => {
+        shimmer.wrap(res, 'emit', emit => wrapResponseEmit(emit, ctx))
 
         try {
           return emit.apply(this, arguments)
-        } catch (err) {
-          errorServerCh.publish(err)
+        } catch (error) {
+          ctx.error = error
+          errorServerCh.publish(ctx)
 
-          throw err
+          throw error
         }
       })
     }

packages/datadog-instrumentations/src/mongodb-core.js

@@ -148,61 +148,66 @@ function wrapCommand (command, operation, name) {
   return wrapped
 }
 
-function instrument (operation, command, ctx, args, server, ns, ops, options = {}) {
+function instrument (operation, command, instance, args, server, ns, ops, options = {}) {
   const name = options.name || (ops && Object.keys(ops)[0])
   const index = args.length - 1
-  let callback = args[index]
+  const callback = args[index]
 
-  if (typeof callback !== 'function') return command.apply(ctx, args)
+  if (typeof callback !== 'function') return command.apply(instance, args)
 
   const serverInfo = server && server.s && server.s.options
-  const callbackResource = new AsyncResource('bound-anonymous-fn')
-  const asyncResource = new AsyncResource('bound-anonymous-fn')
 
-  callback = callbackResource.bind(callback)
-
-  return asyncResource.runInAsyncScope(() => {
-    startCh.publish({ ns, ops, options: serverInfo, name })
-
-    args[index] = shimmer.wrapFunction(callback, callback => asyncResource.bind(function (err, res) {
+  const ctx = {
+    ns,
+    ops,
+    options: serverInfo,
+    name
+  }
+  return startCh.runStores(ctx, () => {
+    args[index] = shimmer.wrapFunction(callback, callback => function (err, res) {
       if (err) {
-        errorCh.publish(err)
+        ctx.error = err
+        errorCh.publish(ctx)
       }
 
-      finishCh.publish()
-
-      if (callback) {
-        return callback.apply(this, arguments)
-      }
-    }))
+      return finishCh.runStores(ctx, callback, this, ...arguments)
+    })
 
     try {
-      return command.apply(ctx, args)
+      return command.apply(instance, args)
     } catch (err) {
-      errorCh.publish(err)
+      ctx.error = err
+      errorCh.publish(ctx)
 
       throw err
     }
   })
 }
 
-function instrumentPromise (operation, command, ctx, args, server, ns, ops, options = {}) {
+function instrumentPromise (operation, command, instance, args, server, ns, ops, options = {}) {
   const name = options.name || (ops && Object.keys(ops)[0])
 
   const serverInfo = server && server.s && server.s.options
-  const asyncResource = new AsyncResource('bound-anonymous-fn')
 
-  return asyncResource.runInAsyncScope(() => {
-    startCh.publish({ ns, ops, options: serverInfo, name })
+  const ctx = {
+    ns,
+    ops,
+    options: serverInfo,
+    name
+  }
 
-    const promise = command.apply(ctx, args)
+  return startCh.runStores(ctx, () => {
+    const promise = command.apply(instance, args)
 
     return promise.then(function (res) {
-      finishCh.publish()
-      return res
+      ctx.result = res
+      return finishCh.runStores(ctx, () => {
+        return res
+      })
     }, function (err) {
-      errorCh.publish(err)
-      finishCh.publish()
+      ctx.error = err
+      errorCh.publish(ctx)
+      finishCh.publish(ctx)
 
       throw err
     })

packages/datadog-instrumentations/src/mongodb.js

@@ -4,8 +4,7 @@ require('./mongodb-core')
 
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -41,19 +40,16 @@ addHook({ name: 'mongodb', versions: ['>=3.3 <5', '5', '>=6'] }, mongodb => {
           return method.apply(this, arguments)
         }
 
-        const asyncResource = new AsyncResource('bound-anonymous-fn')
-
-        return asyncResource.runInAsyncScope(() => {
-          const filters = [arguments[0]]
-          if (useTwoArguments) {
-            filters.push(arguments[1])
-          }
+        const ctx = {
+          filters: [arguments[0]],
+          methodName
+        }
 
-          startCh.publish({
-            filters,
-            methodName
-          })
+        if (useTwoArguments) {
+          ctx.filters.push(arguments[1])
+        }
 
+        return startCh.runStores(ctx, () => {
           return method.apply(this, arguments)
         })
       }