dd-trace 2.0.0-appsec-beta.4 → 2.0.1

package/packages/datadog-plugin-cypress/src/support.js

@@ -3,15 +3,30 @@ beforeEach(() => {
   cy.task('dd:beforeEach', {
     testName: Cypress.mocha.getRunner().suite.ctx.currentTest.fullTitle(),
     testSuite: Cypress.mocha.getRootSuite().file
+  }).then(traceId => {
+    Cypress.env('traceId', traceId)
   })
 })
 
+after(() => {
+  cy.window().then(win => {
+    win.dispatchEvent(new Event('beforeunload'))
+  })
+})
+
+
 afterEach(() => {
-  const currentTest = Cypress.mocha.getRunner().suite.ctx.currentTest
-  cy.task('dd:afterEach', {
-    testName: currentTest.fullTitle(),
-    testSuite: Cypress.mocha.getRootSuite().file,
-    state: currentTest.state,
-    error: currentTest.err
+  cy.window().then(win => {
+    const currentTest = Cypress.mocha.getRunner().suite.ctx.currentTest
+    const testInfo = {
+      testName: currentTest.fullTitle(),
+      testSuite: Cypress.mocha.getRootSuite().file,
+      state: currentTest.state,
+      error: currentTest.err,
+    }
+    if (win.DD_RUM) {
+      testInfo.isRUMActive = true
+    }
+    cy.task('dd:afterEach', testInfo)
   })
 })

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

@@ -82,7 +82,7 @@ function defaultAsyncEnd () {
 }
 
 function errorHandler (error) {
-  storage.getStore().addError(error)
+  storage.getStore().span.setTag('error', error)
 }
 
 module.exports = DNSPlugin

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

@@ -1,5 +1,7 @@
 'use strict'
 
+const { storage } = require('../../datadog-core')
+
 let kDirReadPromisified
 let kDirClosePromisified
 let kHandle
@@ -52,7 +54,7 @@ const orphanable = false
 function createWrapCreateReadStream (config, tracer) {
   return function wrapCreateReadStream (createReadStream) {
     return function createReadStreamWithTrace (path, options) {
-      if (!hasParent(tracer)) {
+      if (!hasParent()) {
         return createReadStream.apply(this, arguments)
       }
       const tags = makeFSFlagTags('ReadStream', path, options, 'r', config, tracer)
@@ -282,8 +284,10 @@ function getSymbolName (sym) {
   return sym.description || sym.toString()
 }
 
-function hasParent (tracer) {
-  return !!tracer.scope().active()
+function hasParent () {
+  const store = storage.getStore()
+
+  return store && store.span && !store.noop
 }
 
 function createWrapCb (tracer, config, name, tagMaker) {

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

@@ -1,16 +1,13 @@
 'use strict'
 
 const url = require('url')
-const opentracing = require('opentracing')
 const log = require('../../dd-trace/src/log')
-const constants = require('../../dd-trace/src/constants')
 const tags = require('../../../ext/tags')
 const kinds = require('../../../ext/kinds')
 const formats = require('../../../ext/formats')
 const urlFilter = require('../../dd-trace/src/plugins/util/urlfilter')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-
-const Reference = opentracing.Reference
+const { storage } = require('../../datadog-core')
 
 const HTTP_HEADERS = formats.HTTP_HEADERS
 const HTTP_STATUS_CODE = tags.HTTP_STATUS_CODE
@@ -18,8 +15,6 @@ const HTTP_REQUEST_HEADERS = tags.HTTP_REQUEST_HEADERS
 const HTTP_RESPONSE_HEADERS = tags.HTTP_RESPONSE_HEADERS
 const SPAN_KIND = tags.SPAN_KIND
 const CLIENT = kinds.CLIENT
-const REFERENCE_CHILD_OF = opentracing.REFERENCE_CHILD_OF
-const REFERENCE_NOOP = constants.REFERENCE_NOOP
 
 function patch (http, methodName, tracer, config) {
   config = normalizeConfig(tracer, config)
@@ -27,6 +22,10 @@ function patch (http, methodName, tracer, config) {
 
   function makeRequestTrace (request) {
     return function requestTrace () {
+      const store = storage.getStore()
+
+      if (store && store.noop) return request.apply(this, arguments)
+
       let args
 
       try {
@@ -50,11 +49,8 @@ function patch (http, methodName, tracer, config) {
 
       const scope = tracer.scope()
       const childOf = scope.active()
-      const type = config.filter(uri) ? REFERENCE_CHILD_OF : REFERENCE_NOOP
       const span = tracer.startSpan('http.request', {
-        references: [
-          new Reference(type, childOf)
-        ],
+        childOf,
         tags: {
           [SPAN_KIND]: CLIENT,
           'service.name': getServiceName(tracer, config, options),
@@ -286,35 +282,24 @@ function getStatusValidator (config) {
   return code => code < 400 || code >= 500
 }
 
-function getFilter (tracer, config) {
-  const blocklist = tracer._url ? [getAgentFilter(tracer._url)] : []
-
+function getFilter (config) {
   config = Object.assign({}, config, {
-    blocklist: blocklist.concat(config.blocklist || [])
+    blocklist: config.blocklist || []
   })
 
   return urlFilter.getFilter(config)
 }
 
-function getAgentFilter (url) {
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Escaping
-  const agentFilter = url.href.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-
-  return RegExp(`^${agentFilter}.*$`, 'i')
-}
-
 function normalizeConfig (tracer, config) {
   config = config.client || config
 
   const validateStatus = getStatusValidator(config)
-  const filter = getFilter(tracer, config)
-  const propagationFilter = getFilter(tracer, { blocklist: config.propagationBlocklist })
+  const propagationFilter = getFilter({ blocklist: config.propagationBlocklist })
   const headers = getHeaders(config)
   const hooks = getHooks(config)
 
   return Object.assign({}, config, {
     validateStatus,
-    filter,
     propagationFilter,
     headers,
     hooks

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

@@ -1,26 +1,19 @@
 'use strict'
 
 const URL = require('url').URL
-const opentracing = require('opentracing')
 const log = require('../../dd-trace/src/log')
-const constants = require('../../dd-trace/src/constants')
 const tags = require('../../../ext/tags')
 const kinds = require('../../../ext/kinds')
 const formats = require('../../../ext/formats')
-const urlFilter = require('../../dd-trace/src/plugins/util/urlfilter')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 const shimmer = require('../../datadog-shimmer')
 
-const Reference = opentracing.Reference
-
 const HTTP_HEADERS = formats.HTTP_HEADERS
 const HTTP_STATUS_CODE = tags.HTTP_STATUS_CODE
 const HTTP_REQUEST_HEADERS = tags.HTTP_REQUEST_HEADERS
 const HTTP_RESPONSE_HEADERS = tags.HTTP_RESPONSE_HEADERS
 const SPAN_KIND = tags.SPAN_KIND
 const CLIENT = kinds.CLIENT
-const REFERENCE_CHILD_OF = opentracing.REFERENCE_CHILD_OF
-const REFERENCE_NOOP = constants.REFERENCE_NOOP
 
 const HTTP2_HEADER_METHOD = ':method'
 const HTTP2_HEADER_PATH = ':path'
@@ -91,26 +84,14 @@ function getStatusValidator (config) {
   return code => code < 400 || code >= 500
 }
 
-function getFilter (tracer, config) {
-  const blocklist = tracer._url ? [`${tracer._url.href}/v0.4/traces`] : []
-
-  config = Object.assign({}, config, {
-    blocklist: blocklist.concat(config.blocklist || [])
-  })
-
-  return urlFilter.getFilter(config)
-}
-
 function normalizeConfig (tracer, config) {
   config = config.client || config
 
   const validateStatus = getStatusValidator(config)
-  const filter = getFilter(tracer, config)
   const headers = getHeaders(config)
 
   return Object.assign({}, config, {
     validateStatus,
-    filter,
     headers
   })
 }
@@ -165,12 +146,8 @@ function startSpan (tracer, config, headers, sessionDetails) {
   const method = headers[HTTP2_HEADER_METHOD] || HTTP2_METHOD_GET
   const url = `${sessionDetails.protocol}//${sessionDetails.host}:${sessionDetails.port}${path}`
 
-  const type = config.filter(url) ? REFERENCE_CHILD_OF : REFERENCE_NOOP
-
   const span = tracer.startSpan('http.request', {
-    references: [
-      new Reference(type, childOf)
-    ],
+    childOf,
     tags: {
       [SPAN_KIND]: CLIENT,
       'service.name': getServiceName(tracer, config, sessionDetails),

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

@@ -20,6 +20,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 MANUAL_DROP = tags.MANUAL_DROP
 
 const HTTP_STATUS_OK = 200
 const HTTP2_HEADER_AUTHORITY = ':authority'
@@ -73,9 +74,8 @@ function instrumentStream (tracer, config, stream, headers, name, callback) {
 
   const span = startStreamSpan(tracer, config, stream, headers, name)
 
-  // TODO: replace this with a REFERENCE_NOOP after we split http/express/etc
   if (!config.filter(headers[HTTP2_HEADER_PATH])) {
-    span.context()._traceFlags.sampled = false
+    span.setTag(MANUAL_DROP, true)
   }
 
   if (config.service) {

package/packages/datadog-plugin-jest/src/jest-environment.js

@@ -238,8 +238,8 @@ module.exports = [
   {
     name: 'jest-environment-node',
     versions: ['>=24.8.0'],
-    patch: function (NodeEnvironment, tracer) {
-      const testEnvironmentMetadata = getTestEnvironmentMetadata('jest')
+    patch: function (NodeEnvironment, tracer, config) {
+      const testEnvironmentMetadata = getTestEnvironmentMetadata('jest', config)
 
       this.wrap(NodeEnvironment.prototype, 'teardown', createWrapTeardown(tracer, this))
 
@@ -257,8 +257,8 @@ module.exports = [
   {
     name: 'jest-environment-jsdom',
     versions: ['>=24.8.0'],
-    patch: function (JsdomEnvironment, tracer) {
-      const testEnvironmentMetadata = getTestEnvironmentMetadata('jest')
+    patch: function (JsdomEnvironment, tracer, config) {
+      const testEnvironmentMetadata = getTestEnvironmentMetadata('jest', config)
 
       this.wrap(JsdomEnvironment.prototype, 'teardown', createWrapTeardown(tracer, this))
 

package/packages/datadog-plugin-jest/src/jest-jasmine2.js

@@ -169,8 +169,8 @@ module.exports = [
     name: 'jest-jasmine2',
     versions: ['>=24.8.0'],
     file: 'build/jasmineAsyncInstall.js',
-    patch: function (jasmineAsyncInstallExport, tracer) {
-      const testEnvironmentMetadata = getTestEnvironmentMetadata('jest')
+    patch: function (jasmineAsyncInstallExport, tracer, config) {
+      const testEnvironmentMetadata = getTestEnvironmentMetadata('jest', config)
       return this.wrapExport(
         jasmineAsyncInstallExport.default,
         createWrapJasmineAsyncInstall(tracer, this, testEnvironmentMetadata)(jasmineAsyncInstallExport.default)

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

@@ -1,14 +1,14 @@
 'use strict'
 
-const tx = require('../../dd-trace/src/plugins/util/promise')
+const { wrapThen } = require('../../datadog-instrumentations/src/helpers/promise')
 
 function createPatch (file) {
   return {
     name: 'knex',
     versions: ['>=0.8.0'],
     file,
-    patch (Builder, tracer, config) {
-      this.wrap(Builder.prototype, 'then', tx.createWrapThen(tracer, config))
+    patch (Builder) {
+      this.wrap(Builder.prototype, 'then', wrapThen)
     },
     unpatch (Builder) {
       this.unwrap(Builder.prototype, 'then')

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

@@ -122,6 +122,7 @@ function getAllTestsInSuite (root) {
 function createWrapRunTests (tracer, testEnvironmentMetadata, sourceRoot) {
   return function wrapRunTests (runTests) {
     return function runTestsWithTrace () {
+      this.once('end', () => tracer._exporter._writer.flush())
       runTests.apply(this, arguments)
       const suite = arguments[0]
       const tests = getAllTestsInSuite(suite)
@@ -239,8 +240,8 @@ module.exports = [
     name: 'mocha',
     versions: ['>=5.2.0'],
     file: 'lib/runner.js',
-    patch (Runner, tracer) {
-      const testEnvironmentMetadata = getTestEnvironmentMetadata('mocha')
+    patch (Runner, tracer, config) {
+      const testEnvironmentMetadata = getTestEnvironmentMetadata('mocha', config)
       const sourceRoot = process.cwd()
       this.wrap(Runner.prototype, 'runTests', createWrapRunTests(tracer, testEnvironmentMetadata, sourceRoot))
       this.wrap(Runner.prototype, 'runTest', createWrapRunTest(tracer, testEnvironmentMetadata, sourceRoot))

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

@@ -0,0 +1,60 @@
+'use strict'
+
+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,
+        tags: {
+          'span.kind': 'client'
+        }
+      }
+
+      opts = arguments[2] = opts || {}
+      opts.meta = opts.meta || {}
+
+      arguments.length = Math.max(3, arguments.length)
+
+      return tracer.trace('moleculer.call', options, () => {
+        const span = tracer.scope().active()
+
+        tracer.inject(span, 'text_map', opts.meta)
+
+        const promise = call.apply(this, arguments)
+
+        if (promise.ctx) {
+          const endpoint = promise.ctx.endpoint || {}
+          const node = endpoint.node || {}
+
+          span.addTags({
+            'out.host': node.hostname,
+            'out.port': node.port,
+            ...moleculerTags(this, promise.ctx, config)
+          })
+        }
+
+        return promise
+      })
+    }
+  }
+}
+
+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')
+    }
+  }
+]

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

@@ -0,0 +1,8 @@
+'use strict'
+
+// TODO: support https://moleculer.services/docs/0.13/actions.html#Streaming
+
+const client = require('./client')
+const server = require('./server')
+
+module.exports = [].concat(client, server)

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

@@ -0,0 +1,61 @@
+'use strict'
+
+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))
+      }
+
+      return registerMiddlewares.apply(this, arguments)
+    }
+  }
+}
+
+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)
+          }
+        }
+
+        if (childOf) {
+          options.childOf = childOf
+        }
+
+        return tracer.trace('moleculer.action', options, () => next(ctx))
+      }
+    }
+  }
+}
+
+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')
+    }
+  }
+]

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

@@ -0,0 +1,21 @@
+'use strict'
+
+// TODO: add ctx.params when nested object properties are deprecated
+
+function moleculerTags (broker, ctx, config) {
+  const service = ctx.service || {}
+  const action = ctx.action || {}
+  const meta = config.meta && ctx.meta
+
+  return {
+    'moleculer.context.action': action.name,
+    'moleculer.context.meta': meta,
+    'moleculer.context.node_id': ctx.nodeID,
+    'moleculer.context.request_id': ctx.requestID,
+    'moleculer.context.service': service.name,
+    'moleculer.namespace': broker.namespace,
+    'moleculer.node_id': broker.nodeID
+  }
+}
+
+module.exports = { moleculerTags }

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const tx = require('../../dd-trace/src/plugins/util/promise')
+const { wrapThen } = require('../../datadog-instrumentations/src/helpers/promise')
 
 function createWrapCollectionAddQueue (tracer, config) {
   return function wrapAddQueue (addQueue) {
@@ -33,7 +33,7 @@ module.exports = [
     versions: ['>=4.6.4'],
     patch (mongoose, tracer, config) {
       if (mongoose.Promise !== global.Promise) {
-        this.wrap(mongoose.Promise.prototype, 'then', tx.createWrapThen(tracer, config))
+        this.wrap(mongoose.Promise.prototype, 'then', wrapThen)
       }
 
       this.wrap(mongoose.Collection.prototype, 'addQueue', createWrapCollectionAddQueue(tracer, config))

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

@@ -1,110 +1,58 @@
 'use strict'
 
-const Tags = require('opentracing').Tags
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
-function createWrapQuery (tracer, config) {
-  return function wrapQuery (query) {
-    return function queryWithTrace (sql, values, cb) {
-      const scope = tracer.scope()
-      const childOf = scope.active()
-      const span = tracer.startSpan('mysql.query', {
+class MySQLPlugin extends Plugin {
+  static get name () {
+    return 'mysql'
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:mysql:query:start', ([sql, conf]) => {
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
+      const span = this.tracer.startSpan('mysql.query', {
         childOf,
         tags: {
-          [Tags.SPAN_KIND]: Tags.SPAN_KIND_RPC_CLIENT,
-          'service.name': config.service || `${tracer._service}-mysql`,
+          'service.name': this.config.service || `${this.tracer._service}-mysql`,
           'span.type': 'sql',
           'span.kind': 'client',
           'db.type': 'mysql',
-          'db.user': this.config.user,
-          'out.host': this.config.host,
-          'out.port': this.config.port
+          'db.user': conf.user,
+          'out.host': conf.host,
+          'out.port': conf.port,
+          'resource.name': sql
         }
       })
 
-      if (this.config.database) {
-        span.setTag('db.name', this.config.database)
+      if (conf.database) {
+        span.setTag('db.name', conf.database)
       }
 
-      analyticsSampler.sample(span, config.measured)
+      analyticsSampler.sample(span, this.config.measured)
+      this.enter(span, store)
+    })
 
-      const sequence = scope.bind(query, span).apply(this, arguments)
+    this.addSub('apm:mysql:query:end', () => {
+      this.exit()
+    })
 
-      scope.bind(sequence)
-
-      span.setTag('resource.name', sequence.sql)
-
-      if (sequence._callback) {
-        sequence._callback = wrapCallback(tracer, span, childOf, sequence._callback)
-      } else {
-        sequence.on('end', () => {
-          span.finish()
-        })
+    this.addSub('apm:mysql:query:error', err => {
+      if (err) {
+        const span = storage.getStore().span
+        span.setTag('error', err)
       }
+    })
 
-      return sequence
-    }
-  }
-}
-
-function createWrapGetConnection (tracer, config) {
-  return function wrapGetConnection (getConnection) {
-    return function getConnectionWithTrace (cb) {
-      const scope = tracer.scope()
-
-      arguments[0] = scope.bind(cb)
-
-      return scope.bind(getConnection).apply(this, arguments)
-    }
+    this.addSub('apm:mysql:query:async-end', () => {
+      const span = storage.getStore().span
+      span.finish()
+    })
   }
 }
 
-function wrapCallback (tracer, span, parent, done) {
-  return tracer.scope().bind((...args) => {
-    const err = args[0]
-    if (err) {
-      span.addTags({
-        'error.type': err.name,
-        'error.msg': err.message,
-        'error.stack': err.stack
-      })
-    }
-
-    span.finish()
-
-    done(...args)
-  }, parent)
-}
-
-function patchConnection (Connection, tracer, config) {
-  this.wrap(Connection.prototype, 'query', createWrapQuery(tracer, config))
-}
-
-function unpatchConnection (Connection) {
-  this.unwrap(Connection.prototype, 'query')
-}
-
-function patchPool (Pool, tracer, config) {
-  this.wrap(Pool.prototype, 'getConnection', createWrapGetConnection(tracer, config))
-}
-
-function unpatchPool (Pool) {
-  this.unwrap(Pool.prototype, 'getConnection')
-}
-
-module.exports = [
-  {
-    name: 'mysql',
-    file: 'lib/Connection.js',
-    versions: ['>=2'],
-    patch: patchConnection,
-    unpatch: unpatchConnection
-  },
-  {
-    name: 'mysql',
-    file: 'lib/Pool.js',
-    versions: ['>=2'],
-    patch: patchPool,
-    unpatch: unpatchPool
-  }
-]
+module.exports = MySQLPlugin

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

@@ -2,10 +2,15 @@
 
 const tx = require('../../dd-trace/src/plugins/util/tx')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
+const { storage } = require('../../datadog-core')
 
 function createWrapConnect (tracer, config) {
   return function wrapConnect (connect) {
     return function connectWithTrace () {
+      const store = storage.getStore()
+
+      if (store && store.noop) return connect.apply(this, arguments)
+
       const scope = tracer.scope()
       const options = getOptions(arguments)
       const lastIndex = arguments.length - 1