dd-trace 5.61.0 → 5.62.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.61.0",
+  "version": "5.62.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",

package/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
+  }
 )

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

@@ -1,10 +1,6 @@
 'use strict'
 
-const {
-  channel,
-  addHook,
-  AsyncResource
-} = require('./helpers/instrument')
+const { channel, addHook } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
 function wrapRequest (send) {
@@ -15,28 +11,26 @@ function wrapRequest (send) {
     const channelSuffix = getChannelSuffix(serviceIdentifier)
     const startCh = channel(`apm:aws:request:start:${channelSuffix}`)
     if (!startCh.hasSubscribers) return send.apply(this, arguments)
-    const innerAr = new AsyncResource('apm:aws:request:inner')
-    const outerAr = new AsyncResource('apm:aws:request:outer')
-
-    return innerAr.runInAsyncScope(() => {
-      this.on('complete', innerAr.bind(response => {
-        const cbExists = typeof cb === 'function'
-        channel(`apm:aws:request:complete:${channelSuffix}`).publish({ response, cbExists })
-      }))
-
-      startCh.publish({
-        serviceIdentifier,
-        operation: this.operation,
-        awsRegion: this.service.config && this.service.config.region,
-        awsService: this.service.api && this.service.api.className,
-        request: this
-      })
 
-      if (typeof cb === 'function') {
-        arguments[0] = wrapCb(cb, channelSuffix, this, outerAr)
-      }
-      return send.apply(this, arguments)
+    const ctx = {
+      serviceIdentifier,
+      operation: this.operation,
+      awsRegion: this.service.config && this.service.config.region,
+      awsService: this.service.api && this.service.api.className,
+      request: this,
+      cbExists: typeof cb === 'function'
+    }
+
+    this.on('complete', response => {
+      ctx.response = response
+      channel(`apm:aws:request:complete:${channelSuffix}`).publish(ctx)
     })
+
+    if (ctx.cbExists) {
+      arguments[0] = wrapCb(cb, channelSuffix, ctx)
+    }
+
+    return startCh.runStores(ctx, send, this, ...arguments)
   }
 }
 
@@ -55,8 +49,6 @@ function wrapDeserialize (deserialize, channelSuffix) {
 function wrapSmithySend (send) {
   return function (command, ...args) {
     const cb = args.at(-1)
-    const innerAr = new AsyncResource('apm:aws:request:inner')
-    const outerAr = new AsyncResource('apm:aws:request:outer')
     const serviceIdentifier = this.config.serviceId.toLowerCase()
     const channelSuffix = getChannelSuffix(serviceIdentifier)
     const commandName = command.constructor.name
@@ -77,46 +69,45 @@ function wrapSmithySend (send) {
       shimmer.wrap(command, 'deserialize', deserialize => wrapDeserialize(deserialize, channelSuffix))
     }
 
-    return innerAr.runInAsyncScope(() => {
-      startCh.publish({
-        serviceIdentifier,
-        operation,
-        awsService: clientName,
-        request
-      })
+    const ctx = {
+      serviceIdentifier,
+      operation,
+      awsService: clientName,
+      request
+    }
 
+    return startCh.runStores(ctx, () => {
       // When the region is not set this never resolves so we can't await.
       this.config.region().then(region => {
-        regionCh.publish(region)
+        ctx.region = region
+        regionCh.publish(ctx)
       })
 
       if (typeof cb === 'function') {
         args[args.length - 1] = shimmer.wrapFunction(cb, cb => function (err, result) {
-          const message = getMessage(request, err, result)
+          addResponse(ctx, err, result)
 
-          completeChannel.publish(message)
+          completeChannel.publish(ctx)
 
-          outerAr.runInAsyncScope(() => {
-            responseStartChannel.publish(message)
+          const responseCtx = { request, response: ctx.response }
 
+          responseStartChannel.runStores(responseCtx, () => {
             cb.apply(this, arguments)
 
-            if (message.needsFinish) {
-              responseFinishChannel.publish(message.response.error)
-            }
+            responseFinishChannel.publish(responseCtx)
           })
         })
       } else { // always a promise
         return send.call(this, command, ...args)
           .then(
             result => {
-              const message = getMessage(request, null, result)
-              completeChannel.publish(message)
+              addResponse(ctx, null, result)
+              completeChannel.publish(ctx)
               return result
             },
             error => {
-              const message = getMessage(request, error)
-              completeChannel.publish(message)
+              addResponse(ctx, error)
+              completeChannel.publish(ctx)
               throw error
             }
           )
@@ -127,47 +118,45 @@ function wrapSmithySend (send) {
   }
 }
 
-function wrapCb (cb, serviceName, request, ar) {
+function wrapCb (cb, serviceName, ctx) {
   // eslint-disable-next-line n/handle-callback-err
   return shimmer.wrapFunction(cb, cb => function wrappedCb (err, response) {
-    const obj = { request, response }
-    return ar.runInAsyncScope(() => {
-      channel(`apm:aws:response:start:${serviceName}`).publish(obj)
-      // TODO(bengl) make this work without needing a needsFinish property added to the object
-      if (!obj.needsFinish) {
-        return cb.apply(this, arguments)
-      }
+    ctx = { request: ctx.request, response }
+    return channel(`apm:aws:response:start:${serviceName}`).runStores(ctx, () => {
       const finishChannel = channel(`apm:aws:response:finish:${serviceName}`)
       try {
         let result = cb.apply(this, arguments)
         if (result && result.then) {
           result = result.then(x => {
-            finishChannel.publish()
+            finishChannel.publish(ctx)
             return x
           }, e => {
-            finishChannel.publish(e)
+            ctx.error = e
+            finishChannel.publish(ctx)
             throw e
           })
         } else {
-          finishChannel.publish()
+          finishChannel.publish(ctx)
         }
         return result
       } catch (e) {
-        finishChannel.publish(e)
+        ctx.error = e
+        finishChannel.publish(ctx)
         throw e
       }
     })
   })
 }
 
-function getMessage (request, error, result) {
+function addResponse (ctx, error, result) {
+  const request = ctx.request
   const response = { request, error, ...result }
 
   if (result && result.$metadata) {
     response.requestId = result.$metadata.requestId
   }
 
-  return { request, response }
+  ctx.response = response
 }
 
 function getChannelSuffix (name) {

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

@@ -1,7 +1,7 @@
 'use strict'
 
 const shimmer = require('../../datadog-shimmer')
-const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+const { addHook, channel } = require('./helpers/instrument')
 
 const errorChannel = channel('apm:fastify:middleware:error')
 const handleChannel = channel('apm:fastify:request:handle')
@@ -13,7 +13,12 @@ const responsePayloadReadCh = channel('datadog:fastify:response:finish')
 const pathParamsReadCh = channel('datadog:fastify:path-params:finish')
 const finishSetHeaderCh = channel('datadog:fastify:set-header:finish')
 
-const parsingResources = new WeakMap()
+// context management channels
+const preParsingCh = channel('datadog:fastify:pre-parsing:start')
+const preValidationCh = channel('datadog:fastify:pre-validation:start')
+const callbackFinishCh = channel('datadog:fastify:callback:execute')
+
+const parsingContexts = new WeakMap()
 const cookiesPublished = new WeakSet()
 const bodyPublished = new WeakSet()
 
@@ -51,6 +56,7 @@ function wrapAddHook (addHook) {
 
     arguments[arguments.length - 1] = shimmer.wrapFunction(fn, fn => function (request, reply, done) {
       const req = getReq(request)
+      const ctx = { req }
 
       try {
         // done callback is always the last argument
@@ -58,32 +64,26 @@ function wrapAddHook (addHook) {
 
         if (typeof doneCallback === 'function') {
           arguments[arguments.length - 1] = function (err) {
-            publishError(err, req)
+            ctx.error = err
+            publishError(ctx)
 
             const hasCookies = request.cookies && Object.keys(request.cookies).length > 0
 
             if (cookieParserReadCh.hasSubscribers && hasCookies && !cookiesPublished.has(req)) {
-              const res = getRes(reply)
-              const abortController = new AbortController()
-
-              cookieParserReadCh.publish({
-                req,
-                res,
-                abortController,
-                cookies: request.cookies
-              })
+              ctx.res = getRes(reply)
+              ctx.abortController = new AbortController()
+              ctx.cookies = request.cookies
 
+              cookieParserReadCh.publish(ctx)
               cookiesPublished.add(req)
 
-              if (abortController.signal.aborted) return
+              if (ctx.abortController.signal.aborted) return
             }
 
             if (name === 'onRequest' || name === 'preParsing') {
-              const parsingResource = new AsyncResource('bound-anonymous-fn')
-
-              parsingResources.set(req, parsingResource)
+              parsingContexts.set(req, ctx)
 
-              return parsingResource.runInAsyncScope(() => {
+              return callbackFinishCh.runStores(ctx, () => {
                 return doneCallback.apply(this, arguments)
               })
             }
@@ -96,12 +96,16 @@ function wrapAddHook (addHook) {
         const promise = fn.apply(this, arguments)
 
         if (promise && typeof promise.catch === 'function') {
-          return promise.catch(err => publishError(err, req))
+          return promise.catch(err => {
+            ctx.error = err
+            return publishError(ctx)
+          })
         }
 
         return promise
       } catch (e) {
-        throw publishError(e, req)
+        ctx.error = e
+        throw publishError(ctx)
       }
     })
 
@@ -116,7 +120,8 @@ function onRequest (request, reply, done) {
   const res = getRes(reply)
   const routeConfig = getRouteConfig(request)
 
-  handleChannel.publish({ req, res, routeConfig })
+  const ctx = { req, res, routeConfig }
+  handleChannel.publish(ctx)
 
   return done()
 }
@@ -127,18 +132,18 @@ function preHandler (request, reply, done) {
 
   const req = getReq(request)
   const res = getRes(reply)
+  const ctx = { req, res }
 
   const hasBody = request.body && Object.keys(request.body).length > 0
 
   // For multipart/form-data, the body is not available until after preValidation hook
   if (bodyParserReadCh.hasSubscribers && hasBody && !bodyPublished.has(req)) {
-    const abortController = new AbortController()
-
-    bodyParserReadCh.publish({ req, res, body: request.body, abortController })
-
+    ctx.abortController = new AbortController()
+    ctx.body = request.body
+    bodyParserReadCh.publish(ctx)
     bodyPublished.add(req)
 
-    if (abortController.signal.aborted) return
+    if (ctx.abortController.signal.aborted) return
   }
 
   reply.send = wrapSend(reply.send, req)
@@ -149,20 +154,17 @@ function preHandler (request, reply, done) {
 function preValidation (request, reply, done) {
   const req = getReq(request)
   const res = getRes(reply)
-  const parsingResource = parsingResources.get(req)
+  const ctx = parsingContexts.get(req)
+  ctx.res = res
 
   const processInContext = () => {
     let abortController
 
     if (queryParamsReadCh.hasSubscribers && request.query) {
       abortController ??= new AbortController()
-
-      queryParamsReadCh.publish({
-        req,
-        res,
-        abortController,
-        query: request.query
-      })
+      ctx.abortController = abortController
+      ctx.query = request.query
+      queryParamsReadCh.publish(ctx)
 
       if (abortController.signal.aborted) return
     }
@@ -170,8 +172,9 @@ function preValidation (request, reply, done) {
     // Analyze body before schema validation
     if (bodyParserReadCh.hasSubscribers && request.body && !bodyPublished.has(req)) {
       abortController ??= new AbortController()
-
-      bodyParserReadCh.publish({ req, res, body: request.body, abortController })
+      ctx.abortController = abortController
+      ctx.body = request.body
+      bodyParserReadCh.publish(ctx)
 
       bodyPublished.add(req)
 
@@ -180,13 +183,9 @@ function preValidation (request, reply, done) {
 
     if (pathParamsReadCh.hasSubscribers && request.params) {
       abortController ??= new AbortController()
-
-      pathParamsReadCh.publish({
-        req,
-        res,
-        abortController,
-        params: request.params
-      })
+      ctx.abortController = abortController
+      ctx.params = request.params
+      pathParamsReadCh.publish(ctx)
 
       if (abortController.signal.aborted) return
     }
@@ -194,9 +193,9 @@ function preValidation (request, reply, done) {
     done()
   }
 
-  if (!parsingResource) return processInContext()
+  if (!ctx) return processInContext()
 
-  parsingResource.runInAsyncScope(processInContext)
+  preValidationCh.runStores(ctx, processInContext)
 }
 
 function preParsing (request, reply, payload, done) {
@@ -205,19 +204,24 @@ function preParsing (request, reply, payload, done) {
   }
 
   const req = getReq(request)
-  const parsingResource = new AsyncResource('bound-anonymous-fn')
+  const ctx = { req }
+
+  parsingContexts.set(req, ctx)
 
-  parsingResources.set(req, parsingResource)
-  parsingResource.runInAsyncScope(() => done())
+  preParsingCh.runStores(ctx, () => done())
 }
 
 function wrapSend (send, req) {
   return function sendWithTrace (payload) {
+    const ctx = { req }
     if (payload instanceof Error) {
-      errorChannel.publish({ req, error: payload })
+      ctx.error = payload
+      errorChannel.publish(ctx)
     } else if (canPublishResponsePayload(payload)) {
       const res = getRes(this)
-      responsePayloadReadCh.publish({ req, res, body: payload })
+      ctx.res = res
+      ctx.body = payload
+      responsePayloadReadCh.publish(ctx)
     }
 
     return send.apply(this, arguments)
@@ -236,16 +240,17 @@ function getRouteConfig (request) {
   return request?.routeOptions?.config
 }
 
-function publishError (error, req) {
-  if (error) {
-    errorChannel.publish({ error, req })
+function publishError (ctx) {
+  if (ctx.error) {
+    errorChannel.publish(ctx)
   }
 
-  return error
+  return ctx.error
 }
 
 function onRoute (routeOptions) {
-  routeAddedChannel.publish({ routeOptions, onRoute })
+  const ctx = { routeOptions, onRoute }
+  routeAddedChannel.publish(ctx)
 }
 
 // send() payload types: https://fastify.dev/docs/latest/Reference/Reply/#senddata
@@ -282,7 +287,8 @@ function wrapReplyHeader (Reply) {
     const result = header.apply(this, arguments)
 
     if (finishSetHeaderCh.hasSubscribers && key && value) {
-      finishSetHeaderCh.publish({ name: key, value, res: getRes(this) })
+      const ctx = { name: key, value, res: getRes(this) }
+      finishSetHeaderCh.publish(ctx)
     }
 
     return result