dd-trace 5.61.0 → 5.62.0

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

@@ -2,8 +2,7 @@
 
 const {
   addHook,
-  channel,
-  AsyncResource
+  channel
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -89,29 +88,28 @@ function wrapParse (parse) {
       return parse.apply(this, arguments)
     }
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
-    return asyncResource.runInAsyncScope(() => {
-      parseStartCh.publish()
-      let document
+    const ctx = { source }
+    return parseStartCh.runStores(ctx, () => {
       try {
-        document = parse.apply(this, arguments)
-        const operation = getOperation(document)
+        ctx.document = parse.apply(this, arguments)
+        const operation = getOperation(ctx.document)
 
-        if (!operation) return document
+        if (!operation) return ctx.document
 
         if (source) {
-          documentSources.set(document, source.body || source)
+          documentSources.set(ctx.document, source.body || source)
         }
+        ctx.docSource = documentSources.get(ctx.document)
 
-        return document
+        return ctx.document
       } catch (err) {
         err.stack
-        parseErrorCh.publish(err)
+        ctx.error = err
+        parseErrorCh.publish(ctx)
 
         throw err
       } finally {
-        parseFinishCh.publish({ source, document, docSource: documentSources.get(document) })
+        parseFinishCh.publish(ctx)
       }
     })
   }
@@ -123,25 +121,25 @@ function wrapValidate (validate) {
       return validate.apply(this, arguments)
     }
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
-    return asyncResource.runInAsyncScope(() => {
-      validateStartCh.publish({ docSource: documentSources.get(document), document })
-
+    const ctx = { docSource: documentSources.get(document), document }
+    return validateStartCh.runStores(ctx, () => {
       let errors
       try {
         errors = validate.apply(this, arguments)
         if (errors && errors[0]) {
-          validateErrorCh.publish(errors && errors[0])
+          ctx.error = errors && errors[0]
+          validateErrorCh.publish(ctx)
         }
         return errors
       } catch (err) {
         err.stack
-        validateErrorCh.publish(err)
+        ctx.error = err
+        validateErrorCh.publish(ctx)
 
         throw err
       } finally {
-        validateFinishCh.publish({ document, errors })
+        ctx.errors = errors
+        validateFinishCh.publish(ctx)
       }
     })
   }
@@ -155,44 +153,46 @@ function wrapExecute (execute) {
         return exe.apply(this, arguments)
       }
 
-      const asyncResource = new AsyncResource('bound-anonymous-fn')
-      return asyncResource.runInAsyncScope(() => {
-        const args = normalizeArgs(arguments, defaultFieldResolver)
-        const schema = args.schema
-        const document = args.document
-        const source = documentSources.get(document)
-        const contextValue = args.contextValue
-        const operation = getOperation(document, args.operationName)
-
-        if (contexts.has(contextValue)) {
-          return exe.apply(this, arguments)
-        }
+      const args = normalizeArgs(arguments, defaultFieldResolver)
+      const schema = args.schema
+      const document = args.document
+      const source = documentSources.get(document)
+      const contextValue = args.contextValue
+      const operation = getOperation(document, args.operationName)
+
+      if (contexts.has(contextValue)) {
+        return exe.apply(this, arguments)
+      }
+
+      const ctx = {
+        operation,
+        args,
+        docSource: documentSources.get(document),
+        source,
+        fields: {},
+        abortController: new AbortController()
+      }
 
+      return startExecuteCh.runStores(ctx, () => {
         if (schema) {
           wrapFields(schema._queryType)
           wrapFields(schema._mutationType)
         }
 
-        startExecuteCh.publish({
-          operation,
-          args,
-          docSource: documentSources.get(document)
-        })
-
-        const context = { source, asyncResource, fields: {}, abortController: new AbortController() }
-
-        contexts.set(contextValue, context)
+        contexts.set(contextValue, ctx)
 
-        return callInAsyncScope(exe, asyncResource, this, arguments, context.abortController, (err, res) => {
-          if (finishResolveCh.hasSubscribers) finishResolvers(context)
+        return callInAsyncScope(exe, this, arguments, ctx.abortController, (err, res) => {
+          if (finishResolveCh.hasSubscribers) finishResolvers(ctx)
 
           const error = err || (res && res.errors && res.errors[0])
 
           if (error) {
-            executeErrorCh.publish(error)
+            ctx.error = error
+            executeErrorCh.publish(ctx)
           }
 
-          finishExecuteCh.publish({ res, args, context })
+          ctx.res = res
+          finishExecuteCh.publish(ctx)
         })
       })
     }
@@ -205,14 +205,17 @@ function wrapResolve (resolve) {
   function resolveAsync (source, args, contextValue, info) {
     if (!startResolveCh.hasSubscribers) return resolve.apply(this, arguments)
 
-    const context = contexts.get(contextValue)
+    const ctx = contexts.get(contextValue)
 
-    if (!context) return resolve.apply(this, arguments)
+    if (!ctx) return resolve.apply(this, arguments)
 
-    const field = assertField(context, info, args)
+    const field = assertField(ctx, info, args)
 
-    return callInAsyncScope(resolve, field.asyncResource, this, arguments, context.abortController, (err) => {
-      updateFieldCh.publish({ field, info, err })
+    return callInAsyncScope(resolve, this, arguments, ctx.abortController, (err) => {
+      field.ctx.error = err
+      field.ctx.info = info
+      field.ctx.field = field
+      updateFieldCh.publish(field.ctx)
     })
   }
 
@@ -221,32 +224,30 @@ function wrapResolve (resolve) {
   return resolveAsync
 }
 
-function callInAsyncScope (fn, aR, thisArg, args, abortController, cb) {
+function callInAsyncScope (fn, thisArg, args, abortController, cb) {
   cb = cb || (() => {})
 
-  return aR.runInAsyncScope(() => {
-    if (abortController?.signal.aborted) {
-      cb(null, null)
-      throw new AbortError('Aborted')
-    }
+  if (abortController?.signal.aborted) {
+    cb(null, null)
+    throw new AbortError('Aborted')
+  }
 
-    try {
-      const result = fn.apply(thisArg, args)
-      if (result && typeof result.then === 'function') {
-        // bind callback to this scope
-        result.then(
-          aR.bind(res => cb(null, res)),
-          aR.bind(err => cb(err))
-        )
-      } else {
-        cb(null, result)
-      }
-      return result
-    } catch (err) {
-      cb(err)
-      throw err
+  try {
+    const result = fn.apply(thisArg, args)
+    if (result && typeof result.then === 'function') {
+      // bind callback to this scope
+      result.then(
+        res => cb(null, res),
+        err => cb(err)
+      )
+    } else {
+      cb(null, result)
     }
-  })
+    return result
+  } catch (err) {
+    cb(err)
+    throw err
+  }
 }
 
 function pathToArray (path) {
@@ -259,59 +260,26 @@ function pathToArray (path) {
   return flattened.reverse()
 }
 
-function assertField (context, info, args) {
+function assertField (rootCtx, info, args) {
   const pathInfo = info && info.path
 
   const path = pathToArray(pathInfo)
 
   const pathString = path.join('.')
-  const fields = context.fields
+  const fields = rootCtx.fields
 
   let field = fields[pathString]
 
   if (!field) {
-    const parent = getParentField(context, path)
-
-    // we want to spawn the new span off of the parent, not a new async resource
-    parent.asyncResource.runInAsyncScope(() => {
-      /* this child resource will run a branched scope off of the parent resource, which
-      accesses the parent span from the storage unit in its own scope */
-      const childResource = new AsyncResource('bound-anonymous-fn')
-
-      childResource.runInAsyncScope(() => {
-        startResolveCh.publish({
-          info,
-          context,
-          args
-        })
-      })
-
-      field = fields[pathString] = {
-        parent,
-        asyncResource: childResource,
-        error: null
-      }
-    })
-  }
-
-  return field
-}
-
-function getParentField (context, path) {
-  for (let i = path.length - 1; i > 0; i--) {
-    const field = getField(context, path.slice(0, i))
-    if (field) {
-      return field
+    const fieldCtx = { info, rootCtx, args }
+    startResolveCh.publish(fieldCtx)
+    field = fields[pathString] = {
+      error: null,
+      ctx: fieldCtx
     }
   }
 
-  return {
-    asyncResource: context.asyncResource
-  }
-}
-
-function getField (context, path) {
-  return context.fields[path.join('.')]
+  return field
 }
 
 function wrapFields (type) {
@@ -349,13 +317,13 @@ function wrapFieldType (field) {
 function finishResolvers ({ fields }) {
   Object.keys(fields).reverse().forEach(key => {
     const field = fields[key]
-    const asyncResource = field.asyncResource
-    asyncResource.runInAsyncScope(() => {
-      if (field.error) {
-        resolveErrorCh.publish(field.error)
-      }
-      finishResolveCh.publish(field.finishTime)
-    })
+    field.ctx.finishTime = field.finishTime
+    field.ctx.field = field
+    if (field.error) {
+      field.ctx.error = field.error
+      resolveErrorCh.publish(field.ctx)
+    }
+    finishResolveCh.publish(field.ctx)
   })
 }
 

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

package/packages/datadog-instrumentations/src/microgateway-core.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 handleChannel = channel('apm:microgateway-core:request:handle')
 const routeChannel = channel('apm:microgateway-core:request:route')
@@ -11,18 +11,18 @@ const name = 'microgateway-core'
 
 // TODO Remove " <=3.0.0" when "volos-util-apigee" module is fixed
 const versions = ['>=2.1 <=3.0.0']
-const requestResources = new WeakMap()
+const requestContexts = new WeakMap()
 
 function wrapConfigProxyFactory (configProxyFactory) {
   return function () {
     const configProxy = configProxyFactory.apply(this, arguments)
 
     return function (req, res, next) {
-      const requestResource = new AsyncResource('bound-anonymous-fn')
+      const ctx = { req, res }
 
-      requestResources.set(req, requestResource)
+      requestContexts.set(req, ctx)
 
-      handleChannel.publish({ req, res })
+      handleChannel.publish(ctx)
 
       return configProxy.apply(this, arguments)
     }
@@ -43,18 +43,19 @@ function wrapPluginsFactory (pluginsFactory) {
 
 function wrapNext (req, res, next) {
   return shimmer.wrapFunction(next, next => function nextWithTrace (err) {
-    const requestResource = requestResources.get(req)
+    const ctx = requestContexts.get(req)
 
-    requestResource.runInAsyncScope(() => {
-      if (err) {
-        errorChannel.publish(err)
-      }
-
-      if (res.proxy && res.proxy.base_path) {
-        routeChannel.publish({ req, res, route: res.proxy.base_path })
-      }
-    })
+    if (err) {
+      ctx.error = err
+      errorChannel.publish(ctx)
+    }
 
+    if (res.proxy && res.proxy.base_path) {
+      ctx.req = req
+      ctx.res = res
+      ctx.route = res.proxy.base_path
+      routeChannel.publish(ctx)
+    }
     return next.apply(this, arguments)
   })
 }

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

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