dd-trace 2.0.0-appsec-beta.1 → 2.0.0-appsec-beta.5

package/ci/cypress/plugin.js

@@ -0,0 +1,3 @@
+require('../init')
+
+module.exports = require('../../packages/datadog-plugin-cypress/src/plugin')

package/ci/cypress/support.js

@@ -0,0 +1 @@
+require('../../packages/datadog-plugin-cypress/src/support')

package/ci/init.js

@@ -0,0 +1,13 @@
+const tracer = require('../packages/dd-trace')
+const { ORIGIN_KEY } = require('../packages/dd-trace/src/constants')
+
+tracer.init({
+  startupLogs: false,
+  tags: {
+    [ORIGIN_KEY]: 'ciapp-test'
+  }
+})
+
+tracer.use('fs', false)
+
+module.exports = tracer

package/ci/jest/env.js

@@ -0,0 +1,14 @@
+const tracer = require('../../packages/dd-trace')
+const { ORIGIN_KEY } = require('../../packages/dd-trace/src/constants')
+
+tracer.init({
+  startupLogs: false,
+  flushInterval: 400000,
+  tags: {
+    [ORIGIN_KEY]: 'ciapp-test'
+  }
+})
+
+tracer.use('fs', false)
+
+module.exports = tracer

package/index.d.ts

