dd-trace 1.4.0 → 1.5.1

package/LICENSE-3rdparty.csv

@@ -18,6 +18,7 @@ require,multer,MIT,Copyright 2014 Hage Yaapa
 require,opentracing,MIT,Copyright 2016 Resonance Labs Inc
 require,path-to-regexp,MIT,Copyright 2014 Blake Embrey
 require,performance-now,MIT,Copyright 2013 Braveg1rl
+require,retry,MIT,Copyright 2011 Tim Koschützki Felix Geisendörfer
 require,semver,ISC,Copyright Isaac Z. Schlueter and Contributors
 require,source-map,BSD-3-Clause,Copyright 2009-2011 Mozilla Foundation and contributors
 require,source-map-resolve,MIT,Copyright 2014-2020 Simon Lydell 2019 Jinxiang
@@ -51,7 +52,6 @@ dev,msgpack-lite,MIT,Copyright 2015 Yusuke Kawasaki
 dev,nock,MIT,Copyright 2017 Pedro Teixeira and other contributors
 dev,nyc,ISC,Copyright 2015 Contributors
 dev,proxyquire,MIT,Copyright 2013 Thorsten Lorenz
-dev,retry,MIT,Copyright 2011 Tim Koschützki Felix Geisendörfer
 dev,rimraf,ISC,Copyright Isaac Z. Schlueter and Contributors
 dev,sinon,BSD-3-Clause,Copyright 2010-2017 Christian Johansen
 dev,sinon-chai,WTFPL and BSD-2-Clause,Copyright 2004 Sam Hocevar 2012–2017 Domenic Denicola

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -56,13 +56,13 @@
     "node": ">=12"
   },
   "dependencies": {
-    "@datadog/native-metrics": "^1.0.0",
-    "@datadog/pprof": "^0.1.3",
+    "@datadog/native-metrics": "^1.0.1",
+    "@datadog/pprof": "^0.3.0",
     "@datadog/sketches-js": "^1.0.4",
     "@types/node": "^10.12.18",
     "crypto-randomuuid": "^1.0.0",
     "form-data": "^3.0.0",
-    "import-in-the-middle": "^1.1.1",
+    "import-in-the-middle": "^1.1.2",
     "koalas": "^1.0.2",
     "limiter": "^1.1.4",
     "lodash.kebabcase": "^4.1.1",
@@ -75,13 +75,14 @@
     "opentracing": ">=0.12.1",
     "path-to-regexp": "^0.1.2",
     "performance-now": "^2.1.0",
+    "retry": "^0.10.1",
     "semver": "^5.5.0",
     "source-map": "^0.7.3",
     "source-map-resolve": "^0.6.0"
   },
   "devDependencies": {
     "autocannon": "^4.5.2",
-    "axios": "^0.21.1",
+    "axios": "^0.21.2",
     "benchmark": "^2.1.4",
     "body-parser": "^1.18.2",
     "chai": "^4.2.0",
@@ -110,7 +111,6 @@
     "nock": "^11.3.3",
     "nyc": "^15.1.0",
     "proxyquire": "^1.8.0",
-    "retry": "^0.10.1",
     "rimraf": "^3.0.0",
     "sinon": "^11.1.2",
     "sinon-chai": "^3.7.0",

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

@@ -1,5 +1,3 @@
-const { relative } = require('path')
-
 const { SAMPLING_RULE_DECISION } = require('../../dd-trace/src/constants')
 
 const {
@@ -11,7 +9,8 @@ const {
   CI_APP_ORIGIN,
   ERROR_MESSAGE,
   getTestEnvironmentMetadata,
-  finishAllTraceSpans
+  finishAllTraceSpans,
+  getTestSuitePath
 } = require('../../dd-trace/src/plugins/util/test')
 
 function setStatusFromResult (span, result, tag) {
@@ -42,11 +41,11 @@ function setStatusFromResultLatest (span, result, tag) {
   }
 }
 
-function createWrapRun (tracer, testEnvironmentMetadata, getTestSuiteName, setStatus) {
+function createWrapRun (tracer, testEnvironmentMetadata, sourceRoot, setStatus) {
   return function wrapRun (run) {
     return function handleRun () {
       const testName = this.pickle.name
-      const testSuite = getTestSuiteName(this.pickle.uri)
+      const testSuite = getTestSuitePath(this.pickle.uri, sourceRoot)
 
       const commonSpanTags = {
         [TEST_TYPE]: 'test',
@@ -105,14 +104,11 @@ module.exports = [
     patch (PickleRunner, tracer) {
       const testEnvironmentMetadata = getTestEnvironmentMetadata('cucumber')
       const sourceRoot = process.cwd()
-      const getTestSuiteName = (pickleUri) => {
-        return relative(sourceRoot, pickleUri)
-      }
       const pl = PickleRunner.default
       this.wrap(
         pl.prototype,
         'run',
-        createWrapRun(tracer, testEnvironmentMetadata, getTestSuiteName, setStatusFromResult)
+        createWrapRun(tracer, testEnvironmentMetadata, sourceRoot, setStatusFromResult)
       )
       const getResourceName = (testStep) => {
         return testStep.isHook ? 'hook' : testStep.pickleStep.text
@@ -132,14 +128,11 @@ module.exports = [
     patch (TestCaseRunner, tracer) {
       const testEnvironmentMetadata = getTestEnvironmentMetadata('cucumber')
       const sourceRoot = process.cwd()
-      const getTestSuiteName = (pickleUri) => {
-        return relative(sourceRoot, pickleUri)
-      }
       const pl = TestCaseRunner.default
       this.wrap(
         pl.prototype,
         'run',
-        createWrapRun(tracer, testEnvironmentMetadata, getTestSuiteName, setStatusFromResultLatest)
+        createWrapRun(tracer, testEnvironmentMetadata, sourceRoot, setStatusFromResultLatest)
       )
       const getResourceName = (testStep) => {
         return testStep.text

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

@@ -9,20 +9,17 @@ let tools
 function createWrapExecute (tracer, config, defaultFieldResolver) {
   return function wrapExecute (execute) {
     return function executeWithTrace () {
-      const args = normalizeArgs(arguments)
+      const args = normalizeArgs(arguments, tracer, config, defaultFieldResolver)
       const schema = args.schema
       const document = args.document
       const source = document && document._datadog_source
-      const fieldResolver = args.fieldResolver || defaultFieldResolver
-      const contextValue = args.contextValue = args.contextValue || {}
+      const contextValue = args.contextValue
       const operation = getOperation(document, args.operationName)
 
       if (contextValue._datadog_graphql) {
         return execute.apply(this, arguments)
       }
 
-      args.fieldResolver = wrapResolve(fieldResolver, tracer, config)
-
       if (schema) {
         wrapFields(schema._queryType, tracer, config)
         wrapFields(schema._mutationType, tracer, config)
@@ -32,7 +29,7 @@ function createWrapExecute (tracer, config, defaultFieldResolver) {
 
       contextValue._datadog_graphql = { source, span, fields: {} }
 
-      return call(execute, span, this, [args], (err, res) => {
+      return call(execute, span, this, arguments, (err, res) => {
         finishResolvers(contextValue, config)
 
         setError(span, err || (res && res.errors && res.errors[0]))
@@ -212,10 +209,19 @@ function getField (contextValue, path) {
   return contextValue._datadog_graphql.fields[path.join('.')]
 }
 
-function normalizeArgs (args) {
-  if (args.length === 1) {
-    return args[0]
-  }
+function normalizeArgs (args, tracer, config, defaultFieldResolver) {
+  if (args.length !== 1) return normalizePositional(args, tracer, config, defaultFieldResolver)
+
+  args[0].contextValue = args[0].contextValue || {}
+  args[0].fieldResolver = wrapResolve(args[0].fieldResolver || defaultFieldResolver, tracer, config)
+
+  return args[0]
+}
+
+function normalizePositional (args, tracer, config, defaultFieldResolver) {
+  args[3] = args[3] || {} // contextValue
+  args[6] = wrapResolve(args[6] || defaultFieldResolver, tracer, config) // fieldResolver
+  args.length = Math.max(args.length, 7)
 
   return {
     schema: args[0],

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

@@ -48,7 +48,7 @@ function createWrapMakeClientConstructor (tracer, config) {
 function wrapPackageDefinition (tracer, config, def) {
   for (const name in def) {
     if (def[name].format) continue
-    if (def[name].service) {
+    if (def[name].service && def[name].prototype) {
       wrapClientConstructor(tracer, config, def[name], def[name].service)
     } else {
       wrapPackageDefinition(tracer, config, def[name])

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

@@ -11,7 +11,8 @@ const {
   CI_APP_ORIGIN,
   getTestEnvironmentMetadata,
   getTestParametersString,
-  finishAllTraceSpans
+  finishAllTraceSpans,
+  getTestSuitePath
 } = require('../../dd-trace/src/plugins/util/test')
 const {
   getFormattedJestTestParameters,
@@ -30,7 +31,7 @@ function wrapEnvironment (BaseEnvironment) {
   return class DatadogJestEnvironment extends BaseEnvironment {
     constructor (config, context) {
       super(config, context)
-      this.testSuite = context.testPath.replace(`${config.rootDir}/`, '')
+      this.testSuite = getTestSuitePath(context.testPath, config.rootDir)
       this.testSpansByTestName = {}
       this.originalTestFnByTestName = {}
     }

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

@@ -7,7 +7,8 @@ const {
   TEST_STATUS,
   CI_APP_ORIGIN,
   getTestEnvironmentMetadata,
-  finishAllTraceSpans
+  finishAllTraceSpans,
+  getTestSuitePath
 } = require('../../dd-trace/src/plugins/util/test')
 const { getTestSpanTags, setSuppressedErrors } = require('./util')
 
@@ -21,7 +22,7 @@ function createWrapIt (tracer, globalConfig, globalInput, testEnvironmentMetadat
 
       const { childOf, commonSpanTags } = getTestSpanTags(tracer, testEnvironmentMetadata)
 
-      const testSuite = globalInput.jasmine.testPath.replace(`${globalConfig.rootDir}/`, '')
+      const testSuite = getTestSuitePath(globalInput.jasmine.testPath, globalConfig.rootDir)
 
       const newSpecFunction = tracer.wrap(
         'jest.test',
@@ -107,7 +108,7 @@ function createWrapItSkip (tracer, globalConfig, globalInput, testEnvironmentMet
     return function itSkipWithTrace () {
       const { childOf, commonSpanTags } = getTestSpanTags(tracer, testEnvironmentMetadata)
 
-      const testSuite = globalInput.jasmine.testPath.replace(`${globalConfig.rootDir}/`, '')
+      const testSuite = getTestSuitePath(globalInput.jasmine.testPath, globalConfig.rootDir)
 
       const spec = it.apply(this, arguments)
 

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

@@ -13,22 +13,23 @@ const {
   getTestEnvironmentMetadata,
   getTestParametersString,
   finishAllTraceSpans,
-  getTestParentSpan
+  getTestParentSpan,
+  getTestSuitePath
 } = require('../../dd-trace/src/plugins/util/test')
 
 function getTestSpanMetadata (tracer, test, sourceRoot) {
   const childOf = getTestParentSpan(tracer)
 
-  const { file: testSuite } = test
+  const { file: testSuiteAbsolutePath } = test
   const fullTestName = test.fullTitle()
-  const strippedTestSuite = testSuite ? testSuite.replace(`${sourceRoot}/`, '') : ''
+  const testSuite = getTestSuitePath(testSuiteAbsolutePath, sourceRoot)
 
   return {
     childOf,
-    resource: `${strippedTestSuite}.${fullTestName}`,
+    resource: `${testSuite}.${fullTestName}`,
     [TEST_TYPE]: 'test',
     [TEST_NAME]: fullTestName,
-    [TEST_SUITE]: strippedTestSuite,
+    [TEST_SUITE]: testSuite,
     [SAMPLING_RULE_DECISION]: 1,
     [SAMPLING_PRIORITY]: AUTO_KEEP
   }
@@ -37,6 +38,12 @@ function getTestSpanMetadata (tracer, test, sourceRoot) {
 function createWrapRunTest (tracer, testEnvironmentMetadata, sourceRoot) {
   return function wrapRunTest (runTest) {
     return async function runTestWithTrace () {
+      // `runTest` is rerun when retries are configured through `this.retries` and the test fails.
+      // This clause prevents rewrapping `this.test.fn` when it has already been wrapped.
+      if (this.test._currentRetry !== undefined && this.test._currentRetry !== 0) {
+        return runTest.apply(this, arguments)
+      }
+
       let specFunction = this.test.fn
       if (specFunction.length) {
         specFunction = promisify(specFunction)

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

@@ -1 +1 @@
-module.exports = '1.4.0'
+module.exports = '1.5.1'

package/packages/dd-trace/src/encode/0.4.js

@@ -61,13 +61,15 @@ class AgentEncoder {
     this._encodeArrayPrefix(bytes, trace)
 
     for (const span of trace) {
+      bytes.reserve(1)
+
       if (span.type) {
-        bytes.push(0x8c)
+        bytes.buffer[bytes.length++] = 0x8c
 
         this._encodeString(bytes, 'type')
         this._encodeString(bytes, span.type)
       } else {
-        bytes.push(0x8b)
+        bytes.buffer[bytes.length++] = 0x8b
       }
 
       this._encodeString(bytes, 'trace_id')
@@ -107,52 +109,105 @@ class AgentEncoder {
 
   _encodeArrayPrefix (bytes, value) {
     const length = value.length
+    const buffer = bytes.buffer
+    const offset = bytes.length
+
+    bytes.reserve(5)
+    bytes.length += 5
 
-    bytes.push(0xdd, length >> 24, length >> 16, length >> 8, length)
+    buffer[offset] = 0xdd
+    buffer[offset + 1] = length >> 24
+    buffer[offset + 2] = length >> 16
+    buffer[offset + 3] = length >> 8
+    buffer[offset + 4] = length
   }
 
   _encodeByte (bytes, value) {
-    bytes.push(value)
+    const buffer = bytes.buffer
+
+    bytes.reserve(1)
+
+    buffer[bytes.length++] = value
   }
 
   _encodeId (bytes, id) {
+    const buffer = bytes.buffer
+    const offset = bytes.length
+
+    bytes.reserve(9)
+    bytes.length += 9
+
     id = id.toArray()
-    bytes.push(0xcf, id[0], id[1], id[2], id[3], id[4], id[5], id[6], id[7])
+
+    buffer[offset] = 0xcf
+    buffer[offset + 1] = id[0]
+    buffer[offset + 2] = id[1]
+    buffer[offset + 3] = id[2]
+    buffer[offset + 4] = id[3]
+    buffer[offset + 5] = id[4]
+    buffer[offset + 6] = id[5]
+    buffer[offset + 7] = id[6]
+    buffer[offset + 8] = id[7]
   }
 
   _encodeInteger (bytes, value) {
-    bytes.push(0xce, value >> 24, value >> 16, value >> 8, value)
+    const buffer = bytes.buffer
+    const offset = bytes.length
+
+    bytes.reserve(5)
+    bytes.length += 5
+
+    buffer[offset] = 0xce
+    buffer[offset + 1] = value >> 24
+    buffer[offset + 2] = value >> 16
+    buffer[offset + 3] = value >> 8
+    buffer[offset + 4] = value
   }
 
   _encodeLong (bytes, value) {
+    const buffer = bytes.buffer
+    const offset = bytes.length
     const hi = (value / Math.pow(2, 32)) >> 0
     const lo = value >>> 0
 
-    bytes.push(0xcf, hi >> 24, hi >> 16, hi >> 8, hi, lo >> 24, lo >> 16, lo >> 8, lo)
+    bytes.reserve(9)
+    bytes.length += 9
+
+    buffer[offset] = 0xcf
+    buffer[offset + 1] = hi >> 24
+    buffer[offset + 2] = hi >> 16
+    buffer[offset + 3] = hi >> 8
+    buffer[offset + 4] = hi
+    buffer[offset + 5] = lo >> 24
+    buffer[offset + 6] = lo >> 16
+    buffer[offset + 7] = lo >> 8
+    buffer[offset + 8] = lo
   }
 
   _encodeMap (bytes, value) {
-    const keys = []
-    const allKeys = Object.keys(value)
+    const keys = Object.keys(value)
+    const buffer = bytes.buffer
+    const offset = bytes.length
 
-    let key = ''
+    bytes.reserve(5)
+    bytes.length += 5
 
-    for (let i = 0, l = allKeys.length; i < l; i++) {
-      key = allKeys[i]
-      if (typeof value[key] !== 'function') {
-        keys.push(key)
-      }
-    }
+    let length = 0
 
-    const length = keys.length
+    for (const key of keys) {
+      if (typeof value[key] !== 'string' && typeof value[key] !== 'number') return
 
-    bytes.push(0xdf, length >> 24, length >> 16, length >> 8, length)
+      length++
 
-    for (let i = 0; i < length; i++) {
-      key = keys[i]
       this._encodeString(bytes, key)
       this._encodeValue(bytes, value[key])
     }
+
+    buffer[offset] = 0xdf
+    buffer[offset + 1] = length >> 24
+    buffer[offset + 2] = length >> 16
+    buffer[offset + 3] = length >> 8
+    buffer[offset + 4] = length
   }
 
   _encodeValue (bytes, value) {
@@ -179,15 +234,21 @@ class AgentEncoder {
   _encodeFloat (bytes, value) {
     float64Array[0] = value
 
-    bytes.push(0xcb)
+    const buffer = bytes.buffer
+    const offset = bytes.length
+
+    bytes.reserve(9)
+    bytes.length += 9
+
+    buffer[offset] = 0xcb
 
     if (bigEndian) {
       for (let i = 0; i <= 7; i++) {
-        bytes.push(uInt8Float64Array[i])
+        buffer[offset + i + 1] = uInt8Float64Array[i]
       }
     } else {
       for (let i = 7; i >= 0; i--) {
-        bytes.push(uInt8Float64Array[i])
+        buffer[bytes.length - i - 1] = uInt8Float64Array[i]
       }
     }
   }

package/packages/dd-trace/src/encode/chunk.js

@@ -14,26 +14,24 @@ class Chunk {
     this._minSize = minSize
   }
 
-  push (...bytes) {
-    this._reserve(bytes.length)
-
-    for (const byte of bytes) {
-      this.buffer[this.length++] = byte
-    }
-  }
-
   write (value) {
     const length = Buffer.byteLength(value)
     const offset = this.length
 
     if (length < 0x20) { // fixstr
-      this.push(length | 0xa0)
+      this.reserve(length + 1)
+      this.length += 1
+      this.buffer[offset] = length | 0xa0
     } else if (length < 0x100000000) { // str 32
-      this.push(0xdb, length >> 24, length >> 16, length >> 8, length)
+      this.reserve(length + 5)
+      this.length += 5
+      this.buffer[offset] = 0xdb
+      this.buffer[offset + 1] = length >> 24
+      this.buffer[offset + 2] = length >> 16
+      this.buffer[offset + 3] = length >> 8
+      this.buffer[offset + 4] = length
     }
 
-    this._reserve(length)
-
     this.length += this.buffer.utf8Write(value, this.length, length)
 
     return this.length - offset
@@ -44,13 +42,13 @@ class Chunk {
   }
 
   set (array) {
-    this._reserve(array.length)
+    this.reserve(array.length)
 
     this.buffer.set(array, this.length)
     this.length += array.length
   }
 
-  _reserve (size) {
+  reserve (size) {
     if (this.length + size > this.buffer.length) {
       this._resize(this._minSize * Math.ceil((this.length + size) / this._minSize))
     }

package/packages/dd-trace/src/id.js

@@ -1,17 +1,17 @@
 'use strict'
 
-const { randomBytes } = require('crypto')
+const { randomFillSync } = require('crypto')
 
 const UINT_MAX = 4294967296
 
+const data = new Uint8Array(8 * 8192)
 const zeroId = new Uint8Array(8)
 
-// Cryptographically secure local seeds to mitigate Math.random() seed reuse.
-const seed = new Uint32Array(randomBytes(8).buffer)
-
 const map = Array.prototype.map
 const pad = byte => `${byte < 16 ? '0' : ''}${byte.toString(16)}`
 
+let batch = 0
+
 // Internal representation of a trace or span ID.
 class Identifier {
   constructor (value, radix) {
@@ -36,7 +36,7 @@ class Identifier {
     if (this._buffer.length === 8) {
       return this._buffer
     }
-    return this._buffer.subarray(-8)
+    return this._buffer.slice(-8)
   }
 
   toJSON () {
@@ -50,7 +50,7 @@ function createBuffer (value) {
   if (!value) return pseudoRandom()
 
   const size = Math.ceil(value.length / 2)
-  const buffer = new Uint8Array(size)
+  const buffer = new Array(size)
 
   for (let i = 0; i < size; i++) {
     buffer[i] = parseInt(value.substring(i * 2, i * 2 + 2), 16)
@@ -61,7 +61,7 @@ function createBuffer (value) {
 
 // Convert a numerical string to a buffer using the specified radix.
 function fromString (str, raddix) {
-  const buffer = new Uint8Array(8)
+  const buffer = new Array(8)
   const len = str.length
 
   let pos = 0
@@ -126,20 +126,24 @@ function toHexString (buffer) {
 
 // Simple pseudo-random 64-bit ID generator.
 function pseudoRandom () {
-  const buffer = new Uint8Array(8)
-
-  const hi = randomUInt32(seed[0]) & 0x7FFFFFFF // only positive int64
-  const lo = randomUInt32(seed[1])
+  if (batch === 0) {
+    randomFillSync(data)
+  }
 
-  writeUInt32BE(buffer, hi, 0)
-  writeUInt32BE(buffer, lo, 4)
+  batch = (batch + 1) % 8192
 
-  return buffer
-}
+  const offset = batch * 8
 
-// Generate a random unsigned 32-bit integer.
-function randomUInt32 (seed) {
-  return seed ^ Math.floor(Math.random() * (0xFFFFFFFF + 1))
+  return [
+    data[offset] & 0x7F, // only positive int64,
+    data[offset + 1],
+    data[offset + 2],
+    data[offset + 3],
+    data[offset + 4],
+    data[offset + 5],
+    data[offset + 6],
+    data[offset + 7]
+  ]
 }
 
 // Read a buffer to unsigned integer bytes.

package/packages/dd-trace/src/instrumenter.js

@@ -7,10 +7,10 @@ const Loader = require('./loader')
 const { isTrue } = require('./util')
 const plugins = require('./plugins')
 
-const disabldPlugins = process.env.DD_TRACE_DISABLED_PLUGINS
+const disabledPlugins = process.env.DD_TRACE_DISABLED_PLUGINS
 
 const collectDisabledPlugins = () => {
-  return new Set(disabldPlugins && disabldPlugins.split(',').map(plugin => plugin.trim()))
+  return new Set(disabledPlugins && disabledPlugins.split(',').map(plugin => plugin.trim()))
 }
 
 function cleanEnv (name) {

package/packages/dd-trace/src/loader.js

@@ -85,51 +85,26 @@ class Loader {
 
     const moduleVersion = getVersion(moduleBaseDir)
 
-    Array.from(this._plugins.keys())
-      .filter(plugin => [].concat(plugin).some(instrumentation =>
-        filename(instrumentation) === moduleName && matchVersion(moduleVersion, instrumentation.versions)
-      ))
-      .forEach(plugin => this._validate(plugin, moduleName, moduleBaseDir, moduleVersion))
-
-    this._plugins
-      .forEach((meta, plugin) => {
-        try {
-          [].concat(plugin)
-            .filter(instrumentation => moduleName === filename(instrumentation))
-            .filter(instrumentation => matchVersion(moduleVersion, instrumentation.versions))
-            .forEach(instrumentation => {
-              const config = this._plugins.get(plugin).config
-
-              if (config.enabled !== false) {
-                moduleExports = this._instrumenter.patch(instrumentation, moduleExports, config) || moduleExports
-              }
-            })
-        } catch (e) {
-          log.error(e)
-          this._instrumenter.unload(plugin)
-          log.debug(`Error while trying to patch ${meta.name}. The plugin has been disabled.`)
-        }
-      })
-
-    return moduleExports
-  }
-
-  _validate (plugin, moduleName, moduleBaseDir, moduleVersion) {
-    const meta = this._plugins.get(plugin)
-    const instrumentations = [].concat(plugin)
+    for (const [plugin, meta] of this._plugins) {
+      if (meta.config.enabled === false) {
+        continue
+      }
+      try {
+        for (const instrumentation of [].concat(plugin)) {
+          if (moduleName !== filename(instrumentation) || !matchVersion(moduleVersion, instrumentation.versions)) {
+            continue
+          }
 
-    for (let i = 0; i < instrumentations.length; i++) {
-      if (moduleName.indexOf(instrumentations[i].name) !== 0) continue
-      if (instrumentations[i].versions && !matchVersion(moduleVersion, instrumentations[i].versions)) continue
-      if (instrumentations[i].file && !exists(moduleBaseDir, instrumentations[i].file)) {
+          moduleExports = this._instrumenter.patch(instrumentation, moduleExports, meta.config) || moduleExports
+        }
+      } catch (e) {
+        log.error(e)
         this._instrumenter.unload(plugin)
-        log.debug([
-          `Plugin "${meta.name}" requires "${instrumentations[i].file}" which was not found.`,
-          `The plugin was disabled.`
-        ].join(' '))
-        break
+        log.debug(`Error while trying to patch ${meta.name}. The plugin has been disabled.`)
       }
     }
+
+    return moduleExports
   }
 }
 
@@ -151,13 +126,4 @@ function filename (plugin) {
   return [plugin.name, plugin.file].filter(val => val).join('/')
 }
 
-function exists (basedir, file) {
-  try {
-    require.resolve(`${basedir}/${file}`)
-    return true
-  } catch (e) {
-    return false
-  }
-}
-
 module.exports = Loader

package/packages/dd-trace/src/opentracing/span.js

@@ -7,8 +7,10 @@ const SpanContext = require('./span_context')
 const constants = require('../constants')
 const id = require('../id')
 const tagger = require('../tagger')
+const log = require('../log')
 
 const SAMPLE_RATE_METRIC_KEY = constants.SAMPLE_RATE_METRIC_KEY
+const { DD_TRACE_EXPERIMENTAL_STATE_TRACKING } = process.env
 
 class DatadogSpan extends Span {
   constructor (tracer, processor, sampler, prioritySampler, fields, debug) {
@@ -117,6 +119,12 @@ class DatadogSpan extends Span {
       return
     }
 
+    if (DD_TRACE_EXPERIMENTAL_STATE_TRACKING === 'true') {
+      if (!this._spanContext._tags['service.name']) {
+        log.error(`Finishing invalid span: ${this}`)
+      }
+    }
+
     finishTime = parseFloat(finishTime) || this._getTime()
 
     this._duration = finishTime - this._startTime

package/packages/dd-trace/src/plugins/util/redis.js

@@ -42,7 +42,7 @@ const redis = {
 function formatCommand (command, args) {
   command = command.toUpperCase()
 
-  if (!args) return command
+  if (!args || command === 'AUTH') return command
 
   for (let i = 0, l = args.length; i < l; i++) {
     if (typeof args[i] === 'function') continue

package/packages/dd-trace/src/plugins/util/test.js

@@ -1,3 +1,5 @@
+const path = require('path')
+
 const { getGitMetadata } = require('./git')
 const { getCIMetadata } = require('./ci')
 const { getRuntimeAndOSMetadata } = require('./env')
@@ -42,7 +44,8 @@ module.exports = {
   getTestEnvironmentMetadata,
   getTestParametersString,
   finishAllTraceSpans,
-  getTestParentSpan
+  getTestParentSpan,
+  getTestSuitePath
 }
 
 function getTestEnvironmentMetadata (testFramework) {
@@ -110,3 +113,16 @@ function getTestParentSpan (tracer) {
     'x-datadog-sampled': 1
   })
 }
+/**
+ * We want to make sure that test suites are reported the same way for
+ * every OS, so we replace `path.sep` by `/`
+ */
+function getTestSuitePath (testSuiteAbsolutePath, sourceRoot) {
+  if (!testSuiteAbsolutePath) {
+    return sourceRoot
+  }
+  const testSuitePath = testSuiteAbsolutePath === sourceRoot
+    ? testSuiteAbsolutePath : path.relative(sourceRoot, testSuiteAbsolutePath)
+
+  return testSuitePath.replace(path.sep, '/')
+}

package/packages/dd-trace/src/plugins/util/web.js

@@ -181,7 +181,7 @@ const web = {
 
   // Extract the parent span from the headers and start a new span as its child
   startChildSpan (tracer, name, headers) {
-    const childOf = tracer.extract(FORMAT_HTTP_HEADERS, headers)
+    const childOf = tracer.scope().active() || tracer.extract(FORMAT_HTTP_HEADERS, headers)
     const span = tracer.startSpan(name, { childOf })
 
     return span

package/packages/dd-trace/src/profiling/exporters/agent.js

@@ -4,9 +4,13 @@ const retry = require('retry')
 const { request } = require('http')
 const FormData = require('form-data')
 
+// TODO: avoid using dd-trace internals. Make this a separate module?
+const docker = require('../../exporters/agent/docker')
 const version = require('../../../lib/version')
 
-function sendRequest (options, body, callback) {
+const containerId = docker.id()
+
+function sendRequest (options, form, callback) {
   const req = request(options, res => {
     if (res.statusCode >= 400) {
       const error = new Error(`HTTP Error ${res.statusCode}`)
@@ -17,7 +21,7 @@ function sendRequest (options, body, callback) {
     }
   })
   req.on('error', callback)
-  if (body) req.write(body)
+  if (form) form.pipe(req)
   req.end()
 }
 
@@ -97,13 +101,16 @@ class AgentExporter {
       })
     }
 
-    const body = form.getBuffer()
     const options = {
       method: 'POST',
       path: '/profiling/v1/input',
       headers: form.getHeaders()
     }
 
+    if (containerId) {
+      options.headers['Datadog-Container-ID'] = containerId
+    }
+
     if (this._url.protocol === 'unix:') {
       options.socketPath = this._url.pathname
     } else {
@@ -125,7 +132,7 @@ class AgentExporter {
 
       operation.attempt((attempt) => {
         const timeout = Math.pow(this._backoffTime, attempt)
-        sendRequest({ ...options, timeout }, body, (err, response) => {
+        sendRequest({ ...options, timeout }, form, (err, response) => {
           if (operation.retry(err)) {
             this._logger.error(`Error from the agent: ${err.message}`)
             return

package/packages/dd-trace/src/profiling/profilers/cpu.js

@@ -25,9 +25,7 @@ class NativeCpuProfiler {
 
   profile () {
     if (!this._stop) return
-    const profile = this._stop()
-    this._record()
-    return profile
+    return this._stop(true)
   }
 
   encode (profile) {

package/packages/dd-trace/src/proxy.js

@@ -46,7 +46,7 @@ class Tracer extends BaseTracer {
             metrics.start(config)
           }
 
-          // dirty require for now so zero appsec code is executed unless explicitely enabled
+          // dirty require for now so zero appsec code is executed unless explicitly enabled
           if (config.appsec.enabled) {
             require('./appsec').enable(config)
           }

package/packages/dd-trace/src/span_processor.js

@@ -1,6 +1,9 @@
 const log = require('./log')
 const format = require('./format')
 
+const startedSpans = new WeakSet()
+const finishedSpans = new WeakSet()
+
 class SpanProcessor {
   constructor (exporter, prioritySampler) {
     this._exporter = exporter
@@ -27,9 +30,80 @@ class SpanProcessor {
   }
 
   _erase (trace) {
-    trace.finished.forEach(span => {
+    if (process.env.DD_TRACE_EXPERIMENTAL_STATE_TRACKING === 'true') {
+      const started = new Set()
+      const startedIds = new Set()
+      const finished = new Set()
+      const finishedIds = new Set()
+
+      for (const span of trace.finished) {
+        const context = span.context()
+        const id = context.toSpanId()
+
+        if (finished.has(span)) {
+          log.error(`Span was already finished in the same trace: ${span}`)
+        } else {
+          finished.add(span)
+
+          if (finishedIds.has(id)) {
+            log.error(`Another span with the same ID was already finished in the same trace: ${span}`)
+          } else {
+            finishedIds.add(id)
+          }
+
+          if (context._trace !== trace) {
+            log.error(`A span was finished in the wrong trace: ${span}.`)
+          }
+
+          if (finishedSpans.has(span)) {
+            log.error(`Span was already finished in a different trace: ${span}`)
+          } else {
+            finishedSpans.add(span)
+          }
+        }
+      }
+
+      for (const span of trace.started) {
+        const context = span.context()
+        const id = context.toSpanId()
+
+        if (started.has(span)) {
+          log.error(`Span was already started in the same trace: ${span}`)
+        } else {
+          started.add(span)
+
+          if (startedIds.has(id)) {
+            log.error(`Another span with the same ID was already started in the same trace: ${span}`)
+          } else {
+            startedIds.add(id)
+          }
+
+          if (context._trace !== trace) {
+            log.error(`A span was started in the wrong trace: ${span}.`)
+          }
+
+          if (startedSpans.has(span)) {
+            log.error(`Span was already started in a different trace: ${span}`)
+          } else {
+            startedSpans.add(span)
+          }
+        }
+
+        if (!finished.has(span)) {
+          log.error(`Span started in one trace but was finished in another trace: ${span}`)
+        }
+      }
+
+      for (const span of trace.finished) {
+        if (!started.has(span)) {
+          log.error(`Span finished in one trace but was started in another trace: ${span}`)
+        }
+      }
+    }
+
+    for (const span of trace.finished) {
       span.context()._tags = {}
-    })
+    }
 
     trace.started = []
     trace.finished = []

package/NOTICE

@@ -1,4 +0,0 @@
-Datadog dd-trace-js
-Copyright 2016-Present Datadog, Inc.
-
-This product includes software developed at Datadog, Inc. (https://www.datadoghq.com/).