dd-trace 2.0.0-appsec-beta.3 → 2.0.0

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

@@ -1,77 +1,64 @@
 'use strict'
 
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
-function createWrapCommand (tracer, config) {
-  return function wrapCommand (command) {
-    return function commandWithTrace (queryCompiler, server) {
-      const scope = tracer.scope()
-      const childOf = scope.active()
-      const span = tracer.startSpan('memcached.command', {
+class MemcachedPlugin extends Plugin {
+  static get name () {
+    return 'memcached'
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:memcached:command:start', () => {
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
+      const span = this.tracer.startSpan('memcached.command', {
         childOf,
         tags: {
           'span.kind': 'client',
           'span.type': 'memcached',
-          'service.name': config.service || `${tracer._service}-memcached`
+          'service.name': this.config.service || `${this.tracer._service}-memcached`
         }
       })
 
-      analyticsSampler.sample(span, config.measured)
-
-      arguments[0] = wrapQueryCompiler(queryCompiler, this, server, scope, span)
-
-      return scope.bind(command, span).apply(this, arguments)
-    }
-  }
-}
-
-function wrapQueryCompiler (original, client, server, scope, span) {
-  const parent = scope.active()
-
-  return function () {
-    const query = original.apply(this, arguments)
-    const callback = query.callback
-
-    span.addTags({
-      'resource.name': query.type,
-      'memcached.command': query.command
+      analyticsSampler.sample(span, this.config.measured)
+      this.enter(span, store)
     })
 
-    addHost(span, client, server, query)
-
-    query.callback = scope.bind(function (err) {
-      addError(span, err)
-
-      span.finish()
+    this.addSub('apm:memcached:command:end', () => {
+      this.exit()
+    })
 
-      return callback.apply(this, arguments)
-    }, parent)
+    this.addSub('apm:memcached:command:start:with-args', ({ client, server, query }) => {
+      const span = storage.getStore().span
+      span.addTags({
+        'resource.name': query.type,
+        'memcached.command': query.command
+      })
 
-    return query
-  }
-}
+      const address = getAddress(client, server, query)
 
-function addHost (span, client, server, query) {
-  const address = getAddress(client, server, query)
+      if (address) {
+        span.addTags({
+          'out.host': address[0],
+          'out.port': address[1]
+        })
+      }
+    })
 
-  if (address) {
-    span.addTags({
-      'out.host': address[0],
-      'out.port': address[1]
+    this.addSub('apm:memcached:command:error', err => {
+      const span = storage.getStore().span
+      span.setTag('error', err)
     })
-  }
-}
 
-function addError (span, error) {
-  if (error) {
-    span.addTags({
-      'error.type': error.name,
-      'error.msg': error.message,
-      'error.stack': error.stack
+    this.addSub('apm:memcached:command:async-end', () => {
+      const span = storage.getStore().span
+      span.finish()
     })
   }
-
-  return error
 }
 
 function getAddress (client, server, query) {
@@ -94,13 +81,4 @@ function getAddress (client, server, query) {
   return server && server.split(':')
 }
 
-module.exports = {
-  name: 'memcached',
-  versions: ['>=2.2'],
-  patch (Memcached, tracer, config) {
-    this.wrap(Memcached.prototype, 'command', createWrapCommand(tracer, config))
-  },
-  unpatch (Memcached) {
-    this.unwrap(Memcached.prototype, 'command')
-  }
-}
+module.exports = MemcachedPlugin

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

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

@@ -100,7 +100,7 @@ module.exports = [
   },
   {
     name: 'pino',
-    versions: ['>=5.14.0'],
+    versions: ['>=5.14.0 <6.8.0'],
     patch (pino, tracer, config) {
       if (!tracer._logInjection) return
 
@@ -112,6 +112,30 @@ module.exports = [
       return this.unwrapExport(pino)
     }
   },
+  {
+    name: 'pino',
+    versions: ['>=6.8.0'],
+    patch (pino, tracer, config) {
+      if (!tracer._logInjection) return
+
+      const mixinSym = pino.symbols.mixinSym
+
+      const wrapped = this.wrapExport(pino, createWrapPino(tracer, config, mixinSym, createWrapMixin)(pino))
+
+      wrapped.pino = wrapped
+      wrapped.default = wrapped
+
+      return wrapped
+    },
+    unpatch (pino) {
+      const unwrapped = this.unwrapExport(pino)
+
+      unwrapped.pino = unwrapped
+      unwrapped.default = unwrapped
+
+      return unwrapped
+    }
+  },
   {
     name: 'pino-pretty',
     versions: ['>=3'], // will only work starting from pino@5.0.0 as previous versions are not using pino-pretty