dd-trace 2.9.0 → 2.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "2.9.0",
+  "version": "2.11.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -58,10 +58,10 @@
     "node": ">=12"
   },
   "dependencies": {
-    "@datadog/native-appsec": "^1.2.0",
-    "@datadog/native-metrics": "^1.2.0",
-    "@datadog/pprof": "^0.4.0",
-    "@datadog/sketches-js": "^1.0.4",
+    "@datadog/native-appsec": "^1.2.1",
+    "@datadog/native-metrics": "^1.4.0",
+    "@datadog/pprof": "^0.5.1",
+    "@datadog/sketches-js": "^1.0.5",
     "@types/node": ">=12",
     "crypto-randomuuid": "^1.0.0",
     "diagnostics_channel": "^1.1.0",
@@ -106,8 +106,8 @@
     "jszip": "^3.5.0",
     "mkdirp": "^0.5.1",
     "mocha": "8",
-    "multer": "^1.4.2",
     "msgpack-lite": "^0.1.26",
+    "multer": "^1.4.5-lts.1",
     "nock": "^11.3.3",
     "nyc": "^15.1.0",
     "proxyquire": "^1.8.0",

package/packages/datadog-instrumentations/index.js

@@ -16,14 +16,18 @@ require('./src/fastify')
 require('./src/find-my-way')
 require('./src/generic-pool')
 require('./src/google-cloud-pubsub')
+require('./src/graphql')
+require('./src/grpc')
 require('./src/hapi')
 require('./src/http')
+require('./src/http2')
 require('./src/ioredis')
 require('./src/jest')
 require('./src/kafkajs')
 require('./src/knex')
 require('./src/koa')
 require('./src/memcached')
+require('./src/microgateway-core')
 require('./src/moleculer')
 require('./src/mongodb-core')
 require('./src/mongoose')
@@ -31,6 +35,7 @@ require('./src/mysql')
 require('./src/mysql2')
 require('./src/mocha')
 require('./src/net')
+require('./src/next')
 require('./src/oracledb')
 require('./src/paperplane')
 require('./src/pino')

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

@@ -4,6 +4,7 @@ const shimmer = require('../../datadog-shimmer')
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 
 const enterChannel = channel('apm:connect:middleware:enter')
+const exitChannel = channel('apm:connect:middleware:exit')
 const errorChannel = channel('apm:connect:middleware:error')
 const nextChannel = channel('apm:connect:middleware:next')
 const handleChannel = channel('apm:connect:request:handle')
@@ -80,6 +81,7 @@ function wrapLayerHandle (layer) {
       } catch (e) {
         errorChannel.publish(e)
         nextChannel.publish({ req })
+        exitChannel.publish({ req })
 
         throw e
       }
@@ -94,6 +96,7 @@ function wrapNext (req, next) {
     }
 
     nextChannel.publish({ req })
+    exitChannel.publish({ req })
 
     next.apply(null, arguments)
   }

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

@@ -85,8 +85,8 @@ function wrapAddHook (addHook) {
   }
 }
 
