dd-trace 2.4.2 → 2.7.0

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

@@ -5,20 +5,18 @@ const { storage } = require('../../datadog-core')
 
 const {
   CI_APP_ORIGIN,
-  TEST_TYPE,
-  TEST_NAME,
-  TEST_SUITE,
   TEST_SKIP_REASON,
-  TEST_FRAMEWORK_VERSION,
   ERROR_MESSAGE,
   TEST_STATUS,
+  TEST_CODE_OWNERS,
   finishAllTraceSpans,
   getTestEnvironmentMetadata,
-  getTestSuitePath
+  getTestSuitePath,
+  getCodeOwnersFileEntries,
+  getCodeOwnersForFilename,
+  getTestCommonTags
 } = require('../../dd-trace/src/plugins/util/test')
-const { SPAN_TYPE, RESOURCE_NAME, SAMPLING_PRIORITY } = require('../../../ext/tags')
-const { SAMPLING_RULE_DECISION } = require('../../dd-trace/src/constants')
-const { AUTO_KEEP } = require('../../../ext/priority')
+const { RESOURCE_NAME } = require('../../../ext/tags')
 
 class CucumberPlugin extends Plugin {
   static get name () {
@@ -30,26 +28,28 @@ class CucumberPlugin extends Plugin {
 
     const testEnvironmentMetadata = getTestEnvironmentMetadata('cucumber', this.config)
     const sourceRoot = process.cwd()
+    const codeOwnersEntries = getCodeOwnersFileEntries(sourceRoot)
 
     this.addSub('ci:cucumber:run:start', ({ pickleName, pickleUri }) => {
       const store = storage.getStore()
       const childOf = store ? store.span : store
       const testSuite = getTestSuitePath(pickleUri, sourceRoot)
 
+      const commonTags = getTestCommonTags(pickleName, testSuite, this.tracer._version)
+
+      const codeOwners = getCodeOwnersForFilename(testSuite, codeOwnersEntries)
+      if (codeOwners) {
+        commonTags[TEST_CODE_OWNERS] = codeOwners
+      }
+
       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,
-          [SAMPLING_PRIORITY]: AUTO_KEEP,
-          [TEST_FRAMEWORK_VERSION]: this.tracer._version,
+          ...commonTags,
           ...testEnvironmentMetadata
         }
       })
+
       span.context()._trace.origin = CI_APP_ORIGIN
       this.enter(span, store)
     })

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