@@ -786,7 +786,7 @@ declare namespace plugins {
    * This plugin automatically instruments the
    * [cucumber](https://www.npmjs.com/package/@cucumber/cucumber) module.
    */
-  interface cucumber extends Instrumentation {}
+  interface cucumber extends Integration {}
 
   /**
    * This plugin automatically instruments the
@@ -972,12 +972,12 @@ declare namespace plugins {
     /**
      * Configuration for HTTP clients.
      */
-    client?: HttpClient,
+    client?: HttpClient | boolean,
 
     /**
      * Configuration for HTTP servers.
      */
-    server?: HttpServer
+    server?: HttpServer | boolean
 
     /**
      * Hooks to run before spans are finished.
@@ -1006,12 +1006,12 @@ declare namespace plugins {
     /**
      * Configuration for HTTP clients.
      */
-    client?: Http2Client,
+    client?: Http2Client | boolean,
 
     /**
      * Configuration for HTTP servers.
      */
-    server?: Http2Server
+    server?: Http2Server | boolean
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "2.0.0-appsec-beta.1",
+  "version": "2.0.0-appsec-beta.5",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -10,6 +10,7 @@
     "bench": "node benchmark",
     "bench:profiler": "node benchmark/profiler",
     "bench:e2e": "SERVICES=mongo yarn services && cd benchmark/e2e && node benchmark-run.js --duration=30",
+    "bench:e2e:ci-visibility": "node benchmark/e2e-ci/benchmark-run.js",
     "type:doc": "cd docs && yarn && yarn build",
     "type:test": "cd docs && yarn && yarn test",
     "lint": "node scripts/check_licenses.js && eslint . && yarn audit --groups dependencies",
@@ -58,11 +59,11 @@
     "node": ">=12"
   },
   "dependencies": {
-    "@datadog/native-appsec": "^0.6.0",
-    "@datadog/native-metrics": "^1.0.1",
+    "@datadog/native-appsec": "^0.7.0",
+    "@datadog/native-metrics": "^1.1.0",
     "@datadog/pprof": "^0.3.0",
     "@datadog/sketches-js": "^1.0.4",
-    "@types/node": "^10.12.18",
+    "@types/node": ">=12",
     "crypto-randomuuid": "^1.0.0",
     "diagnostics_channel": "^1.1.0",
     "form-data": "^3.0.0",

package/packages/datadog-instrumentations/index.js

@@ -0,0 +1,5 @@
+'use strict'
+
+require('./src/dns')
+require('./src/memcached')
+require('./src/mysql')

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

@@ -0,0 +1,94 @@
+'use strict'
+
+const { channel, addHook, bind } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const rrtypes = {
+  resolveAny: 'ANY',
+  resolve4: 'A',
+  resolve6: 'AAAA',
+  resolveCname: 'CNAME',
+  resolveMx: 'MX',
+  resolveNs: 'NS',
+  resolveTxt: 'TXT',
+  resolveSrv: 'SRV',
+  resolvePtr: 'PTR',
+  resolveNaptr: 'NAPTR',
+  resolveSoa: 'SOA'
+}
+
+const rrtypeMap = new WeakMap()
+
+addHook({ name: 'dns' }, dns => {
+  dns.lookup = wrap('apm:dns:lookup', dns.lookup, 2)
+  dns.lookupService = wrap('apm:dns:lookup_service', dns.lookupService, 3)
+  dns.resolve = wrap('apm:dns:resolve', dns.resolve, 2)
+  dns.reverse = wrap('apm:dns:reverse', dns.reverse, 2)
+
+  patchResolveShorthands(dns)
+
+  if (dns.Resolver) {
+    dns.Resolver.prototype.resolve = wrap('apm:dns:resolve', dns.Resolver.prototype.resolve, 2)
+    dns.Resolver.prototype.reverse = wrap('apm:dns:reverse', dns.Resolver.prototype.reverse, 2)
+
+    patchResolveShorthands(dns.Resolver.prototype)
+  }
+
+  return dns
+})
+
+function patchResolveShorthands (prototype) {
+  Object.keys(rrtypes)
+    .filter(method => !!prototype[method])
+    .forEach(method => {
+      rrtypeMap.set(prototype[method], rrtypes[method])
+      prototype[method] = wrap('apm:dns:resolve', prototype[method], 2, rrtypes[method])
+    })
+}
+
+function wrap (prefix, fn, expectedArgs, rrtype) {
+  const startCh = channel(prefix + ':start')
+  const endCh = channel(prefix + ':end')
+  const asyncEndCh = channel(prefix + ':async-end')
+  const errorCh = channel(prefix + ':error')
+
+  const wrapped = function () {
+    const cb = bind(arguments[arguments.length - 1])
+    if (
+      !startCh.hasSubscribers ||
+      arguments.length < expectedArgs ||
+      typeof cb !== 'function'
+    ) {
+      return fn.apply(this, arguments)
+    }
+
+    const startArgs = Array.from(arguments)
+    startArgs.pop() // gets rid of the callback
+    if (rrtype) {
+      startArgs.push(rrtype)
+    }
+    startCh.publish(startArgs)
+
+    arguments[arguments.length - 1] = function (error, result) {
+      if (error) {
+        errorCh.publish(error)
+      }
+      asyncEndCh.publish(result)
+      cb.apply(this, arguments)
+    }
+
+    try {
+      return fn.apply(this, arguments)
+      // TODO deal with promise versions when we support `dns/promises`
+    } catch (error) {
+      error.stack // trigger getting the stack at the original throwing point
+      errorCh.publish(error)
+
+      throw error
+    } finally {
+      endCh.publish(undefined)
+    }
+  }
+
+  return shimmer.wrap(fn, wrapped)
+}

package/packages/datadog-instrumentations/src/helpers/instrument.js

@@ -0,0 +1,121 @@
+'use strict'
+
+const dc = require('diagnostics_channel')
+const path = require('path')
+const semver = require('semver')
+const iitm = require('../../../dd-trace/src/iitm')
+const ritm = require('../../../dd-trace/src/ritm')
+const parse = require('module-details-from-path')
+const requirePackageJson = require('../../../dd-trace/src/require-package-json')
+const { AsyncResource } = require('async_hooks')
+
+const pathSepExpr = new RegExp(`\\${path.sep}`, 'g')
+const channelMap = {}
+exports.channel = function channel (name) {
+  const maybe = channelMap[name]
+  if (maybe) return maybe
+  const ch = dc.channel(name)
+  channelMap[name] = ch
+  return ch
+}
+
+exports.addHook = function addHook ({ name, versions, file }, hook) {
+  file = filename(name, file)
+  const loaderHook = (moduleExports, moduleName, moduleBaseDir) => {
+    moduleName = moduleName.replace(pathSepExpr, '/')
+    const moduleVersion = getVersion(moduleBaseDir)
+    if (moduleName !== file || !matchVersion(moduleVersion, versions)) {
+      return moduleExports
+    }
+    return hook(moduleExports)
+  }
+  ritm([name], loaderHook)
+  cjsPostLoad({ name, versions, file }, hook)
+  iitm([name], loaderHook)
+}
+
+function matchVersion (version, ranges) {
+  return !version || (ranges && ranges.some(range => semver.satisfies(semver.coerce(version), range)))
+}
+
+function getVersion (moduleBaseDir) {
+  if (moduleBaseDir) {
+    return requirePackageJson(moduleBaseDir, module).version
+  }
+}
+
+function filename (name, file) {
+  return [name, file].filter(val => val).join('/')
+}
+
+// TODO this is basically Loader#_getModules + running the hook. DRY up.
+function cjsPostLoad (instrumentation, hook) {
+  const ids = Object.keys(require.cache)
+
+  let pkg
+
+  for (let i = 0, l = ids.length; i < l; i++) {
+    if (ids[i] === instrumentation.name) {
+      hook(require.cache[ids[i]].exports)
+      continue
+    }
+
+    const id = ids[i].replace(pathSepExpr, '/')
+
+    if (!id.includes(`/node_modules/${instrumentation.name}/`)) continue
+
+    if (instrumentation.file) {
+      if (!id.endsWith(`/node_modules/${filename(instrumentation)}`)) continue
+
+      const basedir = getBasedir(ids[i])
+
+      pkg = requirePackageJson(basedir, module)
+    } else {
+      const basedir = getBasedir(ids[i])
+
+      pkg = requirePackageJson(basedir, module)
+
+      const mainFile = path.posix.normalize(pkg.main || 'index.js')
+      if (!id.endsWith(`/node_modules/${instrumentation.name}/${mainFile}`)) continue
+    }
+
+    if (!matchVersion(pkg.version, instrumentation.versions)) continue
+
+    hook(require.cache[ids[i]].exports)
+  }
+}
+
+function getBasedir (id) {
+  return parse(id).basedir.replace(pathSepExpr, '/')
+}
+
+if (semver.satisfies(process.versions.node, '>=16.0.0')) {
+  exports.bind = AsyncResource.bind
+  exports.bindAsyncResource = AsyncResource.prototype.bind
+} else {
+  exports.bindAsyncResource = function bindAsyncResource (fn, thisArg) {
+    thisArg = thisArg || this
+    const ret = this.runInAsyncScope.bind(this, fn, thisArg)
+    Object.defineProperties(ret, {
+      'length': {
+        configurable: true,
+        enumerable: false,
+        value: fn.length,
+        writable: false
+      },
+      'asyncResource': {
+        configurable: true,
+        enumerable: true,
+        value: this,
+        writable: true
+      }
+    })
+    return ret
+  }
+
+  exports.bind = function bind (fn, type, thisArg) {
+    type = type || fn.name
+    const ar = new AsyncResource(type || 'bound-anonymous-fn')
+    return exports.bindAsyncResource.call(ar, fn, thisArg)
+  }
+}

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

@@ -0,0 +1,55 @@
+'use strict'
+
+const { AsyncResource } = require('async_hooks')
+const {
+  channel,
+  addHook,
+  bind,
+  bindAsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+addHook({ name: 'memcached', versions: ['>=2.2'] }, Memcached => {
+  const startCh = channel('apm:memcached:command:start')
+  const startWithArgsCh = channel('apm:memcached:command:start:with-args')
+  const asyncEndCh = channel('apm:memcached:command:async-end')
+  const endCh = channel('apm:memcached:command:end')
+  const errorCh = channel('apm:memcached:command:error')
+
+  shimmer.wrap(Memcached.prototype, 'command', command => function (queryCompiler, server) {
+    if (!startCh.hasSubscribers) {
+      return command.apply(this, arguments)
+    }
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+    const client = this
+
+    const wrappedQueryCompiler = function () {
+      const query = queryCompiler.apply(this, arguments)
+      const callback = bindAsyncResource.call(asyncResource, query.callback)
+
+      query.callback = bind(function (err) {
+        if (err) {
+          errorCh.publish(err)
+        }
+        asyncEndCh.publish(undefined)
+
+        return callback.apply(this, arguments)
+      })
+      startWithArgsCh.publish({ client, server, query })
+
+      return query
+    }
+
+    startCh.publish(undefined)
+
+    arguments[0] = wrappedQueryCompiler
+
+    const result = command.apply(this, arguments)
+    endCh.publish(undefined)
+    return result
+  })
+
+  return Memcached
+})

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

@@ -0,0 +1,69 @@
+'use strict'
+
+const { AsyncResource } = require('async_hooks')
+const {
+  channel,
+  addHook,
+  bind,
+  bindAsyncResource
+} = 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 = bindAsyncResource.call(asyncResource, res._callback)
+        res._callback = bind(function (error, result) {
+          if (error) {
+            errorCh.publish(error)
+          }
+          asyncEndCh.publish(result)
+
+          return cb.apply(this, arguments)
+        })
+      } else {
+        const cb = 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] = bind(cb)
+    return getConnection.apply(this, arguments)
+  })
+  return Pool
+})

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,15 +67,18 @@ 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

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