dd-trace 3.3.1 → 3.12.1

package/packages/datadog-plugin-amqplib/src/producer.js

@@ -0,0 +1,37 @@
+'use strict'
+
+const { TEXT_MAP } = require('../../../ext/formats')
+const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
+const { getResourceName } = require('./util')
+
+class AmqplibProducerPlugin extends ProducerPlugin {
+  static get name () { return 'amqplib' }
+  static get operation () { return 'command' }
+
+  start ({ channel = {}, method, fields }) {
+    if (method !== 'basic.publish') return
+
+    const stream = (channel.connection && channel.connection.stream) || {}
+    const span = this.startSpan('amqp.command', {
+      service: this.config.service || `${this.tracer._service}-amqp`,
+      resource: getResourceName(method, fields),
+      kind: 'producer',
+      meta: {
+        'out.host': stream._host,
+        'out.port': stream.remotePort,
+        'amqp.queue': fields.queue,
+        'amqp.exchange': fields.exchange,
+        'amqp.routingKey': fields.routingKey,
+        'amqp.consumerTag': fields.consumerTag,
+        'amqp.source': fields.source,
+        'amqp.destination': fields.destination
+      }
+    })
+
+    fields.headers = fields.headers || {}
+
+    this.tracer.inject(span, TEXT_MAP, fields.headers)
+  }
+}
+
+module.exports = AmqplibProducerPlugin

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

@@ -0,0 +1,14 @@
+'use strict'
+
+function getResourceName (method, fields = {}) {
+  return [
+    method,
+    fields.exchange,
+    fields.routingKey,
+    fields.queue,
+    fields.source,
+    fields.destination
+  ].filter(val => val).join(' ')
+}
+
+module.exports = { getResourceName }

package/packages/datadog-plugin-cassandra-driver/src/index.js

@@ -1,66 +1,28 @@
 'use strict'
 
