dd-trace 2.8.0 → 2.10.0

package/ci/init.js

@@ -1,3 +1,5 @@
+/* eslint-disable no-console */
+
 const path = require('path')
 const tracer = require('../packages/dd-trace')
 const { ORIGIN_KEY } = require('../packages/dd-trace/src/constants')
@@ -11,9 +13,22 @@ const options = {
   }
 }
 
-if (process.env.DD_CIVISIBILITY_AGENTLESS_ENABLED && (process.env.DATADOG_API_KEY || process.env.DD_API_KEY)) {
-  options.experimental = {
-    exporter: 'datadog'
+let shouldInit = true
+
+const isAgentlessEnabled = process.env.DD_CIVISIBILITY_AGENTLESS_ENABLED &&
+  process.env.DD_CIVISIBILITY_AGENTLESS_ENABLED !== 'false' &&
+  process.env.DD_CIVISIBILITY_AGENTLESS_ENABLED !== '0'
+
+if (isAgentlessEnabled) {
+  if (process.env.DATADOG_API_KEY || process.env.DD_API_KEY) {
+    options.experimental = {
+      exporter: 'datadog'
+    }
+  } else {
+    console.error(`DD_CIVISIBILITY_AGENTLESS_ENABLED is set, \
+but neither DD_API_KEY nor DATADOG_API_KEY are set in your environment, \
+so dd-trace will not be initialized.`)
+    shouldInit = false
   }
 }
 
@@ -36,8 +51,9 @@ try {
   // ignore error and let the tracer initialize anyway
 }
 
-tracer.init(options)
-
-tracer.use('fs', false)
+if (shouldInit) {
+  tracer.init(options)
+  tracer.use('fs', false)
+}
 
 module.exports = tracer

package/ci/jest/env.js

@@ -1,3 +1,5 @@
+/* eslint-disable no-console */
+
 const tracer = require('../../packages/dd-trace')
 const { ORIGIN_KEY } = require('../../packages/dd-trace/src/constants')
 
@@ -8,13 +10,23 @@ const options = {
   }
 }
 
-if (process.env.DD_CIVISIBILITY_AGENTLESS_ENABLED && (process.env.DATADOG_API_KEY || process.env.DD_API_KEY)) {
-  tracer.init({
-    ...options,
-    experimental: {
-      exporter: 'datadog'
-    }
-  })
+const isAgentlessEnabled = process.env.DD_CIVISIBILITY_AGENTLESS_ENABLED &&
+  process.env.DD_CIVISIBILITY_AGENTLESS_ENABLED !== 'false' &&
+  process.env.DD_CIVISIBILITY_AGENTLESS_ENABLED !== '0'
+
+if (isAgentlessEnabled) {
+  if (process.env.DATADOG_API_KEY || process.env.DD_API_KEY) {
+    tracer.init({
+      ...options,
+      experimental: {
+        exporter: 'datadog'
+      }
+    })
+  } else {
+    console.error(`DD_CIVISIBILITY_AGENTLESS_ENABLED is set, \
+but neither DD_API_KEY nor DATADOG_API_KEY are set in your environment, \
+so dd-trace will not be initialized.`)
+  }
 } else {
   tracer.init({
     ...options,

package/ext/tags.d.ts

@@ -15,6 +15,7 @@ declare const tags: {
   HTTP_ROUTE: 'http.route'
   HTTP_REQUEST_HEADERS: 'http.request.headers'
   HTTP_RESPONSE_HEADERS: 'http.response.headers'
+  HTTP_USERAGENT: 'http.useragent'
 }
 
 export = tags

package/ext/tags.js

@@ -19,7 +19,8 @@ const tags = {
   HTTP_STATUS_CODE: 'http.status_code',
   HTTP_ROUTE: 'http.route',
   HTTP_REQUEST_HEADERS: 'http.request.headers',
-  HTTP_RESPONSE_HEADERS: 'http.response.headers'
+  HTTP_RESPONSE_HEADERS: 'http.response.headers',
+  HTTP_USERAGENT: 'http.useragent'
 }
 
 // Deprecated

package/index.d.ts

@@ -1210,13 +1210,15 @@ declare namespace plugins {
    * This plugin automatically instruments the
    * [mysql](https://github.com/mysqljs/mysql) module.
    */
-  interface mysql extends Instrumentation {}
+  interface mysql extends Instrumentation {
+    service?: string | ((params: any) => string);
+  }
 
   /**
    * This plugin automatically instruments the
    * [mysql2](https://github.com/brianmario/mysql2) module.
    */
-  interface mysql2 extends Instrumentation {}
+  interface mysql2 extends mysql {}
 
   /**
    * This plugin automatically instruments the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "2.8.0",
+  "version": "2.10.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -59,9 +59,9 @@
   },
   "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-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-core/src/storage/async_resource.js

@@ -69,7 +69,7 @@ class AsyncResourceStorage {
   }
 
   _executionAsyncResource () {
-    return executionAsyncResource()
+    return executionAsyncResource() || {}
   }
 }
 

package/packages/datadog-instrumentations/index.js

@@ -16,6 +16,7 @@ require('./src/fastify')
 require('./src/find-my-way')
 require('./src/generic-pool')
 require('./src/google-cloud-pubsub')
+require('./src/graphql')
 require('./src/hapi')
 require('./src/http')
 require('./src/ioredis')

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

@@ -15,13 +15,14 @@ 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')
 
-    this.on('complete', response => {
-      channel(`apm:aws:request:complete:${channelSuffix}`).publish({ response })
-    })
+    return innerAr.runInAsyncScope(() => {
+      this.on('complete', innerAr.bind(response => {
+        channel(`apm:aws:request:complete:${channelSuffix}`).publish({ response })
+      }))
 
-    return new AsyncResource('apm:aws:request:inner').runInAsyncScope(() => {
       startCh.publish({
         serviceIdentifier,
         operation: this.operation,

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

@@ -1,6 +1,5 @@
 'use strict'
 
-const methods = require('methods').concat('all')
 const shimmer = require('../../datadog-shimmer')
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 
@@ -8,26 +7,28 @@ const errorChannel = channel('apm:fastify:middleware:error')
 const handleChannel = channel('apm:fastify:request:handle')
 
 const requestResources = new WeakMap()
+const parsingResources = new WeakMap()
 
-function wrapFastify (fastify) {
+function wrapFastify (fastify, hasParsingEvents) {
   if (typeof fastify !== 'function') return fastify
 
   return function fastifyWithTrace () {
     const app = fastify.apply(this, arguments)
 
-    if (!app) return app
+    if (!app || typeof app.addHook !== 'function') return app
 
-    if (typeof app.addHook === 'function') {
-      app.addHook('onRequest', onRequest)
-      app.addHook = wrapAddHook(app.addHook)
-      app.addHook('preHandler', preHandler)
-    }
+    app.addHook('onRequest', onRequest)
+    app.addHook('preHandler', preHandler)
 
-    methods.forEach(method => {
-      app[method] = wrapMethod(app[method])
-    })
+    if (hasParsingEvents) {
+      app.addHook('preParsing', preParsing)
+      app.addHook('preValidation', preValidation)
+    } else {
+      app.addHook('onRequest', preParsing)
+      app.addHook('preHandler', preValidation)
+    }
 
-    app.route = wrapRoute(app.route)
+    app.addHook = wrapAddHook(app.addHook)
 
     return app
   }
@@ -45,114 +46,102 @@ function wrapAddHook (addHook) {
 
       if (!requestResource) return fn.apply(this, arguments)
 
-      return requestResource.runInAsyncScope(() => {
-        const hookResource = new AsyncResource('bound-anonymous-fn')
+      try {
+        if (typeof done === 'function') {
+          done = arguments[arguments.length - 1]
 
-        try {
-          if (typeof done === 'function') {
-            done = arguments[arguments.length - 1]
+          arguments[arguments.length - 1] = function (err) {
+            publishError(err, requestResource)
 
-            arguments[arguments.length - 1] = hookResource.bind(function (err) {
-              errorChannel.publish(err)
-              return done.apply(this, arguments)
-            })
+            if (name === 'onRequest' || name === 'preParsing') {
+              const parsingResource = new AsyncResource('bound-anonymous-fn')
 
-            return hookResource.bind(fn).apply(this, arguments)
-          } else {
-            const promise = hookResource.bind(fn).apply(this, arguments)
+              parsingResources.set(req, parsingResource)
 
-            if (promise && typeof promise.catch === 'function') {
-              return promise.catch(err => {
-                errorChannel.publish(err)
-                throw err
+              return parsingResource.runInAsyncScope(() => {
+                return done.apply(this, arguments)
               })
+            } else {
+              return done.apply(this, arguments)
             }
+          }
 
-            return promise
+          return fn.apply(this, arguments)
+        } else {
+          const promise = fn.apply(this, arguments)
+
+          if (promise && typeof promise.catch === 'function') {
+            return promise.catch(err => publishError(err, requestResource))
           }
-        } catch (e) {
-          errorChannel.publish(e)
-          throw e
+
+          return promise
         }
-      })
+      } catch (e) {
+        throw publishError(e, requestResource)
+      }
     })
 
     return addHook.apply(this, arguments)
   }
 }
 
-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)
+  const requestResource = new AsyncResource('bound-anonymous-fn')
 
-  requestResources.set(req, new AsyncResource('bound-anonymous-fn'))
-  handleChannel.publish({ req, res })
+  requestResources.set(req, requestResource)
 
-  return next()
+  return requestResource.runInAsyncScope(() => {
+    handleChannel.publish({ req, res })
+    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 = requestResources.get(req).bind(wrapSend(reply.send))
+  reply.send = wrapSend(reply.send, requestResource)
 
-  next()
+  done()
 }
 
-function wrapSend (send) {
-  return function sendWithTrace (payload) {
-    if (payload instanceof Error) {
-      errorChannel.publish(payload)
-    }
-
-    return send.apply(this, arguments)
-  }
-}
-
-function wrapRoute (route) {
-  if (typeof route !== 'function') return route
+function preValidation (request, reply, done) {
+  const req = getReq(request)
+  const parsingResource = parsingResources.get(req)
 
-  return function routeWithTrace (opts) {
-    opts.handler = wrapHandler(opts.handler)
+  if (!parsingResource) return done()
 
-    return route.apply(this, arguments)
-  }
+  parsingResource.runInAsyncScope(() => done())
 }
 
-function wrapMethod (method) {
-  if (typeof method !== 'function') return method
-
-  return function methodWithTrace (url, opts, handler) {
-    const lastIndex = arguments.length - 1
-
-    handler = arguments[lastIndex]
+function preParsing (request, reply, payload, done) {
+  if (typeof done !== 'function') {
+    done = payload
+  }
 
-    if (typeof handler === 'function') {
-      arguments[lastIndex] = wrapHandler(handler)
-    } else if (handler) {
-      arguments[lastIndex].handler = wrapHandler(handler.handler)
-    }
+  const req = getReq(request)
+  const parsingResource = new AsyncResource('bound-anonymous-fn')
 
-    return method.apply(this, arguments)
-  }
+  parsingResources.set(req, parsingResource)
+  parsingResource.runInAsyncScope(() => done())
 }
 
-function wrapHandler (handler) {
-  if (!handler || typeof handler !== 'function' || handler.name === 'handlerWithTrace') {
-    return handler
-  }
-
-  return function handlerWithTrace (request, reply) {
-    const req = getReq(request)
+function wrapSend (send, resource) {
+  return function sendWithTrace (payload) {
+    if (payload instanceof Error) {
+      resource.runInAsyncScope(() => {
+        errorChannel.publish(payload)
+      })
+    }
 
-    return requestResources.get(req).runInAsyncScope(() => {
-      return handler.apply(this, arguments)
-    })
+    return send.apply(this, arguments)
   }
 }
 
@@ -164,16 +153,15 @@ function getRes (reply) {
   return reply && (reply.raw || reply.res || reply)
 }
 
-addHook({ name: 'fastify', versions: ['>=3.25.2'] }, fastify => {
-  const wrapped = shimmer.wrap(fastify, wrapFastify(fastify, false))
-
-  wrapped.fastify = wrapped
-  wrapped.default = wrapped
+function publishError (error, resource) {
+  resource.runInAsyncScope(() => {
+    errorChannel.publish(error)
+  })
 
-  return wrapped
-})
+  return error
+}
 
-addHook({ name: 'fastify', versions: ['3 - 3.25.1'] }, fastify => {
+addHook({ name: 'fastify', versions: ['>=3'] }, fastify => {
   const wrapped = shimmer.wrap(fastify, wrapFastify(fastify, true))
 
   wrapped.fastify = wrapped
@@ -182,6 +170,10 @@ addHook({ name: 'fastify', versions: ['3 - 3.25.1'] }, fastify => {
   return wrapped
 })
 
-addHook({ name: 'fastify', versions: ['1 - 2'] }, fastify => {
+addHook({ name: 'fastify', versions: ['2'] }, fastify => {
   return shimmer.wrap(fastify, wrapFastify(fastify, true))
 })
+
+addHook({ name: 'fastify', versions: ['1'] }, fastify => {
+  return shimmer.wrap(fastify, wrapFastify(fastify, false))
+})