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

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

@@ -0,0 +1,67 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connection => {
+  const startCh = channel('apm:mysql:query:start')
+  const asyncEndCh = channel('apm:mysql:query:async-end')
+  const endCh = channel('apm:mysql:query:end')
+  const errorCh = channel('apm:mysql:query:error')
+
+  shimmer.wrap(Connection.prototype, 'query', query => function () {
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    if (!startCh.hasSubscribers) {
+      return query.apply(this, arguments)
+    }
+
+    const sql = arguments[0].sql ? arguments[0].sql : arguments[0]
+    const startArgs = [sql, this.config]
+
+    startCh.publish(startArgs)
+
+    try {
+      const res = query.apply(this, arguments)
+
+      if (res._callback) {
+        const cb = asyncResource.bind(res._callback)
+        res._callback = AsyncResource.bind(function (error, result) {
+          if (error) {
+            errorCh.publish(error)
+          }
+          asyncEndCh.publish(result)
+
+          return cb.apply(this, arguments)
+        })
+      } else {
+        const cb = AsyncResource.bind(function () {
+          asyncEndCh.publish(undefined)
+        })
+        res.on('end', cb)
+      }
+
+      return res
+    } catch (err) {
+      err.stack // trigger getting the stack at the original throwing point
+      errorCh.publish(err)
+
+      throw err
+    } finally {
+      endCh.publish(undefined)
+    }
+  })
+
+  return Connection
+})
+
+addHook({ name: 'mysql', file: 'lib/Pool.js', versions: ['>=2'] }, Pool => {
+  shimmer.wrap(Pool.prototype, 'getConnection', getConnection => function (cb) {
+    arguments[0] = AsyncResource.bind(cb)
+    return getConnection.apply(this, arguments)
+  })
+  return Pool
+})

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

@@ -0,0 +1,15 @@
+'use strict'
+
+const { addHook } = require('./helpers/instrument')
+const { wrapThen } = require('./helpers/promise')
+const shimmer = require('../../datadog-shimmer')
+
+addHook({
+  name: 'promise-js',
+  versions: ['>=0.0.3']
+}, Promise => {
+  if (Promise !== global.Promise) {
+    shimmer.wrap(Promise.prototype, 'then', wrapThen)
+  }
+  return Promise
+})

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

@@ -0,0 +1,14 @@
+'use strict'
+
+const { addHook } = require('./helpers/instrument')
+const { wrapThen } = require('./helpers/promise')
+const shimmer = require('../../datadog-shimmer')
+
+addHook({
+  name: 'promise',
+  file: 'lib/core.js',
+  versions: ['>=7']
+}, Promise => {
+  shimmer.wrap(Promise.prototype, 'then', wrapThen)
+  return Promise
+})

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

@@ -0,0 +1,13 @@
+'use strict'
+
+const { addHook } = require('./helpers/instrument')
+const { wrapThen } = require('./helpers/promise')
+const shimmer = require('../../datadog-shimmer')
+
+addHook({
+  name: 'q',
+  versions: ['>=1']
+}, Q => {
+  shimmer.wrap(Q.makePromise.prototype, 'then', wrapThen)
+  return Q
+})

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

@@ -0,0 +1,14 @@
+'use strict'
+
+const { addHook } = require('./helpers/instrument')
+const { wrapThen } = require('./helpers/promise')
+const shimmer = require('../../datadog-shimmer')
+
+addHook({
+  name: 'when',
+  file: 'lib/Promise.js',
+  versions: ['>=3']
+}, Promise => {
+  shimmer.wrap(Promise.prototype, 'then', wrapThen)
+  return Promise
+})

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

