dd-trace 2.5.0 → 2.7.1

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 }

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

@@ -1,90 +1,85 @@
 'use strict'
 
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
-function createWrapProducer (tracer, config) {
-  return function wrapProducer (createProducer) {
-    return function producerWithTrace () {
-      const serviceName = config.service || `${tracer._service}-kafka`
-      const producer = createProducer.apply(this, arguments)
-
-      const send = producer.send
-
-      const tags = {
-        'service.name': serviceName,
-        'span.kind': 'producer',
-        'component': 'kafkajs'
-      }
+class KafkajsPlugin extends Plugin {
+  static get name () {
+    return 'kafkajs'
+  }
 
-      producer.send = tracer.wrap('kafka.produce', { tags }, function (...args) {
-        const { topic, messages = [] } = args[0]
-        const currentSpan = tracer.scope().active()
+  constructor (...args) {
+    super(...args)
+
+    this.addSub(`apm:kafkajs:produce:start`, ({ topic, messages }) => {
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
+      const span = this.tracer.startSpan('kafka.produce', {
+        childOf,
+        tags: {
+          'service.name': this.config.service || `${this.tracer._service}-kafka`,
+          'span.kind': 'producer',
+          'component': 'kafkajs'
+        }
+      })
 
-        analyticsSampler.sample(currentSpan, config.measured)
+      analyticsSampler.sample(span, this.config.measured)
+      this.enter(span, store)
 
-        currentSpan.addTags({
+      span.addTags({
+        'resource.name': topic,
+        'kafka.topic': topic,
+        'kafka.batch_size': messages.length
+      })
+      for (const message of messages) {
+        if (typeof message === 'object') {
+          this.tracer.inject(span, 'text_map', message.headers)
+        }
+      }
+    })
+
+    this.addSub(`apm:kafkajs:consume:start`, ({ topic, partition, message }) => {
+      const store = storage.getStore()
+      const childOf = extract(this.tracer, message.headers)
+      const span = this.tracer.startSpan('kafka.consume', {
+        childOf,
+        tags: {
+          'service.name': this.config.service || `${this.tracer._service}-kafka`,
+          'span.kind': 'consumer',
+          'span.type': 'worker',
+          'component': 'kafkajs',
           'resource.name': topic,
           'kafka.topic': topic,
-          'kafka.batch_size': messages.length
-        })
-
-        for (const message of messages) {
-          message.headers = message.headers || {}
-          tracer.inject(currentSpan, 'text_map', message.headers)
+          'kafka.partition': partition,
+          'kafka.message.offset': message.offset
         }
-
-        return send.apply(this, args)
       })
 
-      return producer
-    }
-  }
-}
+      analyticsSampler.sample(span, this.config.measured, true)
+      this.enter(span, store)
+    })
 
-function createWrapConsumer (tracer, config) {
-  return function wrapConsumer (createConsumer) {
-    return function consumerWithTrace () {
-      const serviceName = config.service || `${tracer._service}-kafka`
-      const consumer = createConsumer.apply(this, arguments)
-      const run = consumer.run
-
-      const tags = {
-        'service.name': serviceName,
-        'span.kind': 'consumer',
-        'span.type': 'worker',
-        'component': 'kafkajs'
-      }
+    this.addSub(`apm:kafkajs:end`, () => {
+      this.exit()
+    })
 
-      consumer.run = function ({ eachMessage, ...runArgs }) {
-        if (typeof eachMessage !== 'function') return run({ eachMessage, ...runArgs })
+    this.addSub(`apm:kafkajs:consume:error`, errorHandler)
 
-        return run({
-          eachMessage: function (...eachMessageArgs) {
-            const { topic, partition, message } = eachMessageArgs[0]
-            const childOf = extract(tracer, message.headers)
+    this.addSub(`apm:kafkajs:consume:finish`, finishHandler)
 
-            return tracer.trace('kafka.consume', { childOf, tags }, () => {
-              const currentSpan = tracer.scope().active()
+    this.addSub(`apm:kafkajs:produce:error`, errorHandler)
 
-              analyticsSampler.sample(currentSpan, config.measured, true)
-
-              currentSpan.addTags({
-                'resource.name': topic,
-                'kafka.topic': topic,
-                'kafka.partition': partition,
-                'kafka.message.offset': message.offset
-              })
+    this.addSub(`apm:kafkajs:produce:finish`, finishHandler)
+  }
+}
 
-              return eachMessage.apply(this, eachMessageArgs)
-            })
-          },
-          ...runArgs
-        })
-      }
+function finishHandler () {
+  storage.getStore().span.finish()
+}
 
-      return consumer
-    }
-  }
+function errorHandler (error) {
+  storage.getStore().span.setTag('error', error)
 }
 
 function extract (tracer, bufferMap) {
@@ -99,25 +94,4 @@ function extract (tracer, bufferMap) {
   return tracer.extract('text_map', textMap)
 }
 
-module.exports = [
-  {
-    name: 'kafkajs',
-    versions: ['>=1.4'],
-    patch ({ Kafka }, tracer, config) {
-      this.wrap(
-        Kafka.prototype,
-        'producer',
-        createWrapProducer(tracer, config)
-      )
-      this.wrap(
-        Kafka.prototype,
-        'consumer',
-        createWrapConsumer(tracer, config)
-      )
-    },
-    unpatch ({ Kafka }) {
-      this.unwrap(Kafka.prototype, 'producer')
-      this.unwrap(Kafka.prototype, 'consumer')
-    }
-  }
-]
+module.exports = KafkajsPlugin