dd-trace 2.7.1 → 2.9.1

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

@@ -31,10 +31,6 @@ class HttpServerPlugin extends Plugin {
       }
     })
 
-    this.addSub('apm:http:server:request:end', () => {
-      this.exit()
-    })
-
     this.addSub('apm:http:server:request:error', (error) => {
       const span = storage.getStore().span
       span.addTags({

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-jest/src/index.js

@@ -48,15 +48,14 @@ class JestPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub('ci:jest:test:end', (status) => {
+    this.addSub('ci:jest:test:finish', (status) => {
       const span = storage.getStore().span
       span.setTag(TEST_STATUS, status)
       span.finish()
       finishAllTraceSpans(span)
-      this.exit()
     })
 
-    this.addSub('ci:jest:test-suite:end', () => {
+    this.addSub('ci:jest:test-suite:finish', () => {
       this.tracer._exporter._writer.flush()
     })
 

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

@@ -60,10 +60,6 @@ class KafkajsPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub(`apm:kafkajs:end`, () => {
-      this.exit()
-    })
-
     this.addSub(`apm:kafkajs:consume:error`, errorHandler)
 
     this.addSub(`apm:kafkajs:consume:finish`, finishHandler)

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

@@ -28,10 +28,6 @@ class MemcachedPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub('apm:memcached:command:end', () => {
-      this.exit()
-    })
-
     this.addSub('apm:memcached:command:start:with-args', ({ client, server, query }) => {
       const span = storage.getStore().span
       span.addTags({
@@ -54,7 +50,7 @@ class MemcachedPlugin extends Plugin {
       span.setTag('error', err)
     })
 
-    this.addSub('apm:memcached:command:async-end', () => {
+    this.addSub('apm:memcached:command:finish', () => {
       const span = storage.getStore().span
       span.finish()
     })

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

@@ -56,7 +56,7 @@ class MochaPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub('ci:mocha:test:async-end', (status) => {
+    this.addSub('ci:mocha:test:finish', (status) => {
       // if the status is skipped the span has already been finished
       if (status === 'skipped') {
         return
@@ -69,10 +69,6 @@ class MochaPlugin extends Plugin {
       finishAllTraceSpans(span)
     })
 
-    this.addSub('ci:mocha:test:end', () => {
-      this.exit()
-    })
-
     // This covers programmatically skipped tests (that do go through `runTest`)
     this.addSub('ci:mocha:test:skip', () => {
       const span = storage.getStore().span
@@ -92,7 +88,7 @@ class MochaPlugin extends Plugin {
       }
     })
 
-    this.addSub('ci:mocha:suite:end', tests => {
+    this.addSub('ci:mocha:suite:finish', tests => {
       tests.forEach(test => {
         const { pending: isSkipped } = test
         // `tests` includes every test, so we need a way to mark
@@ -121,7 +117,7 @@ class MochaPlugin extends Plugin {
       this._testNameToParams[name] = params
     })
 
-    this.addSub('ci:mocha:run:end', () => {
+    this.addSub('ci:mocha:run:finish', () => {
       this.tracer._exporter._writer.flush()
     })
   }

package/packages/datadog-plugin-moleculer/src/client.js

@@ -1,60 +1,50 @@
 'use strict'
 
+const { storage } = require('../../datadog-core')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
 const { moleculerTags } = require('./util')
 
-function createWrapCall (tracer, config) {
-  return function wrapCall (call) {
-    return function callWithTrace (actionName, params, opts) {
-      const options = {
-        service: config.service,
-        resource: actionName,
+class MoleculerClientPlugin extends Plugin {
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:moleculer:call:start', ({ actionName, params, opts }) => {
+      const store = storage.getStore()
+      const childOf = store && store.span
+      const span = this.tracer.startSpan('moleculer.call', {
+        childOf,
         tags: {
-          'span.kind': 'client'
+          'service.name': this.config.service || this.tracer._service,
+          'span.kind': 'client',
+          'resource.name': actionName
         }
-      }
-
-      opts = arguments[2] = opts || {}
-      opts.meta = opts.meta || {}
+      })
 
-      arguments.length = Math.max(3, arguments.length)
+      this.tracer.inject(span, 'text_map', opts.meta)
 
-      return tracer.trace('moleculer.call', options, () => {
-        const span = tracer.scope().active()
+      this.enter(span, store)
+    })
 
-        tracer.inject(span, 'text_map', opts.meta)
+    this.addSub('apm:moleculer:call:finish', ({ broker, ctx }) => {
+      const store = storage.getStore()
+      const span = store.span
 
-        const promise = call.apply(this, arguments)
+      if (ctx) {
+        const endpoint = ctx.endpoint || {}
+        const node = endpoint.node || {}
 
-        if (promise.ctx) {
-          const endpoint = promise.ctx.endpoint || {}
-          const node = endpoint.node || {}
+        span.addTags({
+          'out.host': node.hostname,
+          'out.port': node.port,
+          ...moleculerTags(broker, ctx, this.config)
+        })
+      }
 
-          span.addTags({
-            'out.host': node.hostname,
-            'out.port': node.port,
-            ...moleculerTags(this, promise.ctx, config)
-          })
-        }
+      span.finish()
+    })
 
-        return promise
-      })
-    }
+    this.addSub('apm:moleculer:call:error', this.addError)
   }
 }
 
-module.exports = [
-  {
-    name: 'moleculer',
-    versions: ['>=0.14'],
-    patch ({ ServiceBroker }, tracer, config) {
-      if (config.client === false) return
-
-      config = Object.assign({}, config, config.client)
-
-      this.wrap(ServiceBroker.prototype, 'call', createWrapCall(tracer, config))
-    },
-    unpatch ({ ServiceBroker }) {
-      this.unwrap(ServiceBroker.prototype, 'call')
-    }
-  }
-]
+module.exports = MoleculerClientPlugin

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

@@ -2,7 +2,36 @@
 
 // TODO: support https://moleculer.services/docs/0.13/actions.html#Streaming
 
-const client = require('./client')
-const server = require('./server')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const MoleculerServerPlugin = require('./server')
+const MoleculerClientPlugin = require('./client')
 
-module.exports = [].concat(client, server)
+class MoleculerPlugin extends Plugin {
+  static get name () {
+    return 'moleculer'
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.server = new MoleculerServerPlugin(...args)
+    this.client = new MoleculerClientPlugin(...args)
+  }
+
+  configure (config) {
+    const clientConfig = config.client === false ? false : {
+      ...config,
+      ...config.client
+    }
+
+    const serverConfig = config.server === false ? false : {
+      ...config,
+      ...config.server
+    }
+
+    this.server.configure(serverConfig)
+    this.client.configure(clientConfig)
+  }
+}
+
+module.exports = MoleculerPlugin

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

@@ -1,61 +1,39 @@
 'use strict'
 
+const { storage } = require('../../datadog-core')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
 const { moleculerTags } = require('./util')
 
-function createWrapRegisterMiddlewares (tracer, config) {
-  return function wrapRegisterMiddlewares (registerMiddlewares) {
-    return function registerMiddlewaresWithTrace (userMiddlewares) {
-      if (this.middlewares && this.middlewares.add) {
-        this.middlewares.add(createMiddleware(tracer, config))
-      }
+class MoleculerServerPlugin extends Plugin {
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:moleculer:action:start', ({ action, ctx, broker }) => {
+      const store = storage.getStore()
+      const followsFrom = this.tracer.extract('text_map', ctx.meta)
+      const span = this.tracer.startSpan('moleculer.action', {
+        childOf: followsFrom || (store && store.span),
+        tags: {
+          'service.name': this.config.service || this.tracer._service,
+          'span.type': 'web',
+          'span.kind': 'server',
+          'resource.name': action.name,
+          ...moleculerTags(broker, ctx, this.config)
+        }
+      })
 
-      return registerMiddlewares.apply(this, arguments)
-    }
-  }
-}
+      this.enter(span, store)
+    })
 
-function createMiddleware (tracer, config) {
-  return {
-    name: 'Datadog',
-
-    localAction (next, action) {
-      const broker = this
-
-      return function datadogMiddleware (ctx) {
-        const childOf = tracer.extract('text_map', ctx.meta)
-        const options = {
-          service: config.service,
-          resource: action.name,
-          type: 'web',
-          tags: {
-            'span.kind': 'server',
-            ...moleculerTags(broker, ctx, config)
-          }
-        }
+    this.addSub('apm:moleculer:action:finish', () => {
+      const store = storage.getStore()
+      const span = store.span
 
-        if (childOf) {
-          options.childOf = childOf
-        }
+      span.finish()
+    })
 
-        return tracer.trace('moleculer.action', options, () => next(ctx))
-      }
-    }
+    this.addSub('apm:moleculer:action:error', this.addError)
   }
 }
 
-module.exports = [
-  {
-    name: 'moleculer',
-    versions: ['>=0.14'],
-    patch ({ ServiceBroker }, tracer, config) {
-      if (config.server === false) return
-
-      config = Object.assign({}, config, config.server)
-
-      this.wrap(ServiceBroker.prototype, 'registerMiddlewares', createWrapRegisterMiddlewares(tracer, config))
-    },
-    unpatch ({ ServiceBroker }) {
-      this.unwrap(ServiceBroker.prototype, 'registerMiddlewares')
-    }
-  }
-]
+module.exports = MoleculerServerPlugin

package/packages/datadog-plugin-mongodb-core/src/index.js

@@ -43,15 +43,11 @@ class MongodbCorePlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub(`apm:mongodb:query:end`, () => {
-      this.exit()
-    })
-
     this.addSub(`apm:mongodb:query:error`, err => {
       storage.getStore().span.setTag('error', err)
     })
 
-    this.addSub(`apm:mongodb:query:async-end`, () => {
+    this.addSub(`apm:mongodb:query:finish`, () => {
       storage.getStore().span.finish()
     })
   }

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

@@ -12,35 +12,32 @@ 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)
       this.enter(span, store)
     })
 
-    this.addSub(`apm:${this.constructor.name}:query:end`, () => {
-      this.exit()
-    })
-
     this.addSub(`apm:${this.constructor.name}:query:error`, err => {
       if (err) {
         const span = storage.getStore().span
@@ -48,11 +45,21 @@ class MySQLPlugin extends Plugin {
       }
     })
 
-    this.addSub(`apm:${this.constructor.name}:query:async-end`, () => {
+    this.addSub(`apm:${this.constructor.name}:query:finish`, () => {
       const span = storage.getStore().span
       span.finish()
     })
   }
 }
 
+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/datadog-plugin-net/src/index.js

@@ -30,11 +30,9 @@ class NetPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub(`apm:net:ipc:end`, this.exit.bind(this))
-
     this.addSub(`apm:net:ipc:error`, errorHandler)
 
-    this.addSub(`apm:net:ipc:async-end`, defaultAsyncEnd)
+    this.addSub(`apm:net:ipc:finish`, defaultFinish)
 
     this.addSub(`apm:net:tcp:start`, ({ options }) => {
       const store = storage.getStore()
@@ -62,11 +60,9 @@ class NetPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub(`apm:net:tcp:end`, this.exit.bind(this))
-
     this.addSub(`apm:net:tcp:error`, errorHandler)
 
-    this.addSub(`apm:net:tcp:async-end`, defaultAsyncEnd)
+    this.addSub(`apm:net:tcp:finish`, defaultFinish)
 
     this.addSub(`apm:net:tcp:connection`, ({ socket }) => {
       const span = storage.getStore().span
@@ -78,7 +74,7 @@ class NetPlugin extends Plugin {
   }
 }
 
-function defaultAsyncEnd () {
+function defaultFinish () {
   storage.getStore().span.finish()
 }
 

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

@@ -40,16 +40,12 @@ class PGPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub(`apm:pg:query:end`, () => {
-      this.exit()
-    })
-
     this.addSub(`apm:pg:query:error`, err => {
       const span = storage.getStore().span
       span.setTag('error', err)
     })
 
-    this.addSub(`apm:pg:query:async-end`, () => {
+    this.addSub(`apm:pg:query:finish`, () => {
       const span = storage.getStore().span
       span.finish()
     })

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

@@ -55,16 +55,12 @@ class RedisPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub(`apm:${this.constructor.name}:command:end`, () => {
-      this.exit()
-    })
-
     this.addSub(`apm:${this.constructor.name}:command:error`, err => {
       const span = storage.getStore().span
       span.setTag('error', err)
     })
 
-    this.addSub(`apm:${this.constructor.name}:command:async-end`, () => {
+    this.addSub(`apm:${this.constructor.name}:command:finish`, () => {
       const span = storage.getStore().span
       span.finish()
     })

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

@@ -61,15 +61,11 @@ class RheaPlugin extends Plugin {
       storage.getStore().span.setTag('error', error)
     })
 
-    this.addSub(`apm:rhea:async-end`, () => {
+    this.addSub(`apm:rhea:finish`, () => {
       const span = storage.getStore().span
       span.finish()
     })
 
-    this.addSub(`apm:rhea:end`, () => {
-      this.exit()
-    })
-
     this.addSub(`apm:rhea:dispatch`, ({ state }) => {
       const span = storage.getStore().span
       span.setTag('amqp.delivery.state', state)

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

@@ -26,7 +26,7 @@ class RouterPlugin extends WebPlugin {
       web.setRoute(req, context.route)
     })
 
-    this.addSub(`apm:${this.constructor.name}:middleware:exit`, ({ req }) => {
+    this.addSub(`apm:${this.constructor.name}:middleware:next`, ({ req }) => {
       const context = this._contexts.get(req)
 
       if (!context) return

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

@@ -31,16 +31,12 @@ class SharedbPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub(`apm:sharedb:request:end`, () => {
-      this.exit()
-    })
-
     this.addSub(`apm:sharedb:request:error`, err => {
       const span = storage.getStore().span
       span.setTag('error', err)
     })
 
-    this.addSub(`apm:sharedb:request:async-end`, ({ request, res }) => {
+    this.addSub(`apm:sharedb:request:finish`, ({ request, res }) => {
       const span = storage.getStore().span
       if (this.config.hooks && this.config.hooks.reply) {
         this.config.hooks.reply(span, request, res)

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

@@ -35,16 +35,12 @@ class TediousPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub(`apm:tedious:request:end`, () => {
-      this.exit()
-    })
-
     this.addSub(`apm:tedious:request:error`, err => {
       const span = storage.getStore().span
       span.setTag('error', err)
     })
 
-    this.addSub(`apm:tedious:request:async-end`, () => {
+    this.addSub(`apm:tedious:request:finish`, () => {
       const span = storage.getStore().span
       span.finish()
     })

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

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

package/packages/dd-trace/src/appsec/callbacks/ddwaf.js

@@ -33,10 +33,11 @@ class WAFCallback {
 
     Reporter.metricsQueue.set('_dd.appsec.waf.version', `${version.major}.${version.minor}.${version.patch}`)
 
-    const { loaded, failed } = this.ddwaf.rulesInfo
+    const { loaded, failed, errors } = this.ddwaf.rulesInfo
 
     Reporter.metricsQueue.set('_dd.appsec.event_rules.loaded', loaded)
     Reporter.metricsQueue.set('_dd.appsec.event_rules.error_count', failed)
+    if (failed) Reporter.metricsQueue.set('_dd.appsec.event_rules.errors', JSON.stringify(errors))
 
     Reporter.metricsQueue.set('manual.keep', true)
 

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/encode/agentless-ci-visibility.js

@@ -2,6 +2,7 @@
 const { truncateSpan, normalizeSpan } = require('./tags-processors')
 const Chunk = require('./chunk')
 const { AgentEncoder } = require('./0.4')
+const { version: ddTraceVersion } = require('../../../../package.json')
 
 const ENCODING_VERSION = 1
 
@@ -156,7 +157,8 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
       version: ENCODING_VERSION,
       metadata: {
         '*': {
-          'language': 'javascript'
+          'language': 'javascript',
+          'library_version': ddTraceVersion
         }
       },
       events: []

package/packages/dd-trace/src/plugins/plugin.js

@@ -27,7 +27,6 @@ module.exports = class Plugin {
   constructor (tracer) {
     this._subscriptions = []
     this._enabled = false
-    this._storeStack = []
     this._tracer = tracer
   }
 
@@ -37,21 +36,14 @@ module.exports = class Plugin {
 
   enter (span, store) {
     store = store || storage.getStore()
-    this._storeStack.push(store)
     storage.enterWith({ ...store, span })
   }
 
   /** Prevents creation of spans here and for all async descendants. */
   skip () {
-    const store = storage.getStore()
-    this._storeStack.push(store)
     storage.enterWith({ noop: true })
   }
 
-  exit () {
-    storage.enterWith(this._storeStack.pop())
-  }
-
   addSub (channelName, handler) {
     this._subscriptions.push(new Subscription(channelName, handler))
   }