@@ -103,8 +103,8 @@ module.exports = [
     name: '@cucumber/cucumber',
     versions: ['7.0.0 - 7.2.1'],
     file: 'lib/runtime/pickle_runner.js',
-    patch (PickleRunner, tracer) {
-      const testEnvironmentMetadata = getTestEnvironmentMetadata('cucumber')
+    patch (PickleRunner, tracer, config) {
+      const testEnvironmentMetadata = getTestEnvironmentMetadata('cucumber', config)
       const sourceRoot = process.cwd()
       const pl = PickleRunner.default
       this.wrap(
@@ -127,8 +127,8 @@ module.exports = [
     name: '@cucumber/cucumber',
     versions: ['>=7.3.0'],
     file: 'lib/runtime/test_case_runner.js',
-    patch (TestCaseRunner, tracer) {
-      const testEnvironmentMetadata = getTestEnvironmentMetadata('cucumber')
+    patch (TestCaseRunner, tracer, config) {
+      const testEnvironmentMetadata = getTestEnvironmentMetadata('cucumber', config)
       const sourceRoot = process.cwd()
       const pl = TestCaseRunner.default
       this.wrap(

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

@@ -4,6 +4,7 @@ const {
   TEST_SUITE,
   TEST_STATUS,
   TEST_FRAMEWORK_VERSION,
+  TEST_IS_RUM_ACTIVE,
   getTestEnvironmentMetadata,
   CI_APP_ORIGIN,
   getTestParentSpan
@@ -66,19 +67,28 @@ module.exports = (on, config) => {
           }
         })
       }
-      return null
+      return activeSpan ? activeSpan._spanContext._traceId.toString(10) : null
     },
     'dd:afterEach': (test) => {
-      const { state, error } = test
+      const { state, error, isRUMActive } = test
       if (activeSpan) {
         activeSpan.setTag(TEST_STATUS, CYPRESS_STATUS_TO_TEST_STATUS[state])
         if (error) {
           activeSpan.setTag('error', error)
         }
+        if (isRUMActive) {
+          activeSpan.setTag(TEST_IS_RUM_ACTIVE, 'true')
+        }
         activeSpan.finish()
       }
       activeSpan = null
       return null
+    },
+    'dd:addTags': (tags) => {
+      if (activeSpan) {
+        activeSpan.addTags(tags)
+      }
+      return null
     }
   })
 }

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

@@ -1,201 +1,88 @@
 'use strict'
 
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-const tx = require('../../dd-trace/src/plugins/util/tx')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 
-const rrtypes = {
-  resolveAny: 'ANY',
-  resolve4: 'A',
-  resolve6: 'AAAA',
-  resolveCname: 'CNAME',
-  resolveMx: 'MX',
-  resolveNs: 'NS',
-  resolveTxt: 'TXT',
-  resolveSrv: 'SRV',
-  resolvePtr: 'PTR',
-  resolveNaptr: 'NAPTR',
-  resolveSoa: 'SOA'
-}
-
-function createWrapLookup (tracer, config) {
-  return function wrapLookup (lookup) {
-    return function lookupWithTrace (hostname, options, callback) {
-      if (!isArgsValid(arguments, 2)) return lookup.apply(this, arguments)
-
-      const span = startSpan(tracer, config, 'dns.lookup', {
-        'resource.name': hostname,
-        'dns.hostname': hostname
-      })
-
-      wrapArgs(span, arguments, (e, address) => {
-        span.setTag('dns.address', address)
-      })
-
-      return tracer.scope().activate(span, () => lookup.apply(this, arguments))
-    }
+class DNSPlugin extends Plugin {
+  static get name () {
+    return 'dns'
   }
-}
-
-function createWrapLookupService (tracer, config) {
-  return function wrapLookupService (lookupService) {
-    return function lookupServiceWithTrace (address, port, callback) {
-      if (!isArgsValid(arguments, 3)) return lookupService.apply(this, arguments)
-
-      const span = startSpan(tracer, config, 'dns.lookup_service', {
-        'resource.name': `${address}:${port}`,
-        'dns.address': address,
-        'dns.port': port
-      })
 
-      wrapArgs(span, arguments)
-
-      return tracer.scope().activate(span, () => lookupService.apply(this, arguments))
-    }
+  addSubs (func, start, asyncEnd = defaultAsyncEnd) {
+    this.addSub(`apm:dns:${func}:start`, start)
+    this.addSub(`apm:dns:${func}:end`, this.exit.bind(this))
+    this.addSub(`apm:dns:${func}:error`, errorHandler)
+    this.addSub(`apm:dns:${func}:async-end`, asyncEnd)
   }
-}
-
-function createWrapResolve (tracer, config) {
-  return function wrapResolve (resolve) {
-    return function resolveWithTrace (hostname, rrtype, callback) {
-      if (!isArgsValid(arguments, 2)) return resolve.apply(this, arguments)
-
-      if (typeof rrtype !== 'string') {
-        rrtype = 'A'
-      }
-
-      const span = wrapResolver(tracer, config, rrtype, arguments)
 
-      return tracer.scope().activate(span, () => resolve.apply(this, arguments))
+  startSpan (name, customTags, store) {
+    const tags = {
+      'service.name': this.config.service || this.tracer._service,
+      'span.kind': 'client'
     }
-  }
-}
-
-function createWrapResolver (tracer, config, rrtype) {
-  return function wrapResolve (resolve) {
-    return function resolveWithTrace (hostname, callback) {
-      if (!isArgsValid(arguments, 2)) return resolve.apply(this, arguments)
-
-      const span = wrapResolver(tracer, config, rrtype, arguments)
-
-      return tracer.scope().activate(span, () => resolve.apply(this, arguments))
-    }
-  }
-}
-
-function createWrapReverse (tracer, config) {
-  return function wrapReverse (reverse) {
-    return function reverseWithTrace (ip, callback) {
-      if (!isArgsValid(arguments, 2)) return reverse.apply(this, arguments)
-
-      const span = startSpan(tracer, config, 'dns.reverse', {
-        'resource.name': ip,
-        'dns.ip': ip
-      })
-
-      wrapArgs(span, arguments)
-
-      return tracer.scope().activate(span, () => reverse.apply(this, arguments))
+    for (const tag in customTags) {
+      tags[tag] = customTags[tag]
     }
+    const span = this.tracer.startSpan(name, {
+      childOf: store ? store.span : null,
+      tags
+    })
+    analyticsSampler.sample(span, this.config.measured)
+    return span
   }
-}
-
-function startSpan (tracer, config, operation, tags) {
-  const childOf = tracer.scope().active()
-  const span = tracer.startSpan(operation, {
-    childOf,
-    tags: Object.assign({
-      'service.name': config.service || tracer._service,
-      'span.kind': 'client'
-    }, tags)
-  })
-
-  analyticsSampler.sample(span, config.measured)
 
-  return span
-}
+  constructor (...args) {
+    super(...args)
 
-function isArgsValid (args, minLength) {
-  if (args.length < minLength) return false
-  if (typeof args[args.length - 1] !== 'function') return false
+    this.addSubs('lookup', ([hostname]) => {
+      const store = storage.getStore()
+      const span = this.startSpan('dns.lookup', {
+        'resource.name': hostname,
+        'dns.hostname': hostname
+      }, store)
+      this.enter(span, store)
+    }, (result) => {
+      const { span } = storage.getStore()
+      span.setTag('dns.address', result)
+      span.finish()
+    })
 
-  return true
-}
+    this.addSubs('lookup_service', ([address, port]) => {
+      const store = storage.getStore()
+      const span = this.startSpan('dns.lookup_service', {
+        'resource.name': `${address}:${port}`,
+        'dns.address': address,
+        'dns.port': port
+      }, store)
+      this.enter(span, store)
+    })
 
-function wrapArgs (span, args, callback) {
-  const original = args[args.length - 1]
-  const fn = tx.wrap(span, original)
+    this.addSubs('resolve', ([hostname, maybeType]) => {
+      const store = storage.getStore()
+      const rrtype = typeof maybeType === 'string' ? maybeType : 'A'
+      const span = this.startSpan('dns.resolve', {
+        'resource.name': `${rrtype} ${hostname}`,
+        'dns.hostname': hostname,
+        'dns.rrtype': rrtype
+      }, store)
+      this.enter(span, store)
+    })
 
-  args[args.length - 1] = function () {
-    callback && callback.apply(null, arguments)
-    return fn.apply(this, arguments)
+    this.addSubs('reverse', ([ip]) => {
+      const store = storage.getStore()
+      const span = this.startSpan('dns.reverse', { 'resource.name': ip, 'dns.ip': ip }, store)
+      this.enter(span, store)
+    })
   }
 }
 
-function wrapResolver (tracer, config, rrtype, args) {
-  const hostname = args[0]
-  const span = startSpan(tracer, config, 'dns.resolve', {
-    'resource.name': `${rrtype} ${hostname}`,
-    'dns.hostname': hostname,
-    'dns.rrtype': rrtype
-  })
-
-  wrapArgs(span, args)
-
-  return span
-}
-
-function patchResolveShorthands (tracer, config, shim, prototype) {
-  Object.keys(rrtypes)
-    .filter(method => !!prototype[method])
-    .forEach(method => {
-      shim.wrap(prototype, method, createWrapResolver(tracer, config, rrtypes[method]))
-    })
+function defaultAsyncEnd () {
+  storage.getStore().span.finish()
 }
 
-function unpatchResolveShorthands (shim, prototype) {
-  Object.keys(rrtypes)
-    .filter(method => !!prototype[method])
-    .forEach(method => {
-      shim.unwrap(prototype, method)
-    })
+function errorHandler (error) {
+  storage.getStore().span.setTag('error', error)
 }
 
-module.exports = [
-  {
-    name: 'dns',
-    patch (dns, tracer, config) {
-      this.wrap(dns, 'lookup', createWrapLookup(tracer, config))
-      this.wrap(dns, 'lookupService', createWrapLookupService(tracer, config))
-      this.wrap(dns, 'resolve', createWrapResolve(tracer, config))
-      this.wrap(dns, 'reverse', createWrapReverse(tracer, config))
-
-      patchResolveShorthands(tracer, config, this, dns)
-
-      if (dns.Resolver) {
-        this.wrap(dns.Resolver.prototype, 'resolve', createWrapResolve(tracer, config))
-        this.wrap(dns.Resolver.prototype, 'reverse', createWrapReverse(tracer, config))
-
-        patchResolveShorthands(tracer, config, this, dns.Resolver.prototype)
-      }
-    },
-    unpatch (dns) {
-      this.unwrap(dns, [
-        'lookup',
-        'lookupService',
-        'resolve',
-        'reverse'
-      ])
-
-      unpatchResolveShorthands(this, dns)
-
-      if (dns.Resolver) {
-        this.unwrap(dns.prototype.Resolver, [
-          'resolve',
-          'reverse'
-        ])
-
-        unpatchResolveShorthands(this, dns.Resolver.prototype)
-      }
-    }
-  }
-]
+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-http/src/server.js

@@ -2,6 +2,7 @@
 
 const web = require('../../dd-trace/src/plugins/util/web')
 const Scope = require('../../dd-trace/src/scope')
+const { incomingHttpRequestStart } = require('../../dd-trace/src/appsec/gateway/channels')
 
 function createWrapEmit (tracer, config) {
   config = web.normalizeConfig(config)
@@ -10,6 +11,10 @@ function createWrapEmit (tracer, config) {
     return function emitWithTrace (eventName, req, res) {
       if (eventName === 'request') {
         return web.instrument(tracer, config, req, res, 'http.request', () => {
+          if (incomingHttpRequestStart.hasSubscribers) {
+            incomingHttpRequestStart.publish({ req, res })
+          }
+
           return emit.apply(this, arguments)
         })
       }