dd-trace 2.8.0 → 2.9.1

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.9.1",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",

package/packages/datadog-core/src/storage/async_resource.js

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

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

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

@@ -89,7 +89,10 @@ function wrapMiddleware (fn, layer) {
     const req = ctx.req
 
     return middlewareResource.runInAsyncScope(() => {
-      enterChannel.publish({ req, name })
+      const path = layer && layer.path
+      const route = path !== '(.*)' && path !== '([^/]*)' && path
+
+      enterChannel.publish({ req, name, route })
 
       if (typeof next === 'function') {
         arguments[1] = next
@@ -101,33 +104,33 @@ function wrapMiddleware (fn, layer) {
         if (result && typeof result.then === 'function') {
           return result.then(
             result => {
-              fulfill(ctx, layer)
+              fulfill(ctx)
               return result
             },
             err => {
-              fulfill(ctx, layer, err)
+              fulfill(ctx, err)
               throw err
             }
           )
         } else {
-          fulfill(ctx, layer)
+          fulfill(ctx)
           return result
         }
       } catch (e) {
-        fulfill(ctx, layer, e)
+        fulfill(ctx, e)
         throw e
       }
     })
   }
 }
 
-function fulfill (ctx, layer, error) {
+function fulfill (ctx, error) {
   if (error) {
     errorChannel.publish(error)
   }
 
   const req = ctx.req
-  const route = ctx.routePath || (layer && layer.path)
+  const route = ctx.routePath
 
   // TODO: make sure that the parent class cannot override this in `enter`
   if (route) {

package/packages/datadog-plugin-http2/src/server.js

@@ -22,6 +22,7 @@ const HTTP_STATUS_CODE = tags.HTTP_STATUS_CODE
 const HTTP_ROUTE = tags.HTTP_ROUTE
 const HTTP_REQUEST_HEADERS = tags.HTTP_REQUEST_HEADERS
 const HTTP_RESPONSE_HEADERS = tags.HTTP_RESPONSE_HEADERS
+const HTTP_USERAGENT = tags.HTTP_USERAGENT
 const MANUAL_DROP = tags.MANUAL_DROP
 
 const HTTP_STATUS_OK = 200
@@ -141,7 +142,8 @@ function addRequestTags (stream, headers) {
     [HTTP_METHOD]: headers[HTTP2_HEADER_METHOD],
     [HTTP_URL]: url.split('?')[0],
     [SPAN_KIND]: SERVER,
-    [SPAN_TYPE]: WEB
+    [SPAN_TYPE]: WEB,
+    [HTTP_USERAGENT]: headers['user-agent']
   })
 }
 

package/packages/datadog-plugin-mysql/src/index.js

@@ -12,25 +12,26 @@ class MySQLPlugin extends Plugin {
   constructor (...args) {
     super(...args)
 
-    this.addSub(`apm:${this.constructor.name}:query:start`, ({ sql, conf }) => {
+    this.addSub(`apm:${this.constructor.name}:query:start`, ({ sql, conf: dbConfig }) => {
+      const service = getServiceName(this.tracer, this.config, dbConfig)
       const store = storage.getStore()
       const childOf = store ? store.span : store
       const span = this.tracer.startSpan('mysql.query', {
         childOf,
         tags: {
-          'service.name': this.config.service || `${this.tracer._service}-mysql`,
+          'service.name': service,
           'span.type': 'sql',
           'span.kind': 'client',
           'db.type': 'mysql',
-          'db.user': conf.user,
-          'out.host': conf.host,
-          'out.port': conf.port,
+          'db.user': dbConfig.user,
+          'out.host': dbConfig.host,
+          'out.port': dbConfig.port,
           'resource.name': sql
         }
       })
 
-      if (conf.database) {
-        span.setTag('db.name', conf.database)
+      if (dbConfig.database) {
+        span.setTag('db.name', dbConfig.database)
       }
 
       analyticsSampler.sample(span, this.config.measured)
@@ -51,4 +52,14 @@ class MySQLPlugin extends Plugin {
   }
 }
 
+function getServiceName (tracer, config, dbConfig) {
+  if (typeof config.service === 'function') {
+    return config.service(dbConfig)
+  } else if (config.service) {
+    return config.service
+  } else {
+    return `${tracer._service}-mysql`
+  }
+}
+
 module.exports = MySQLPlugin

package/packages/dd-trace/lib/version.js

@@ -1 +1 @@
-module.exports = '2.8.0'
+module.exports = '2.9.1'

package/packages/dd-trace/src/appsec/index.js

@@ -47,15 +47,15 @@ function incomingHttpStartTranslator (data) {
       '_dd.runtime_family': 'nodejs'
     })
   }
+}
 
+function incomingHttpEndTranslator (data) {
   const store = Gateway.startContext()
 
   store.set('req', data.req)
   store.set('res', data.res)
-}
 
-function incomingHttpEndTranslator (data) {
-  const context = Gateway.getContext()
+  const context = store.get('context')
 
   if (!context) return
 

package/packages/dd-trace/src/plugins/util/web.js

@@ -23,6 +23,7 @@ const HTTP_STATUS_CODE = tags.HTTP_STATUS_CODE
 const HTTP_ROUTE = tags.HTTP_ROUTE
 const HTTP_REQUEST_HEADERS = tags.HTTP_REQUEST_HEADERS
 const HTTP_RESPONSE_HEADERS = tags.HTTP_RESPONSE_HEADERS
+const HTTP_USERAGENT = tags.HTTP_USERAGENT
 const MANUAL_DROP = tags.MANUAL_DROP
 
 const HTTP2_HEADER_AUTHORITY = ':authority'
@@ -412,7 +413,8 @@ function addRequestTags (context) {
     [HTTP_URL]: url.split('?')[0],
     [HTTP_METHOD]: req.method,
     [SPAN_KIND]: SERVER,
-    [SPAN_TYPE]: WEB
+    [SPAN_TYPE]: WEB,
+    [HTTP_USERAGENT]: req.headers['user-agent']
   })
 
   addHeaders(context)

package/scripts/install_plugin_modules.js

@@ -78,15 +78,13 @@ async function assertVersions () {
   const externalNames = Object.keys(externals).filter(name => ~names.indexOf(name))
   for (const name of externalNames) {
     for (const inst of [].concat(externals[name])) {
-      if (!inst.dep) {
-        await assertInstrumentation(inst, true)
-      }
+      await assertInstrumentation(inst, true)
     }
   }
 }
 
 async function assertInstrumentation (instrumentation, external) {
-  const versions = [].concat(instrumentation.versions)
+  const versions = [].concat(instrumentation.versions || [])
   for (const version of versions) {
     if (version) {
       await assertModules(instrumentation.name, semver.coerce(version).version, external)