@@ -1,6 +1,11 @@
-module.exports = [
-  {
-    name: 'cypress',
-    versions: ['>=6.7.0']
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+
+// Cypress plugin does not patch any library. This is just a placeholder to
+// follow the structure of the plugins
+class CypressPlugin extends Plugin {
+  static get name () {
+    return 'cypress'
   }
-]
+}
+
+module.exports = CypressPlugin

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

@@ -1,18 +1,16 @@
 const {
-  TEST_TYPE,
-  TEST_NAME,
-  TEST_SUITE,
   TEST_STATUS,
-  TEST_FRAMEWORK_VERSION,
   TEST_IS_RUM_ACTIVE,
+  TEST_CODE_OWNERS,
   getTestEnvironmentMetadata,
   CI_APP_ORIGIN,
-  getTestParentSpan
+  getTestParentSpan,
+  getCodeOwnersFileEntries,
+  getCodeOwnersForFilename,
+  getTestCommonTags
 } = require('../../dd-trace/src/plugins/util/test')
 
-const { SAMPLING_RULE_DECISION, ORIGIN_KEY } = require('../../dd-trace/src/constants')
-const { SAMPLING_PRIORITY, SPAN_TYPE, RESOURCE_NAME } = require('../../../ext/tags')
-const { AUTO_KEEP } = require('../../../ext/priority')
+const { ORIGIN_KEY } = require('../../dd-trace/src/constants')
 
 const CYPRESS_STATUS_TO_TEST_STATUS = {
   passed: 'pass',
@@ -24,21 +22,20 @@ const CYPRESS_STATUS_TO_TEST_STATUS = {
 function getTestSpanMetadata (tracer, testName, testSuite, cypressConfig) {
   const childOf = getTestParentSpan(tracer)
 
+  const commonTags = getTestCommonTags(testName, testSuite, cypressConfig.version)
+
   return {
     childOf,
-    resource: `${testSuite}.${testName}`,
-    [TEST_TYPE]: 'test',
-    [TEST_NAME]: testName,
-    [TEST_SUITE]: testSuite,
-    [SAMPLING_RULE_DECISION]: 1,
-    [SAMPLING_PRIORITY]: AUTO_KEEP,
-    [TEST_FRAMEWORK_VERSION]: cypressConfig.version
+    ...commonTags
   }
 }
 
 module.exports = (on, config) => {
   const tracer = require('../../dd-trace')
   const testEnvironmentMetadata = getTestEnvironmentMetadata('cypress')
+
+  const codeOwnersEntries = getCodeOwnersFileEntries()
+
   let activeSpan = null
   on('after:run', () => {
     return new Promise(resolve => {
@@ -55,12 +52,16 @@ module.exports = (on, config) => {
         ...testSpanMetadata
       } = getTestSpanMetadata(tracer, testName, testSuite, config)
 
+      const codeOwners = getCodeOwnersForFilename(testSuite, codeOwnersEntries)
+
+      if (codeOwners) {
+        testSpanMetadata[TEST_CODE_OWNERS] = codeOwners
+      }
+
       if (!activeSpan) {
         activeSpan = tracer.startSpan('cypress.test', {
           childOf,
           tags: {
-            [SPAN_TYPE]: 'test',
-            [RESOURCE_NAME]: resource,
             [ORIGIN_KEY]: CI_APP_ORIGIN,
             ...testSpanMetadata,
             ...testEnvironmentMetadata

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

@@ -44,7 +44,18 @@ class DNSPlugin extends Plugin {
       this.enter(span, store)
     }, (result) => {
       const { span } = storage.getStore()
-      span.setTag('dns.address', result)
+
+      if (Array.isArray(result)) {
+        const addresses = Array.isArray(result)
+          ? result.map(address => address.address).sort()
+          : [result]
+
+        span.setTag('dns.address', addresses[0])
+        span.setTag('dns.addresses', addresses.join(','))
+      } else {
+        span.setTag('dns.address', result)
+      }
+
       span.finish()
     })
 

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

@@ -1,33 +1,19 @@
 'use strict'
 
-const web = require('../../dd-trace/src/plugins/util/web')
-const routerPlugin = require('../../datadog-plugin-router/src')
+const RouterPlugin = require('../../datadog-plugin-router/src')
 
-function createWrapHandle (tracer, config) {
-  config = web.normalizeConfig(config)
-
-  return function wrapHandle (handle) {
-    return function handleWithTrace (req, res) {
-      web.instrument(tracer, config, req, res, 'express.request')
-
-      return handle.apply(this, arguments)
-    }
+class ExpressPlugin extends RouterPlugin {
+  static get name () {
+    return 'express'
   }
-}
 
-function patch (express, tracer, config) {
-  this.wrap(express.application, 'handle', createWrapHandle(tracer, config))
-  routerPlugin.patch.call(this, { prototype: express.Router }, tracer, config)
-}
+  constructor (...args) {
+    super(...args)
 
-function unpatch (express) {
-  this.unwrap(express.application, 'handle')
-  routerPlugin.unpatch.call(this, { prototype: express.Router })
+    this.addSub('apm:express:request:handle', ({ req }) => {
+      this.setFramework(req, 'express', this.config)
+    })
+  }
 }
 
-module.exports = {
-  name: 'express',
-  versions: ['>=4'],
-  patch,
-  unpatch
-}
+module.exports = ExpressPlugin

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

@@ -1,6 +1,19 @@
 'use strict'
 
-module.exports = [].concat(
-  require('./fastify'),
-  require('./find-my-way') // TODO make this its own plugin, since restify uses it too
-)
+const RouterPlugin = require('../../datadog-plugin-router/src')
+
+class FastifyPlugin extends RouterPlugin {
+  static get name () {
+    return 'fastify'
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:fastify:request:handle', ({ req }) => {
+      this.setFramework(req, 'fastify', this.config)
+    })
+  }
+}
+
+module.exports = FastifyPlugin

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

@@ -0,0 +1,20 @@
+'use strict'
+
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const web = require('../../dd-trace/src/plugins/util/web')
+
+class FindMyWayPlugin extends Plugin {
+  static get name () {
+    return 'find-my-way'
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:find-my-way:request:route', ({ req, route }) => {
+      web.setRoute(req, route)
+    })
+  }
+}
+
+module.exports = FindMyWayPlugin

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

@@ -60,6 +60,7 @@ function createWrapCreateReadStream (config, tracer) {
       const tags = makeFSFlagTags('ReadStream', path, options, 'r', config, tracer)
       return tracer.trace('fs.operation', { tags, orphanable }, (span, done) => {
         const stream = createReadStream.apply(this, arguments)
+        stream.once('close', done)
         stream.once('end', done)
         stream.once('error', done)
         return stream
@@ -74,6 +75,7 @@ function createWrapCreateWriteStream (config, tracer) {
       const tags = makeFSFlagTags('WriteStream', path, options, 'w', config, tracer)
       return tracer.trace('fs.operation', { tags, orphanable }, (span, done) => {
         const stream = createWriteStream.apply(this, arguments)
+        stream.once('close', done)
         stream.once('finish', done)
         stream.once('error', done)
         return stream

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

@@ -1,116 +1,98 @@
 'use strict'
 
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
 const messageSpans = new WeakMap()
+class GoogleCloudPubsubPlugin extends Plugin {
+  static get name () {
+    return 'google-cloud-pubsub'
+  }
+
+  constructor (...args) {
+    super(...args)
 
-function createWrapRequest (tracer, config) {
-  return function wrapRequest (request) {
-    return function requestWithTrace (cfg = { reqOpts: {} }, cb) {
+    this.addSub(`apm:google-cloud-pubsub:request:start`, ({ cfg, projectId, messages }) => {
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
       const topic = getTopic(cfg)
       const tags = {
         component: '@google-cloud/pubsub',
         'resource.name': [cfg.method, topic].filter(x => x).join(' '),
-        'service.name': config.service || `${tracer._service}-pubsub`,
+        'service.name': this.config.service || `${this.tracer._service}-pubsub`,
         'span.kind': 'client',
         'pubsub.method': cfg.method,
-        'gcloud.project_id': this.projectId,
+        'gcloud.project_id': projectId,
         'pubsub.topic': topic
       }
       if (cfg.method === 'publish') {
         tags['span.kind'] = 'producer'
       }
-      cb = tracer.scope().bind(cb)
-      return tracer.trace('pubsub.request', { tags }, (span, done) => {
-        analyticsSampler.sample(span, config.measured)
-
-        if (cfg.reqOpts && cfg.method === 'publish') {
-          for (const msg of cfg.reqOpts.messages) {
-            if (!msg.attributes) {
-              msg.attributes = {}
-            }
-            tracer.inject(span, 'text_map', msg.attributes)
-          }
-        }
-
-        arguments[1] = function (err) {
-          done(err)
-          return cb.apply(this, arguments)
-        }
-
-        return request.apply(this, arguments)
+      const span = this.tracer.startSpan('pubsub.request', {
+        childOf,
+        tags
       })
-    }
-  }
-}
 
-function createWrapSubscriptionEmit (tracer, config) {
-  return function wrapSubscriptionEmit (emit) {
-    return function emitWithTrace (eventName, message) {
-      if (eventName !== 'message' || !message) return emit.apply(this, arguments)
+      analyticsSampler.sample(span, this.config.measured)
+      this.enter(span, store)
 
-      const span = messageSpans.get(message)
-
-      if (!span) return emit.apply(this, arguments)
-
-      return tracer.scope().activate(span, () => {
-        try {
-          return emit.apply(this, arguments)
-        } catch (e) {
-          span.setTag('error', e)
-          throw e
+      for (const msg of messages) {
+        if (!msg.attributes) {
+          msg.attributes = {}
         }
-      })
-    }
-  }
-}
+        this.tracer.inject(span, 'text_map', msg.attributes)
+      }
+    })
 
-function createWrapLeaseDispense (tracer, config) {
-  return function wrapDispense (dispense) {
-    return function dispenseWithTrace (message) {
+    this.addSub(`apm:google-cloud-pubsub:receive:start`, ({ message }) => {
+      const store = storage.getStore()
       const subscription = message._subscriber._subscription
       const topic = subscription.metadata && subscription.metadata.topic
+      const childOf = this.tracer.extract('text_map', message.attributes)
       const tags = {
         component: '@google-cloud/pubsub',
         'resource.name': topic,
-        'service.name': config.service || tracer._service,
+        'service.name': this.config.service || this.tracer._service,
         'gcloud.project_id': subscription.pubsub.projectId,
         'pubsub.topic': topic,
         'span.kind': 'consumer',
         'span.type': 'worker'
       }
 
-      const childOf = tracer.extract('text_map', message.attributes)
-      const span = tracer.startSpan('pubsub.receive', { tags, childOf })
+      const span = this.tracer.startSpan('pubsub.receive', {
+        childOf,
+        tags
+      })
 
-      analyticsSampler.sample(span, config.measured, true)
+      analyticsSampler.sample(span, this.config.measured, true)
+      this.enter(span, store)
 
       messageSpans.set(message, span)
+    })
 
-      return dispense.apply(this, arguments)
-    }
-  }
-}
+    this.addSub(`apm:google-cloud-pubsub:request:error`, err => {
+      const span = storage.getStore().span
+      span.setTag('error', err)
+    })
 
-function createWrapLeaseRemove (tracer, config) {
-  return function wrapRemove (remove) {
-    return function removeWithTrace (message) {
-      finish(message)
+    this.addSub(`apm:google-cloud-pubsub:request:finish`, () => {
+      const span = storage.getStore().span
+      span.finish()
+    })
 
-      return remove.apply(this, arguments)
-    }
-  }
-}
-
-function createWrapLeaseClear (tracer, config) {
-  return function wrapClear (clear) {
-    return function clearWithTrace () {
-      for (const message of this._messages) {
-        finish(message)
-      }
+    this.addSub(`apm:google-cloud-pubsub:receive:error`, ({ err, message }) => {
+      const span = messageSpans.get(message)
+      if (!span) return undefined
+      span.setTag('error', err)
+    })
 
-      return clear.apply(this, arguments)
-    }
+    this.addSub(`apm:google-cloud-pubsub:receive:finish`, ({ message }) => {
+      const span = messageSpans.get(message)
+      if (!span) return
+      span.setTag('pubsub.ack', message._handled ? 1 : 0)
+      span.finish()
+    })
   }
 }
 
@@ -120,41 +102,4 @@ function getTopic (cfg) {
   }
 }
 
-function finish (message) {
-  const span = messageSpans.get(message)
-
-  if (!span) return
-
-  span.setTag('pubsub.ack', message._handled ? 1 : 0)
-  span.finish()
-}
-
-module.exports = [
-  {
-    name: '@google-cloud/pubsub',
-    versions: ['>=1.2'],
-    patch ({ PubSub, Subscription }, tracer, config) {
-      this.wrap(PubSub.prototype, 'request', createWrapRequest(tracer, config))
-      this.wrap(Subscription.prototype, 'emit', createWrapSubscriptionEmit(tracer, config))
-    },
-    unpatch ({ PubSub, Subscription }) {
-      this.unwrap(PubSub.prototype, 'request')
-      this.unwrap(Subscription.prototype, 'emit')
-    }
-  },
-  {
-    name: '@google-cloud/pubsub',
-    versions: ['>=1.2'],
-    file: 'build/src/lease-manager.js',
-    patch ({ LeaseManager }, tracer, config) {
-      this.wrap(LeaseManager.prototype, '_dispense', createWrapLeaseDispense(tracer, config))
-      this.wrap(LeaseManager.prototype, 'remove', createWrapLeaseRemove(tracer, config))
-      this.wrap(LeaseManager.prototype, 'clear', createWrapLeaseClear(tracer, config))
-    },
-    unpatch ({ LeaseManager }) {
-      this.unwrap(LeaseManager.prototype, '_dispense')
-      this.unwrap(LeaseManager.prototype, 'remove')
-      this.unwrap(LeaseManager.prototype, 'clear')
-    }
-  }
-]
+module.exports = GoogleCloudPubsubPlugin

package/packages/datadog-plugin-http/src/server.js

@@ -4,9 +4,6 @@ const Plugin = require('../../dd-trace/src/plugins/plugin')
 const { storage } = require('../../datadog-core')
 const web = require('../../dd-trace/src/plugins/util/web')
 const { incomingHttpRequestStart } = require('../../dd-trace/src/appsec/gateway/channels')
-const tags = require('../../../ext/tags')
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-const SERVICE_NAME = tags.SERVICE_NAME
 
 class HttpServerPlugin extends Plugin {
   static get name () {
@@ -20,11 +17,6 @@ class HttpServerPlugin extends Plugin {
       const store = storage.getStore()
       const span = web.startSpan(this.tracer, this.config, req, res, 'http.request')
 
-      if (this.config.service) {
-        span.setTag(SERVICE_NAME, this.config.service)
-      }
-
-      analyticsSampler.sample(span, this.config.measured, true)
       this.enter(span, store)
 
       const context = web.getContext(req)
@@ -52,10 +44,10 @@ class HttpServerPlugin extends Plugin {
       })
     })
 
-    this.addSub('apm:http:server:request:async-end', ({ req }) => {
+    this.addSub('apm:http:server:request:finish', ({ req }) => {
       const context = web.getContext(req)
 
-      if (!context) return // Not created by a http.Server instance.
+      if (!context || !context.res) return // Not created by a http.Server instance.
 
       web.wrapRes(context, context.req, context.res, context.res.end)()
     })

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

@@ -1,4 +1,102 @@
-const jestEnvironment = require('./jest-environment')
-const jestJasmine2 = require('./jest-jasmine2')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 
-module.exports = [].concat(jestEnvironment, jestJasmine2)
+const {
+  CI_APP_ORIGIN,
+  TEST_STATUS,
+  JEST_TEST_RUNNER,
+  finishAllTraceSpans,
+  getTestEnvironmentMetadata,
+  getTestParentSpan,
+  getTestCommonTags,
+  TEST_PARAMETERS,
+  getCodeOwnersFileEntries,
+  getCodeOwnersForFilename,
+  TEST_CODE_OWNERS
+} = require('../../dd-trace/src/plugins/util/test')
+
+function getTestSpanMetadata (tracer, test) {
+  const childOf = getTestParentSpan(tracer)
+
+  const { suite, name, runner, testParameters } = test
+
+  const commonTags = getTestCommonTags(name, suite, tracer._version)
+
+  return {
+    childOf,
+    ...commonTags,
+    [JEST_TEST_RUNNER]: runner,
+    [TEST_PARAMETERS]: testParameters
+  }
+}
+
+class JestPlugin extends Plugin {
+  static get name () {
+    return 'jest'
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.testEnvironmentMetadata = getTestEnvironmentMetadata('jest', this.config)
+    this.codeOwnersEntries = getCodeOwnersFileEntries()
+
+    this.addSub('ci:jest:test:start', (test) => {
+      const store = storage.getStore()
+      const span = this.startTestSpan(test)
+
+      this.enter(span, store)
+    })
+
+    this.addSub('ci:jest:test:end', (status) => {
+      const span = storage.getStore().span
+      span.setTag(TEST_STATUS, status)
+      span.finish()
+      finishAllTraceSpans(span)
+      this.exit()
+    })
+
+    this.addSub('ci:jest:test-suite:end', () => {
+      this.tracer._exporter._writer.flush()
+    })
+
+    this.addSub('ci:jest:test:err', (error) => {
+      if (error) {
+        const span = storage.getStore().span
+        span.setTag(TEST_STATUS, 'fail')
+        span.setTag('error', error)
+      }
+    })
+
+    this.addSub('ci:jest:test:skip', (test) => {
+      const span = this.startTestSpan(test)
+      span.setTag(TEST_STATUS, 'skip')
+      span.finish()
+    })
+  }
+
+  startTestSpan (test) {
+    const { childOf, ...testSpanMetadata } = getTestSpanMetadata(this.tracer, test)
+
+    const codeOwners = getCodeOwnersForFilename(test.suite, this.codeOwnersEntries)
+
+    if (codeOwners) {
+      testSpanMetadata[TEST_CODE_OWNERS] = codeOwners
+    }
+
+    const testSpan = this.tracer
+      .startSpan('jest.test', {
+        childOf,
+        tags: {
+          ...this.testEnvironmentMetadata,
+          ...testSpanMetadata
+        }
+      })
+
+    testSpan.context()._trace.origin = CI_APP_ORIGIN
+
+    return testSpan
+  }
+}
+
+module.exports = JestPlugin

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

@@ -1,8 +1,3 @@
-const { SAMPLING_RULE_DECISION } = require('../../dd-trace/src/constants')
-const { SAMPLING_PRIORITY, SPAN_TYPE } = require('../../../ext/tags')
-const { AUTO_KEEP } = require('../../../ext/priority')
-const { TEST_TYPE, TEST_STATUS, getTestParentSpan } = require('../../dd-trace/src/plugins/util/test')
-
 /**
  * There are two ways to call `test.each` in `jest`:
  * 1. With an array of arrays: https://jestjs.io/docs/api#1-testeachtablename-fn-timeout
@@ -38,27 +33,4 @@ function getFormattedJestTestParameters (testParameters) {
   return formattedParameters
 }
 
-function getTestSpanTags (tracer, testEnvironmentMetadata) {
-  const childOf = getTestParentSpan(tracer)
-
-  const commonSpanTags = {
-    [TEST_TYPE]: 'test',
-    [SAMPLING_RULE_DECISION]: 1,
-    [SAMPLING_PRIORITY]: AUTO_KEEP,
-    [SPAN_TYPE]: 'test',
-    ...testEnvironmentMetadata
-  }
-  return {
-    childOf,
-    commonSpanTags
-  }
-}
-
-function setSuppressedErrors (suppressedErrors, testSpan) {
-  if (suppressedErrors && suppressedErrors.length) {
-    testSpan.setTag('error', suppressedErrors[0])
-    testSpan.setTag(TEST_STATUS, 'fail')
-  }
-}
-
-module.exports = { getFormattedJestTestParameters, getTestSpanTags, setSuppressedErrors }
+module.exports = { getFormattedJestTestParameters }