-function onRequest (request, reply, next) {
-  if (typeof next !== 'function') return
+function onRequest (request, reply, done) {
+  if (typeof done !== 'function') return
 
   const req = getReq(request)
   const res = getRes(reply)
@@ -96,37 +96,41 @@ function onRequest (request, reply, next) {
 
   return requestResource.runInAsyncScope(() => {
     handleChannel.publish({ req, res })
-    return next()
+    return done()
   })
 }
 
-function preHandler (request, reply, next) {
-  if (typeof next !== 'function') return
-  if (!reply || typeof reply.send !== 'function') return next()
+function preHandler (request, reply, done) {
+  if (typeof done !== 'function') return
+  if (!reply || typeof reply.send !== 'function') return done()
 
   const req = getReq(request)
   const requestResource = requestResources.get(req)
 
   reply.send = wrapSend(reply.send, requestResource)
 
-  next()
+  done()
 }
 
-function preValidation (request, reply, next) {
+function preValidation (request, reply, done) {
   const req = getReq(request)
   const parsingResource = parsingResources.get(req)
 
-  if (!parsingResource) return next()
+  if (!parsingResource) return done()
 
-  parsingResource.runInAsyncScope(() => next())
+  parsingResource.runInAsyncScope(() => done())
 }
 
-function preParsing (request, reply, next) {
+function preParsing (request, reply, payload, done) {
+  if (typeof done !== 'function') {
+    done = payload
+  }
+
   const req = getReq(request)
   const parsingResource = new AsyncResource('bound-anonymous-fn')
 
   parsingResources.set(req, parsingResource)
-  parsingResource.runInAsyncScope(() => next())
+  parsingResource.runInAsyncScope(() => done())
 }
 
 function wrapSend (send, resource) {
@@ -150,9 +154,11 @@ function getRes (reply) {
 }
 
 function publishError (error, resource) {
-  resource.runInAsyncScope(() => {
-    errorChannel.publish(error)
-  })
+  if (error) {
+    resource.runInAsyncScope(() => {
+      errorChannel.publish(error)
+    })
+  }
 
   return error
 }

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

@@ -0,0 +1,354 @@
+'use strict'
+
+const {
+  addHook,
+  channel,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+/** cached objects */
+
+const contexts = new WeakMap()
+const documentSources = new WeakMap()
+const patchedResolvers = new WeakSet()
+const patchedTypes = new WeakSet()
+
+/** CHANNELS */
+
+// execute channels
+const startResolveCh = channel('apm:graphql:resolve:start')
+const startExecuteCh = channel('apm:graphql:execute:start')
+const finishExecuteCh = channel('apm:graphql:execute:finish')
+const finishResolveCh = channel('apm:graphql:resolve:finish')
+const updateFieldCh = channel('apm:graphql:resolve:updateField')
+const executeErrorCh = channel('apm:graphql:execute:error')
+
+// parse channels
+const parseStartCh = channel('apm:graphql:parser:start')
+const parseFinishCh = channel('apm:graphql:parser:finish')
+const parseErrorCh = channel('apm:graphql:parser:error')
+
+// validate channels
+const validateStartCh = channel('apm:graphql:validate:start')
+const validateFinishCh = channel('apm:graphql:validate:finish')
+const validateErrorCh = channel('apm:graphql:validate:error')
+
+function getOperation (document, operationName) {
+  if (!document || !Array.isArray(document.definitions)) {
+    return
+  }
+
+  const definitions = document.definitions.filter(def => def)
+  const types = ['query', 'mutation', 'subscription']
+
+  if (operationName) {
+    return definitions
+      .filter(def => types.indexOf(def.operation) !== -1)
+      .find(def => operationName === (def.name && def.name.value))
+  } else {
+    return definitions.find(def => types.indexOf(def.operation) !== -1)
+  }
+}
+
+function normalizeArgs (args, defaultFieldResolver) {
+  if (args.length !== 1) return normalizePositional(args, defaultFieldResolver)
+
+  args[0].contextValue = args[0].contextValue || {}
+  args[0].fieldResolver = wrapResolve(args[0].fieldResolver || defaultFieldResolver)
+
+  return args[0]
+}
+
+function normalizePositional (args, defaultFieldResolver) {
+  args[3] = args[3] || {} // contextValue
+  args[6] = wrapResolve(args[6] || defaultFieldResolver) // fieldResolver
+  args.length = Math.max(args.length, 7)
+
+  return {
+    schema: args[0],
+    document: args[1],
+    rootValue: args[2],
+    contextValue: args[3],
+    variableValues: args[4],
+    operationName: args[5],
+    fieldResolver: args[6]
+  }
+}
+
+function wrapParse (parse) {
+  return function (source) {
+    if (!parseStartCh.hasSubscribers) {
+      return parse.apply(this, arguments)
+    }
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+    return asyncResource.runInAsyncScope(() => {
+      parseStartCh.publish()
+      let document
+      try {
+        document = parse.apply(this, arguments)
+        const operation = getOperation(document)
+
+        if (!operation) return document
+
+        if (source) {
+          documentSources.set(document, source.body || source)
+        }
+
+        return document
+      } catch (err) {
+        err.stack
+        parseErrorCh.publish(err)
+
+        throw err
+      } finally {
+        parseFinishCh.publish({ source, document, docSource: documentSources.get(document) })
+      }
+    })
+  }
+}
+
+function wrapValidate (validate) {
+  return function (_schema, document, _rules, _typeInfo) {
+    if (!validateStartCh.hasSubscribers) {
+      return validate.apply(this, arguments)
+    }
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+    return asyncResource.runInAsyncScope(() => {
+      validateStartCh.publish({ docSource: documentSources.get(document), document })
+
+      let errors
+      try {
+        errors = validate.apply(this, arguments)
+        validateErrorCh.publish(errors && errors[0])
+        return errors
+      } catch (err) {
+        err.stack
+        validateErrorCh.publish(err)
+
+        throw err
+      } finally {
+        validateFinishCh.publish({ document, errors })
+      }
+    })
+  }
+}
+
+function wrapExecute (execute) {
+  return function (exe) {
+    const defaultFieldResolver = execute.defaultFieldResolver
+    return function () {
+      if (!startExecuteCh.hasSubscribers) {
+        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)
+        }
+
+        if (schema) {
+          wrapFields(schema._queryType)
+          wrapFields(schema._mutationType)
+        }
+
+        startExecuteCh.publish({
+          operation,
+          args,
+          docSource: documentSources.get(document)
+        })
+
+        const context = { source, asyncResource, fields: {} }
+
+        contexts.set(contextValue, context)
+
+        return callInAsyncScope(exe, asyncResource, this, arguments, (err, res) => {
+          if (finishResolveCh.hasSubscribers) finishResolvers(context)
+
+          executeErrorCh.publish(err || (res && res.errors && res.errors[0]))
+          finishExecuteCh.publish({ res, args })
+        })
+      })
+    }
+  }
+}
+
+function wrapResolve (resolve) {
+  if (typeof resolve !== 'function' || patchedResolvers.has(resolve)) return resolve
+
+  function resolveAsync (source, args, contextValue, info) {
+    if (!startResolveCh.hasSubscribers) return resolve.apply(this, arguments)
+
+    const context = contexts.get(contextValue)
+
+    if (!context) return resolve.apply(this, arguments)
+
+    const field = assertField(context, info)
+
+    return callInAsyncScope(resolve, field.asyncResource, this, arguments, (err) => {
+      updateFieldCh.publish({ field, info, err })
+    })
+  }
+
+  patchedResolvers.add(resolveAsync)
+
+  return resolveAsync
+}
+
+function callInAsyncScope (fn, aR, thisArg, args, cb) {
+  cb = cb || (() => {})
+
+  return aR.runInAsyncScope(() => {
+    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
+    }
+  })
+}
+
+function pathToArray (path) {
+  const flattened = []
+  let curr = path
+  while (curr) {
+    flattened.push(curr.key)
+    curr = curr.prev
+  }
+  return flattened.reverse()
+}
+
+function assertField (context, info) {
+  const pathInfo = info && info.path
+
+  const path = pathToArray(pathInfo)
+
+  const pathString = path.join('.')
+  const fields = context.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
+        })
+      })
+
+      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
+    }
+  }
+
+  return {
+    asyncResource: context.asyncResource
+  }
+}
+
+function getField (context, path) {
+  return context.fields[path.join('.')]
+}
+
+function wrapFields (type) {
+  if (!type || !type._fields || patchedTypes.has(type)) {
+    return
+  }
+
+  patchedTypes.add(type)
+
+  Object.keys(type._fields).forEach(key => {
+    const field = type._fields[key]
+
+    wrapFieldResolve(field)
+    wrapFieldType(field)
+  })
+}
+
+function wrapFieldResolve (field) {
+  if (!field || !field.resolve) return
+  field.resolve = wrapResolve(field.resolve)
+}
+
+function wrapFieldType (field) {
+  if (!field || !field.type) return
+
+  let unwrappedType = field.type
+
+  while (unwrappedType.ofType) {
+    unwrappedType = unwrappedType.ofType
+  }
+
+  wrapFields(unwrappedType)
+}
+
+function finishResolvers ({ fields }) {
+  Object.keys(fields).reverse().forEach(key => {
+    const field = fields[key]
+    const asyncResource = field.asyncResource
+    asyncResource.runInAsyncScope(() => {
+      executeErrorCh.publish(field.error)
+      finishResolveCh.publish(field.finishTime)
+    })
+  })
+}
+
+addHook({ name: 'graphql', file: 'execution/execute.js', versions: ['>=0.10'] }, execute => {
+  shimmer.wrap(execute, 'execute', wrapExecute(execute))
+  return execute
+})
+
+addHook({ name: 'graphql', file: 'language/parser.js', versions: ['>=0.10'] }, parser => {
+  shimmer.wrap(parser, 'parse', wrapParse)
+  return parser
+})
+
+addHook({ name: 'graphql', file: 'validation/validate.js', versions: ['>=0.10'] }, validate => {
+  shimmer.wrap(validate, 'validate', wrapValidate)
+
+  return validate
+})