-const Plugin = require('../../dd-trace/src/plugins/plugin')
-const { storage } = require('../../datadog-core')
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-
-class CassandraDriverPlugin extends Plugin {
-  static get name () {
-    return 'cassandra-driver'
-  }
-  constructor (...args) {
-    super(...args)
-
-    this.addSub(`apm:cassandra:query:start`, ({ keyspace, query, connectionOptions }) => {
-      const store = storage.getStore()
-      const childOf = store ? store.span : store
-
-      if (Array.isArray(query)) {
-        query = combine(query)
-      }
-
-      const span = this.tracer.startSpan('cassandra.query', {
-        childOf,
-        tags: {
-          'service.name': this.config.service || `${this.tracer._service}-cassandra`,
-          'resource.name': trim(query, 5000),
-          'span.type': 'cassandra',
-          'span.kind': 'client',
-          'db.type': 'cassandra',
-          'cassandra.query': query,
-          'cassandra.keyspace': keyspace
-        }
-      })
-
-      if (connectionOptions) {
-        span.addTags({
-          'out.host': connectionOptions.host,
-          'out.port': connectionOptions.port
-        })
-      }
-
-      analyticsSampler.sample(span, this.config.measured)
-      this.enter(span, store)
-    })
-
-    this.addSub(`apm:cassandra:query:error`, err => {
-      storage.getStore().span.setTag('error', err)
-    })
-
-    this.addSub(`apm:cassandra:query:finish`, () => {
-      storage.getStore().span.finish()
-    })
-
-    this.addSub(`apm:cassandra:query:addConnection`, connectionOptions => {
-      const store = storage.getStore()
-      if (!store) {
-        return
-      }
-      const span = store.span
-      span.addTags({
-        'out.host': connectionOptions.address,
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+
+class CassandraDriverPlugin extends DatabasePlugin {
+  static get name () { return 'cassandra-driver' }
+  static get system () { return 'cassandra' }
+
+  start ({ keyspace, query, connectionOptions = {} }) {
+    if (Array.isArray(query)) {
+      query = combine(query)
+    }
+
+    this.startSpan('cassandra.query', {
+      service: this.config.service,
+      resource: trim(query, 5000),
+      type: 'cassandra',
+      kind: 'client',
+      meta: {
+        'db.type': 'cassandra',
+        'cassandra.query': query,
+        'cassandra.keyspace': keyspace,
+        'out.host': connectionOptions.host,
         'out.port': connectionOptions.port
-      })
+      }
     })
   }
 }

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

@@ -1,24 +1,18 @@
 'use strict'
 
-const Plugin = require('../../dd-trace/src/plugins/plugin')
+const CiPlugin = require('../../dd-trace/src/plugins/ci_plugin')
 const { storage } = require('../../datadog-core')
 
 const {
-  CI_APP_ORIGIN,
   TEST_SKIP_REASON,
-  ERROR_MESSAGE,
   TEST_STATUS,
-  TEST_CODE_OWNERS,
   finishAllTraceSpans,
-  getTestEnvironmentMetadata,
-  getTestSuitePath,
-  getCodeOwnersFileEntries,
-  getCodeOwnersForFilename,
-  getTestCommonTags
+  getTestSuitePath
 } = require('../../dd-trace/src/plugins/util/test')
 const { RESOURCE_NAME } = require('../../../ext/tags')
+const { COMPONENT, ERROR_MESSAGE } = require('../../dd-trace/src/constants')
 
-class CucumberPlugin extends Plugin {
+class CucumberPlugin extends CiPlugin {
   static get name () {
     return 'cucumber'
   }
@@ -26,36 +20,18 @@ class CucumberPlugin extends Plugin {
   constructor (...args) {
     super(...args)
 
-    const testEnvironmentMetadata = getTestEnvironmentMetadata('cucumber', this.config)
-    const sourceRoot = process.cwd()
-    const codeOwnersEntries = getCodeOwnersFileEntries(sourceRoot)
-
     this.addSub('ci:cucumber:session:finish', () => {
-      this.tracer._exporter._writer.flush()
+      this.tracer._exporter.flush()
     })
 
-    this.addSub('ci:cucumber:run:start', ({ pickleName, pickleUri }) => {
+    this.addSub('ci:cucumber:run:start', ({ testName, fullTestSuite }) => {
       const store = storage.getStore()
       const childOf = store ? store.span : store
-      const testSuite = getTestSuitePath(pickleUri, sourceRoot)
-
-      const commonTags = getTestCommonTags(pickleName, testSuite, this.tracer._version)
+      const testSuite = getTestSuitePath(fullTestSuite, process.cwd())
 
-      const codeOwners = getCodeOwnersForFilename(testSuite, codeOwnersEntries)
-      if (codeOwners) {
-        commonTags[TEST_CODE_OWNERS] = codeOwners
-      }
+      const testSpan = this.startTestSpan(testName, testSuite, childOf)
 
-      const span = this.tracer.startSpan('cucumber.test', {
-        childOf,
-        tags: {
-          ...commonTags,
-          ...testEnvironmentMetadata
-        }
-      })
-
-      span.context()._trace.origin = CI_APP_ORIGIN
-      this.enter(span, store)
+      this.enter(testSpan, store)
     })
 
     this.addSub('ci:cucumber:run-step:start', ({ resource }) => {
@@ -64,6 +40,7 @@ class CucumberPlugin extends Plugin {
       const span = this.tracer.startSpan('cucumber.step', {
         childOf,
         tags: {
+          [COMPONENT]: this.constructor.name,
           'cucumber.step': resource,
           [RESOURCE_NAME]: resource
         }
@@ -98,6 +75,10 @@ class CucumberPlugin extends Plugin {
       }
     })
   }
+
+  startTestSpan (testName, testSuite, childOf) {
+    return super.startTestSpan(testName, testSuite, {}, childOf)
+  }
 }
 
 module.exports = CucumberPlugin

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

@@ -10,7 +10,7 @@ const {
   getTestCommonTags
 } = require('../../dd-trace/src/plugins/util/test')
 
-const { ORIGIN_KEY } = require('../../dd-trace/src/constants')
+const { ORIGIN_KEY, COMPONENT } = require('../../dd-trace/src/constants')
 
 const CYPRESS_STATUS_TO_TEST_STATUS = {
   passed: 'pass',
@@ -62,6 +62,7 @@ module.exports = (on, config) => {
         activeSpan = tracer.startSpan('cypress.test', {
           childOf,
           tags: {
+            [COMPONENT]: 'cypress',
             [ORIGIN_KEY]: CI_APP_ORIGIN,
             ...testSpanMetadata,
             ...testEnvironmentMetadata

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

@@ -1,98 +1,23 @@
 'use strict'
 
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-const Plugin = require('../../dd-trace/src/plugins/plugin')
-const { storage } = require('../../datadog-core')
-
-class DNSPlugin extends Plugin {
-  static get name () {
-    return 'dns'
-  }
-
-  addSubs (func, start, finish = defaultFinish) {
-    this.addSub(`apm:dns:${func}:start`, start)
-    this.addSub(`apm:dns:${func}:error`, errorHandler)
-    this.addSub(`apm:dns:${func}:finish`, finish)
-  }
-
-  startSpan (name, customTags, store) {
-    const tags = {
-      'service.name': this.config.service || this.tracer._service,
-      'span.kind': 'client'
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const DNSLookupPlugin = require('./lookup')
+const DNSLookupServicePlugin = require('./lookup_service')
+const DNSResolvePlugin = require('./resolve')
+const DNSReversePlugin = require('./reverse')
+
+// TODO: Are DNS spans really client spans?
+
+class DNSPlugin extends CompositePlugin {
+  static get name () { return 'dns' }
+  static get plugins () {
+    return {
+      lookup: DNSLookupPlugin,
+      lookup_service: DNSLookupServicePlugin,
+      resolve: DNSResolvePlugin,
+      reverse: DNSReversePlugin
     }
-    for (const tag in customTags) {
-      tags[tag] = customTags[tag]
-    }
-    const span = this.tracer.startSpan(name, {
-      childOf: store ? store.span : null,
-      tags
-    })
-    analyticsSampler.sample(span, this.config.measured)
-    return span
   }
-
-  constructor (...args) {
-    super(...args)
-
-    this.addSubs('lookup', ([hostname]) => {
-      const store = storage.getStore()
-      const span = this.startSpan('dns.lookup', {
-        'resource.name': hostname,
-        'dns.hostname': hostname
-      }, store)
-      this.enter(span, store)
-    }, (result) => {
-      const { span } = storage.getStore()
-
-      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()
-    })
-
-    this.addSubs('lookup_service', ([address, port]) => {
-      const store = storage.getStore()
-      const span = this.startSpan('dns.lookup_service', {
-        'resource.name': `${address}:${port}`,
-        'dns.address': address,
-        'dns.port': port
-      }, store)
-      this.enter(span, store)
-    })
-
-    this.addSubs('resolve', ([hostname, maybeType]) => {
-      const store = storage.getStore()
-      const rrtype = typeof maybeType === 'string' ? maybeType : 'A'
-      const span = this.startSpan('dns.resolve', {
-        'resource.name': `${rrtype} ${hostname}`,
-        'dns.hostname': hostname,
-        'dns.rrtype': rrtype
-      }, store)
-      this.enter(span, store)
-    })
-
-    this.addSubs('reverse', ([ip]) => {
-      const store = storage.getStore()
-      const span = this.startSpan('dns.reverse', { 'resource.name': ip, 'dns.ip': ip }, store)
-      this.enter(span, store)
-    })
-  }
-}
-
-function defaultFinish () {
-  storage.getStore().span.finish()
-}
-
-function errorHandler (error) {
-  storage.getStore().span.setTag('error', error)
 }
 
 module.exports = DNSPlugin

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

@@ -0,0 +1,40 @@
+'use strict'
+
+const ClientPlugin = require('../../dd-trace/src/plugins/client')
+
+class DNSLookupPlugin extends ClientPlugin {
+  static get name () { return 'dns' }
+  static get operation () { return 'lookup' }
+
+  start ([hostname]) {
+    this.startSpan('dns.lookup', {
+      service: this.config.service,
+      resource: hostname,
+      kind: 'client',
+      meta: {
+        'dns.hostname': hostname,
+        'dns.address': '',
+        'dns.addresses': ''
+      }
+    })
+  }
+
+  finish (result) {
+    const span = this.activeSpan
+
+    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()
+  }
+}
+
+module.exports = DNSLookupPlugin

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

@@ -0,0 +1,24 @@
+'use strict'
+
+const ClientPlugin = require('../../dd-trace/src/plugins/client')
+
+class DNSLookupServicePlugin extends ClientPlugin {
+  static get name () { return 'dns' }
+  static get operation () { return 'lookup_service' }
+
+  start ([address, port]) {
+    this.startSpan('dns.lookup_service', {
+      service: this.config.service,
+      resource: `${address}:${port}`,
+      kind: 'client',
+      meta: {
+        'dns.address': address
+      },
+      metrics: {
+        'dns.port': port
+      }
+    })
+  }
+}
+
+module.exports = DNSLookupServicePlugin

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

@@ -0,0 +1,24 @@
+'use strict'
+
+const ClientPlugin = require('../../dd-trace/src/plugins/client')
+
+class DNSResolvePlugin extends ClientPlugin {
+  static get name () { return 'dns' }
+  static get operation () { return 'resolve' }
+
+  start ([hostname, maybeType]) {
+    const rrtype = typeof maybeType === 'string' ? maybeType : 'A'
+
+    this.startSpan('dns.resolve', {
+      service: this.config.service,
+      resource: `${rrtype} ${hostname}`,
+      kind: 'client',
+      meta: {
+        'dns.hostname': hostname,
+        'dns.rrtype': rrtype
+      }
+    })
+  }
+}
+
+module.exports = DNSResolvePlugin

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

@@ -0,0 +1,21 @@
+'use strict'
+
+const ClientPlugin = require('../../dd-trace/src/plugins/client')
+
+class DNSReversePlugin extends ClientPlugin {
+  static get name () { return 'dns' }
+  static get operation () { return 'reverse' }
+
+  start ([ip]) {
+    this.startSpan('dns.reverse', {
+      service: this.config.service,
+      resource: ip,
+      kind: 'client',
+      meta: {
+        'dns.ip': ip
+      }
+    })
+  }
+}
+
+module.exports = DNSReversePlugin

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

@@ -1,71 +1,35 @@
 'use strict'
 
-const Plugin = require('../../dd-trace/src/plugins/plugin')
-const { storage } = require('../../datadog-core')
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-
-class ElasticsearchPlugin extends Plugin {
-  static get name () {
-    return 'elasticsearch'
-  }
-
-  constructor (...args) {
-    super(...args)
-
-    this.addSub('apm:elasticsearch:query:start', ({ params }) => {
-      const store = storage.getStore()
-      const childOf = store ? store.span : store
-      const body = getBody(params.body || params.bulkBody)
-      const span = this.tracer.startSpan('elasticsearch.query', {
-        childOf,
-        tags: {
-          '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,
-          'elasticsearch.method': params.method,
-          'elasticsearch.body': body,
-          'elasticsearch.params': JSON.stringify(params.querystring || params.query)
-        }
-      })
-      analyticsSampler.sample(span, this.config.measured)
-      this.enter(span, store)
-    })
-
-    this.addSub('apm:elasticsearch:query:error', err => {
-      const span = storage.getStore().span
-      span.setTag('error', err)
-    })
-
-    this.addSub('apm:elasticsearch:query:finish', ({ params }) => {
-      const span = storage.getStore().span
-      this.config.hooks.query(span, params)
-      span.finish()
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+
+class ElasticsearchPlugin extends DatabasePlugin {
+  static get name () { return 'elasticsearch' }
+
+  start ({ params }) {
+    const body = getBody(params.body || params.bulkBody)
+
+    this.startSpan(`${this.system}.query`, {
+      service: this.config.service,
+      resource: `${params.method} ${quantizePath(params.path)}`,
+      type: 'elasticsearch',
+      kind: 'client',
+      meta: {
+        'db.type': this.system,
+        [`${this.system}.url`]: params.path,
+        [`${this.system}.method`]: params.method,
+        [`${this.system}.body`]: body,
+        [`${this.system}.params`]: JSON.stringify(params.querystring || params.query)
+      }
     })
   }
 
-  configure (config) {
-    return super.configure(normalizeConfig(config))
+  finish ({ params }) {
+    const span = this.activeSpan
+    this.config.hooks.query(span, params)
+    super.finish({ params })
   }
 }
 
-function normalizeConfig (config) {
-  const hooks = getHooks(config)
-
-  return Object.assign({}, config, {
-    hooks
-  })
-}
-
-function getHooks (config) {
-  const noop = () => {}
-  const query = (config.hooks && config.hooks.query) || noop
-
-  return { query }
-}
-
 function getBody (body) {
   return body && JSON.stringify(body)
 }

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

@@ -0,0 +1,24 @@
+'use strict'
+
+const ClientPlugin = require('../../dd-trace/src/plugins/client')
+
+class GoogleCloudPubsubClientPlugin extends ClientPlugin {
+  static get name () { return 'google-cloud-pubsub' }
+  static get operation () { return 'request' }
+
+  start ({ cfg, projectId }) {
+    if (cfg.method === 'publish') return
+
+    this.startSpan('pubsub.request', {
+      service: this.config.service || `${this.tracer._service}-pubsub`,
+      resource: [cfg.method, cfg.reqOpts.name].filter(x => x).join(' '),
+      kind: 'client',
+      meta: {
+        'pubsub.method': cfg.method,
+        'gcloud.project_id': projectId
+      }
+    })
+  }
+}
+
+module.exports = GoogleCloudPubsubClientPlugin

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

@@ -0,0 +1,41 @@
+'use strict'
+
+const ConsumerPlugin = require('../../dd-trace/src/plugins/consumer')
+
+class GoogleCloudPubsubConsumerPlugin extends ConsumerPlugin {
+  static get name () { return 'google-cloud-pubsub' }
+  static get operation () { return 'receive' }
+
+  start ({ message }) {
+    const subscription = message._subscriber._subscription
+    const topic = subscription.metadata && subscription.metadata.topic
+    const childOf = this.tracer.extract('text_map', message.attributes) || null
+
+    this.startSpan('pubsub.receive', {
+      childOf,
+      service: this.config.service,
+      resource: topic,
+      kind: 'consumer',
+      type: 'worker',
+      meta: {
+        'gcloud.project_id': subscription.pubsub.projectId,
+        'pubsub.topic': topic
+      },
+      metrics: {
+        'pubsub.ack': 0
+      }
+    })
+  }
+
+  finish (message) {
+    const span = this.activeSpan
+
+    if (message.message._handled) {
+      span.setTag('pubsub.ack', 1)
+    }
+
+    span.finish()
+  }
+}
+
+module.exports = GoogleCloudPubsubConsumerPlugin