dd-trace 2.1.1 → 2.3.0

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

@@ -1,150 +1,105 @@
-const { SAMPLING_RULE_DECISION } = require('../../dd-trace/src/constants')
+'use strict'
+
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 
 const {
+  CI_APP_ORIGIN,
   TEST_TYPE,
   TEST_NAME,
   TEST_SUITE,
-  TEST_STATUS,
-  TEST_FRAMEWORK_VERSION,
   TEST_SKIP_REASON,
-  CI_APP_ORIGIN,
+  TEST_FRAMEWORK_VERSION,
   ERROR_MESSAGE,
-  getTestEnvironmentMetadata,
+  TEST_STATUS,
   finishAllTraceSpans,
+  getTestEnvironmentMetadata,
   getTestSuitePath
 } = require('../../dd-trace/src/plugins/util/test')
+const { SPAN_TYPE, RESOURCE_NAME } = require('../../../ext/tags')
+const { SAMPLING_RULE_DECISION } = require('../../dd-trace/src/constants')
 
-function setStatusFromResult (span, result, tag) {
-  if (result.status === 1) {
-    span.setTag(tag, 'pass')
-  } else if (result.status === 2) {
-    span.setTag(tag, 'skip')
-  } else if (result.status === 4) {
-    span.setTag(tag, 'skip')
-    span.setTag(TEST_SKIP_REASON, 'not implemented')
-  } else {
-    span.setTag(tag, 'fail')
-    span.setTag(ERROR_MESSAGE, result.message)
+class CucumberPlugin extends Plugin {
+  static get name () {
+    return 'cucumber'
   }
-}
 
-function setStatusFromResultLatest (span, result, tag) {
-  if (result.status === 'PASSED') {
-    span.setTag(tag, 'pass')
-  } else if (result.status === 'SKIPPED' || result.status === 'PENDING') {
-    span.setTag(tag, 'skip')
-  } else if (result.status === 'UNDEFINED') {
-    span.setTag(tag, 'skip')
-    span.setTag(TEST_SKIP_REASON, 'not implemented')
-  } else {
-    span.setTag(tag, 'fail')
-    span.setTag(ERROR_MESSAGE, result.message)
-  }
-}
+  constructor (...args) {
+    super(...args)
 
-function createWrapRun (tracer, testEnvironmentMetadata, sourceRoot, setStatus) {
-  return function wrapRun (run) {
-    return function handleRun () {
-      const testName = this.pickle.name
-      const testSuite = getTestSuitePath(this.pickle.uri, sourceRoot)
-
-      const commonSpanTags = {
-        [TEST_TYPE]: 'test',
-        [TEST_NAME]: testName,
-        [TEST_SUITE]: testSuite,
-        [SAMPLING_RULE_DECISION]: 1,
-        [TEST_FRAMEWORK_VERSION]: tracer._version,
-        ...testEnvironmentMetadata
-      }
+    const testEnvironmentMetadata = getTestEnvironmentMetadata('cucumber', this.config)
+    const sourceRoot = process.cwd()
+
+    this.addSub('ci:cucumber:run:start', ({ pickleName, pickleUri }) => {
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
+      const testSuite = getTestSuitePath(pickleUri, sourceRoot)
 
-      return tracer.trace(
-        'cucumber.test',
-        {
-          type: 'test',
-          resource: testName,
-          tags: commonSpanTags
-        },
-        (testSpan) => {
-          testSpan.context()._trace.origin = CI_APP_ORIGIN
-          const promise = run.apply(this, arguments)
-          promise.then(() => {
-            setStatus(testSpan, this.getWorstStepResult(), TEST_STATUS)
-          }).finally(() => {
-            finishAllTraceSpans(testSpan)
-          })
-          return promise
+      const span = this.tracer.startSpan('cucumber.test', {
+        childOf,
+        tags: {
+          [SPAN_TYPE]: 'test',
+          [RESOURCE_NAME]: pickleName,
+          [TEST_TYPE]: 'test',
+          [TEST_NAME]: pickleName,
+          [TEST_SUITE]: testSuite,
+          [SAMPLING_RULE_DECISION]: 1,
+          [TEST_FRAMEWORK_VERSION]: this.tracer._version,
+          ...testEnvironmentMetadata
         }
-      )
-    }
-  }
-}
+      })
+      span.context()._trace.origin = CI_APP_ORIGIN
+      this.enter(span, store)
+    })
 
-function createWrapRunStep (tracer, getResourceName, setStatus) {
-  return function wrapRunStep (runStep) {
-    return function handleRunStep () {
-      const resource = getResourceName(arguments[0])
-      return tracer.trace(
-        'cucumber.step',
-        { resource, tags: { 'cucumber.step': resource } },
-        (span) => {
-          const promise = runStep.apply(this, arguments)
-          promise.then((result) => {
-            setStatus(span, result, 'step.status')
-          })
-          return promise
+    this.addSub('ci:cucumber:run:end', () => {
+      this.exit()
+    })
+
+    this.addSub('ci:cucumber:run-step:start', ({ resource }) => {
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
+      const span = this.tracer.startSpan('cucumber.step', {
+        childOf,
+        tags: {
+          'cucumber.step': resource,
+          [RESOURCE_NAME]: resource
         }
-      )
-    }
-  }
-}
+      })
+      this.enter(span, store)
+    })
+
+    this.addSub('ci:cucumber:run-step:end', () => {
+      this.exit()
+    })
+
+    this.addSub('ci:cucumber:run:async-end', ({ isStep, status, skipReason, errorMessage }) => {
+      const span = storage.getStore().span
+      const statusTag = isStep ? 'step.status' : TEST_STATUS
+
+      span.setTag(statusTag, status)
 
-module.exports = [
-  {
-    name: '@cucumber/cucumber',
-    versions: ['7.0.0 - 7.2.1'],
-    file: 'lib/runtime/pickle_runner.js',
-    patch (PickleRunner, tracer, config) {
-      const testEnvironmentMetadata = getTestEnvironmentMetadata('cucumber', config)
-      const sourceRoot = process.cwd()
-      const pl = PickleRunner.default
-      this.wrap(
-        pl.prototype,
-        'run',
-        createWrapRun(tracer, testEnvironmentMetadata, sourceRoot, setStatusFromResult)
-      )
-      const getResourceName = (testStep) => {
-        return testStep.isHook ? 'hook' : testStep.pickleStep.text
+      if (skipReason) {
+        span.setTag(TEST_SKIP_REASON, skipReason)
       }
-      this.wrap(pl.prototype, 'runStep', createWrapRunStep(tracer, getResourceName, setStatusFromResult))
-    },
-    unpatch (PickleRunner) {
-      const pl = PickleRunner.default
-      this.unwrap(pl.prototype, 'run')
-      this.unwrap(pl.prototype, 'runStep')
-    }
-  },
-  {
-    name: '@cucumber/cucumber',
-    versions: ['>=7.3.0'],
-    file: 'lib/runtime/test_case_runner.js',
-    patch (TestCaseRunner, tracer, config) {
-      const testEnvironmentMetadata = getTestEnvironmentMetadata('cucumber', config)
-      const sourceRoot = process.cwd()
-      const pl = TestCaseRunner.default
-      this.wrap(
-        pl.prototype,
-        'run',
-        createWrapRun(tracer, testEnvironmentMetadata, sourceRoot, setStatusFromResultLatest)
-      )
-      const getResourceName = (testStep) => {
-        return testStep.text
+
+      if (errorMessage) {
+        span.setTag(ERROR_MESSAGE, errorMessage)
+      }
+
+      span.finish()
+      if (!isStep) {
+        finishAllTraceSpans(span)
       }
-      this.wrap(pl.prototype, 'runStep', createWrapRunStep(tracer, getResourceName, setStatusFromResultLatest))
-    },
-    unpatch (TestCaseRunner) {
-      const pl = TestCaseRunner.default
-      this.unwrap(pl.prototype, 'run')
-      this.unwrap(pl.prototype, 'runStep')
-    }
+    })
+
+    this.addSub('ci:cucumber:error', (err) => {
+      if (err) {
+        const span = storage.getStore().span
+        span.setTag('error', err)
+      }
+    })
   }
-]
+}
+
+module.exports = CucumberPlugin

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

@@ -1,23 +1,29 @@
 '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 createWrapRequest (tracer, config) {
-  config = normalizeConfig(config)
-  return function wrapRequest (request) {
-    return function requestWithTrace (params, options, cb) {
-      if (!params) return request.apply(this, arguments)
+class ElasticsearchPlugin extends Plugin {
+  static get name () {
+    return 'elasticsearch'
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:elasticsearch:query:start', ({ params }) => {
+      this.config = normalizeConfig(this.config)
 
-      const lastIndex = arguments.length - 1
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
       const body = getBody(params.body || params.bulkBody)
-      const childOf = tracer.scope().active()
-      const span = tracer.startSpan('elasticsearch.query', {
+      const span = this.tracer.startSpan('elasticsearch.query', {
         childOf,
         tags: {
-          [Tags.SPAN_KIND]: Tags.SPAN_KIND_RPC_CLIENT,
-          [Tags.DB_TYPE]: 'elasticsearch',
-          'service.name': config.service || `${tracer._service}-elasticsearch`,
+          'db.type': 'elasticsearch',
+          'span.kind': 'client',
+          'service.name': this.config.service || `${this.tracer._service}-elasticsearch`,
           'resource.name': `${params.method} ${quantizePath(params.path)}`,
           'span.type': 'elasticsearch',
           'elasticsearch.url': params.path,
@@ -26,57 +32,25 @@ function createWrapRequest (tracer, config) {
           'elasticsearch.params': JSON.stringify(params.querystring || params.query)
         }
       })
+      analyticsSampler.sample(span, this.config.measured)
+      this.enter(span, store)
+    })
 
-      analyticsSampler.sample(span, config.measured)
-
-      cb = arguments[lastIndex]
-
-      if (typeof cb === 'function') {
-        arguments[lastIndex] = wrapCallback(tracer, span, params, config, cb)
-
-        return tracer.scope().activate(span, () => request.apply(this, arguments))
-      } else {
-        const promise = request.apply(this, arguments)
-
-        if (promise && typeof promise.then === 'function') {
-          promise.then(() => finish(span, params, config), e => finish(span, params, config, e))
-        } else {
-          finish(span, params, config)
-        }
-
-        return promise
-      }
-    }
-  }
-}
+    this.addSub('apm:elasticsearch:query:end', () => {
+      this.exit()
+    })
 
-function wrapCallback (tracer, span, params, config, done) {
-  return tracer.scope().bind(function (err) {
-    finish(span, params, config, err)
-    done.apply(null, arguments)
-  })
-}
+    this.addSub('apm:elasticsearch:query:error', err => {
+      const span = storage.getStore().span
+      span.setTag('error', err)
+    })
 
-function finish (span, params, config, err) {
-  if (err) {
-    span.addTags({
-      'error.type': err.name,
-      'error.msg': err.message,
-      'error.stack': err.stack
+    this.addSub('apm:elasticsearch:query:async-end', ({ params }) => {
+      const span = storage.getStore().span
+      this.config.hooks.query(span, params)
+      span.finish()
     })
   }
-
-  config.hooks.query(span, params)
-
-  span.finish()
-}
-
-function quantizePath (path) {
-  return path && path.replace(/[0-9]+/g, '?')
-}
-
-function getBody (body) {
-  return body && JSON.stringify(body)
 }
 
 function normalizeConfig (config) {
@@ -94,27 +68,12 @@ function getHooks (config) {
   return { query }
 }
 
-module.exports = [
-  {
-    name: 'elasticsearch',
-    file: 'src/lib/transport.js',
-    versions: ['>=10'],
-    patch (Transport, tracer, config) {
-      this.wrap(Transport.prototype, 'request', createWrapRequest(tracer, config))
-    },
-    unpatch (Transport) {
-      this.unwrap(Transport.prototype, 'request')
-    }
-  },
-  {
-    name: '@elastic/elasticsearch',
-    file: 'lib/Transport.js',
-    versions: ['>=5.6.16'], // initial version of this module
-    patch (Transport, tracer, config) {
-      this.wrap(Transport.prototype, 'request', createWrapRequest(tracer, config))
-    },
-    unpatch (Transport) {
-      this.unwrap(Transport.prototype, 'request')
-    }
-  }
-]
+function getBody (body) {
+  return body && JSON.stringify(body)
+}
+
+function quantizePath (path) {
+  return path && path.replace(/[0-9]+/g, '?')
+}
+
+module.exports = ElasticsearchPlugin

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

@@ -165,7 +165,28 @@ function getRes (reply) {
 module.exports = [
   {
     name: 'fastify',
-    versions: ['>=1'],
+    versions: ['>=3'],
+    patch (fastify, tracer, config) {
+      // `fastify` is a function so we return a wrapper that will replace its export.
+      const wrapped = this.wrapExport(fastify, createWrapFastify(tracer, config)(fastify))
+
+      wrapped.fastify = wrapped
+      wrapped.default = wrapped
+
+      return wrapped
+    },
+    unpatch (fastify) {
+      const unwrapped = this.unwrapExport(fastify)
+
+      unwrapped.fastify = unwrapped
+      unwrapped.default = unwrapped
+
+      return unwrapped
+    }
+  },
+  {
+    name: 'fastify',
+    versions: ['1 - 2'],
     patch (fastify, tracer, config) {
       // `fastify` is a function so we return a wrapper that will replace its export.
       return this.wrapExport(fastify, createWrapFastify(tracer, config)(fastify))

package/packages/datadog-plugin-fastify/src/find-my-way.js

@@ -10,7 +10,6 @@ function createWrapOn () {
       const wrapper = function (req) {
         web.patch(req)
         web.enterRoute(req, path)
-        req._datadog.routeEntered = true
 
         return handler.apply(this, arguments)
       }

package/packages/datadog-plugin-google-cloud-pubsub/src/index.js

@@ -2,6 +2,8 @@
 
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
+const messageSpans = new WeakMap()
+
 function createWrapRequest (tracer, config) {
   return function wrapRequest (request) {
     return function requestWithTrace (cfg = { reqOpts: {} }, cb) {
@@ -45,11 +47,11 @@ function createWrapRequest (tracer, config) {
 function createWrapSubscriptionEmit (tracer, config) {
   return function wrapSubscriptionEmit (emit) {
     return function emitWithTrace (eventName, message) {
-      if (eventName !== 'message' || !message || !message._datadog_span) {
-        return emit.apply(this, arguments)
-      }
+      if (eventName !== 'message' || !message) return emit.apply(this, arguments)
+
+      const span = messageSpans.get(message)
 
-      const span = message._datadog_span
+      if (!span) return emit.apply(this, arguments)
 
       return tracer.scope().activate(span, () => {
         try {
@@ -83,7 +85,7 @@ function createWrapLeaseDispense (tracer, config) {
 
       analyticsSampler.sample(span, config.measured, true)
 
-      message._datadog_span = span
+      messageSpans.set(message, span)
 
       return dispense.apply(this, arguments)
     }
@@ -119,7 +121,7 @@ function getTopic (cfg) {
 }
 
 function finish (message) {
-  const span = message._datadog_span
+  const span = messageSpans.get(message)
 
   if (!span) return
 

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

@@ -4,6 +4,11 @@ const pick = require('lodash.pick')
 const log = require('../../dd-trace/src/log')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
+const contexts = new WeakMap()
+const documentSources = new WeakMap()
+const patchedTypes = new WeakSet()
+const patchedResolvers = new WeakSet()
+
 let tools
 
 function createWrapExecute (tracer, config, defaultFieldResolver) {
@@ -12,11 +17,11 @@ function createWrapExecute (tracer, config, defaultFieldResolver) {
       const args = normalizeArgs(arguments, tracer, config, defaultFieldResolver)
       const schema = args.schema
       const document = args.document
-      const source = document && document._datadog_source
+      const source = documentSources.get(document)
       const contextValue = args.contextValue
       const operation = getOperation(document, args.operationName)
 
-      if (contextValue._datadog_graphql) {
+      if (contexts.has(contextValue)) {
         return execute.apply(this, arguments)
       }
 
@@ -26,11 +31,12 @@ function createWrapExecute (tracer, config, defaultFieldResolver) {
       }
 
       const span = startExecutionSpan(tracer, config, operation, args)
+      const context = { source, span, fields: {} }
 
-      contextValue._datadog_graphql = { source, span, fields: {} }
+      contexts.set(contextValue, context)
 
       return call(execute, span, this, arguments, (err, res) => {
-        finishResolvers(contextValue, config)
+        finishResolvers(context)
 
         setError(span, err || (res && res.errors && res.errors[0]))
         config.hooks.execute(span, args, res)
@@ -55,7 +61,7 @@ function createWrapParse (tracer, config) {
         if (!operation) return document // skip schema parsing
 
         if (source) {
-          document._datadog_source = source.body || source
+          documentSources.set(document, source.body || source)
         }
 
         addDocumentTags(span, document, config)
@@ -103,11 +109,11 @@ function createWrapValidate (tracer, config) {
 }
 
 function wrapFields (type, tracer, config) {
-  if (!type || !type._fields || type._datadog_patched) {
+  if (!type || !type._fields || patchedTypes.has(type)) {
     return
   }
 
-  type._datadog_patched = true
+  patchedTypes.add(type)
 
   Object.keys(type._fields).forEach(key => {
     const field = type._fields[key]
@@ -136,14 +142,16 @@ function wrapFieldType (field, tracer, config) {
 }
 
 function wrapResolve (resolve, tracer, config) {
-  if (resolve._datadog_patched || typeof resolve !== 'function') return resolve
+  if (typeof resolve !== 'function' || patchedResolvers.has(resolve)) return resolve
 
   const responsePathAsArray = config.collapse
     ? withCollapse(pathToArray)
     : pathToArray
 
   function resolveWithTrace (source, args, contextValue, info) {
-    if (!contextValue._datadog_graphql) return resolve.apply(this, arguments)
+    const context = contexts.get(contextValue)
+
+    if (!context) return resolve.apply(this, arguments)
 
     const path = responsePathAsArray(info && info.path)
 
@@ -151,18 +159,18 @@ function wrapResolve (resolve, tracer, config) {
       const depth = path.filter(item => typeof item === 'string').length
 
       if (config.depth < depth) {
-        const parent = getParentField(tracer, contextValue, path)
+        const parent = getParentField(tracer, context, path)
 
         return call(resolve, parent.span, this, arguments)
       }
     }
 
-    const field = assertField(tracer, config, contextValue, info, path)
+    const field = assertField(tracer, config, context, info, path)
 
     return call(resolve, field.span, this, arguments, err => updateField(field, err))
   }
 
-  resolveWithTrace._datadog_patched = true
+  patchedResolvers.add(resolveWithTrace)
 
   return resolveWithTrace
 }
@@ -191,9 +199,9 @@ function call (fn, span, thisArg, args, callback) {
   }
 }
 
-function getParentField (tracer, contextValue, path) {
+function getParentField (tracer, context, path) {
   for (let i = path.length - 1; i > 0; i--) {
-    const field = getField(contextValue, path.slice(0, i))
+    const field = getField(context, path.slice(0, i))
 
     if (field) {
       return field
@@ -201,12 +209,12 @@ function getParentField (tracer, contextValue, path) {
   }
 
   return {
-    span: contextValue._datadog_graphql.span
+    span: context.span
   }
 }
 
-function getField (contextValue, path) {
-  return contextValue._datadog_graphql.fields[path.join('.')]
+function getField (context, path) {
+  return context.fields[path.join('.')]
 }
 
 function normalizeArgs (args, tracer, config, defaultFieldResolver) {
@@ -267,8 +275,8 @@ function addExecutionTags (span, config, operation, document, operationName) {
 function addDocumentTags (span, document, config) {
   const tags = {}
 
-  if (config.source && document && document._datadog_source) {
-    tags['graphql.source'] = document._datadog_source
+  if (config.source && document) {
+    tags['graphql.source'] = documentSources.get(document)
   }
 
   span.addTags(tags)
@@ -300,9 +308,9 @@ function startSpan (tracer, config, name, options) {
   })
 }
 
-function startResolveSpan (tracer, config, childOf, path, info, contextValue) {
+function startResolveSpan (tracer, config, childOf, path, info, { source }) {
   const span = startSpan(tracer, config, 'resolve', { childOf })
-  const document = contextValue._datadog_graphql.source
+  const document = source
   const fieldNode = info.fieldNodes.find(fieldNode => fieldNode.kind === 'Field')
 
   analyticsSampler.sample(span, config.measured)
@@ -345,9 +353,7 @@ function finish (span, finishTime) {
   span.finish(finishTime)
 }
 
-function finishResolvers (contextValue) {
-  const fields = contextValue._datadog_graphql.fields
-
+function finishResolvers ({ fields }) {
   Object.keys(fields).reverse().forEach(key => {
     const field = fields[key]
 
@@ -369,18 +375,18 @@ function withCollapse (responsePathAsArray) {
   }
 }
 
-function assertField (tracer, config, contextValue, info, path) {
+function assertField (tracer, config, context, info, path) {
   const pathString = path.join('.')
-  const fields = contextValue._datadog_graphql.fields
+  const fields = context.fields
 
   let field = fields[pathString]
 
   if (!field) {
-    const parent = getParentField(tracer, contextValue, path)
+    const parent = getParentField(tracer, context, path)
 
     field = fields[pathString] = {
       parent,
-      span: startResolveSpan(tracer, config, parent.span, path, info, contextValue),
+      span: startResolveSpan(tracer, config, parent.span, path, info, context),
       error: null
     }
   }