dd-trace 3.4.0 → 3.6.0

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

@@ -1,107 +1,17 @@
 'use strict'
 
-const Plugin = require('../../dd-trace/src/plugins/plugin')
-const { storage } = require('../../datadog-core')
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-
-class Amqp10Plugin extends Plugin {
-  static get name () {
-    return 'amqp10'
+const ProducerPlugin = require('./producer')
+const ConsumerPlugin = require('./consumer')
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+
+class Amqp10Plugin extends CompositePlugin {
+  static get name () { return 'amqp10' }
+  static get plugins () {
+    return {
+      producer: ProducerPlugin,
+      consumer: ConsumerPlugin
+    }
   }
-
-  constructor (...args) {
-    super(...args)
-
-    this.addSub(`apm:amqp10:send:start`, ({ link }) => {
-      const address = getAddress(link)
-      const target = getShortName(link)
-
-      const store = storage.getStore()
-      const childOf = store ? store.span : store
-
-      const span = this.tracer.startSpan('amqp.send', {
-        childOf,
-        tags: {
-          'resource.name': ['send', target].filter(v => v).join(' '),
-          'span.kind': 'producer',
-          'amqp.link.target.address': target,
-          'amqp.link.role': 'sender',
-          'out.host': address.host,
-          'out.port': address.port,
-          'service.name': this.config.service || `${this.tracer._service}-amqp`,
-          'amqp.link.name': link.name,
-          'amqp.link.handle': link.handle,
-          'amqp.connection.host': address.host,
-          'amqp.connection.port': address.port,
-          'amqp.connection.user': address.user
-        }
-      })
-
-      analyticsSampler.sample(span, this.config.measured)
-
-      this.enter(span, store)
-    })
-
-    this.addSub(`apm:amqp10:send:error`, err => {
-      const span = storage.getStore().span
-      span.setTag('error', err)
-    })
-
-    this.addSub(`apm:amqp10:send:finish`, () => {
-      const span = storage.getStore().span
-      span.finish()
-    })
-
-    this.addSub(`apm:amqp10:receive:start`, ({ link }) => {
-      const source = getShortName(link)
-      const address = getAddress(link)
-
-      const store = storage.getStore()
-      const childOf = store ? store.span : store
-
-      const span = this.tracer.startSpan('amqp.receive', {
-        childOf,
-        tags: {
-          'resource.name': ['receive', source].filter(v => v).join(' '),
-          'span.kind': 'consumer',
-          'span.type': 'worker',
-          'amqp.link.source.address': source,
-          'amqp.link.role': 'receiver',
-          'service.name': this.config.service || `${this.tracer._service}-amqp`,
-          'amqp.link.name': link.name,
-          'amqp.link.handle': link.handle,
-          'amqp.connection.host': address.host,
-          'amqp.connection.port': address.port,
-          'amqp.connection.user': address.user
-        }
-      })
-
-      analyticsSampler.sample(span, this.config.measured)
-
-      this.enter(span, store)
-    })
-
-    this.addSub(`apm:amqp10:receive:finish`, () => {
-      storage.getStore().span.finish()
-    })
-
-    this.addSub(`apm:amqp10:receive:error`, err => {
-      const span = storage.getStore().span
-      span.setTag('error', err)
-    })
-  }
-}
-
-function getShortName (link) {
-  if (!link || !link.name) return null
-
-  return link.name.split('_').slice(0, -1).join('_')
-}
-
-function getAddress (link) {
-  if (!link || !link.session || !link.session.connection) return {}
-
-  return link.session.connection.address || {}
 }
 
 module.exports = Amqp10Plugin

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

@@ -0,0 +1,34 @@
+'use strict'
+
+const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
+const { getAddress, getShortName } = require('./util')
+
+class Amqp10ProducerPlugin extends ProducerPlugin {
+  static get name () { return 'amqp10' }
+  static get operation () { return 'send' }
+  static get system () { return 'amqp' }
+
+  start ({ link }) {
+    const address = getAddress(link)
+    const target = getShortName(link)
+
+    this.startSpan('amqp.send', {
+      service: this.config.service || `${this.tracer._service}-amqp`,
+      resource: ['send', target].filter(v => v).join(' '),
+      kind: 'producer',
+      meta: {
+        'amqp.link.target.address': target,
+        'amqp.link.role': 'sender',
+        'out.host': address.host,
+        'out.port': address.port,
+        'amqp.link.name': link.name,
+        'amqp.link.handle': link.handle,
+        'amqp.connection.host': address.host,
+        'amqp.connection.port': address.port,
+        'amqp.connection.user': address.user
+      }
+    })
+  }
+}
+
+module.exports = Amqp10ProducerPlugin

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

@@ -0,0 +1,15 @@
+'use strict'
+
+function getAddress (link) {
+  if (!link || !link.session || !link.session.connection) return {}
+
+  return link.session.connection.address || {}
+}
+
+function getShortName (link) {
+  if (!link || !link.name) return null
+
+  return link.name.split('_').slice(0, -1).join('_')
+}
+
+module.exports = { getAddress, getShortName }

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

@@ -0,0 +1,38 @@
+'use strict'
+
+const { TEXT_MAP } = require('../../../ext/formats')
+const ClientPlugin = require('../../dd-trace/src/plugins/client')
+const { getResourceName } = require('./util')
+
+class AmqplibClientPlugin extends ClientPlugin {
+  static get name () { return 'amqplib' }
+  static get operation () { return 'command' }
+
+  start ({ channel = {}, method, fields }) {
+    if (method === 'basic.deliver' || method === 'basic.get') return
+    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: 'client',
+      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 = AmqplibClientPlugin

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

@@ -0,0 +1,40 @@
+'use strict'
+
+const { TEXT_MAP } = require('../../../ext/formats')
+const ConsumerPlugin = require('../../dd-trace/src/plugins/consumer')
+const { getResourceName } = require('./util')
+
+class AmqplibConsumerPlugin extends ConsumerPlugin {
+  static get name () { return 'amqplib' }
+  static get operation () { return 'command' }
+
+  start ({ method, fields, message }) {
+    if (method !== 'basic.deliver' && method !== 'basic.get') return
+
+    const childOf = extract(this.tracer, message)
+
+    this.startSpan('amqp.command', {
+      childOf,
+      service: this.config.service || `${this.tracer._service}-amqp`,
+      resource: getResourceName(method, fields),
+      kind: 'consumer',
+      type: 'worker',
+      meta: {
+        'amqp.queue': fields.queue,
+        'amqp.exchange': fields.exchange,
+        'amqp.routingKey': fields.routingKey,
+        'amqp.consumerTag': fields.consumerTag,
+        'amqp.source': fields.source,
+        'amqp.destination': fields.destination
+      }
+    })
+  }
+}
+
+function extract (tracer, message) {
+  return message
+    ? tracer.extract(TEXT_MAP, message.properties.headers)
+    : null
+}
+
+module.exports = AmqplibConsumerPlugin

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

@@ -1,108 +1,20 @@
 'use strict'
 
-const Plugin = require('../../dd-trace/src/plugins/plugin')
-const { storage } = require('../../datadog-core')
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-const { TEXT_MAP } = require('../../../ext/formats')
-
-class AmqplibPlugin extends Plugin {
-  static get name () {
-    return 'amqplib'
-  }
-
-  constructor (...args) {
-    super(...args)
-
-    this.addSub(`apm:amqplib:command:start`, ({ channel, method, fields, message }) => {
-      const store = storage.getStore()
-      let childOf
-
-      if (method === 'basic.deliver') {
-        childOf = extract(this.tracer, message)
-      } else {
-        fields.headers = fields.headers || {}
-        childOf = store ? store.span : store
-      }
-
-      const span = this.tracer.startSpan('amqp.command', {
-        childOf,
-        tags: {
-          'service.name': this.config.service || `${this.tracer._service}-amqp`,
-          'resource.name': getResourceName(method, fields)
-        }
-      })
-
-      if (channel && channel.connection && channel.connection.stream) {
-        span.addTags({
-          'out.host': channel.connection.stream._host,
-          'out.port': channel.connection.stream.remotePort
-        })
-      }
-      const fieldNames = [
-        'queue',
-        'exchange',
-        'routingKey',
-        'consumerTag',
-        'source',
-        'destination'
-      ]
-
-      switch (method) {
-        case 'basic.publish':
-          span.setTag('span.kind', 'producer')
-          break
-        case 'basic.consume':
-        case 'basic.get':
-        case 'basic.deliver':
-          span.addTags({
-            'span.kind': 'consumer',
-            'span.type': 'worker'
-          })
-          break
-        default:
-          span.setTag('span.kind', 'client')
-      }
-
-      fieldNames.forEach(field => {
-        fields[field] !== undefined && span.setTag(`amqp.${field}`, fields[field])
-      })
-      if (method === 'basic.deliver') {
-        analyticsSampler.sample(span, this.config.measured, true)
-      } else {
-        this.tracer.inject(span, TEXT_MAP, fields.headers)
-        analyticsSampler.sample(span, this.config.measured)
-      }
-
-      this.enter(span, store)
-    })
-
-    this.addSub(`apm:amqplib:command:finish`, () => {
-      const span = storage.getStore().span
-      span.finish()
-    })
-
-    this.addSub(`apm:amqplib:command:error`, err => {
-      const span = storage.getStore().span
-      span.setTag('error', err)
-    })
+const ProducerPlugin = require('./producer')
+const ConsumerPlugin = require('./consumer')
+const ClientPlugin = require('./client')
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+
+// TODO: Consider splitting channels for publish/receive in the instrumentation.
+class AmqplibPlugin extends CompositePlugin {
+  static get name () { return 'amqplib' }
+  static get plugins () {
+    return {
+      producer: ProducerPlugin,
+      consumer: ConsumerPlugin,
+      client: ClientPlugin
+    }
   }
 }
 
-function getResourceName (method, fields = {}) {
-  return [
-    method,
-    fields.exchange,
-    fields.routingKey,
-    fields.queue,
-    fields.source,
-    fields.destination
-  ].filter(val => val).join(' ')
-}
-
-function extract (tracer, message) {
-  return message
-    ? tracer.extract(TEXT_MAP, message.properties.headers)
-    : null
-}
-
 module.exports = AmqplibPlugin

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-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

@@ -8,23 +8,23 @@ class ElasticsearchPlugin extends DatabasePlugin {
   start ({ params }) {
     const body = getBody(params.body || params.bulkBody)
 
-    this.startSpan('elasticsearch.query', {
+    this.startSpan(`${this.system}.query`, {
       service: this.config.service,
       resource: `${params.method} ${quantizePath(params.path)}`,
       type: 'elasticsearch',
       kind: 'client',
       meta: {
-        'db.type': 'elasticsearch',
-        'elasticsearch.url': params.path,
-        'elasticsearch.method': params.method,
-        'elasticsearch.body': body,
-        'elasticsearch.params': JSON.stringify(params.querystring || params.query)
+        '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)
       }
     })
   }
 
   finish ({ params }) {
-    const span = this.activeSpan()
+    const span = this.activeSpan
     this.config.hooks.query(span, params)
     super.finish({ params })
   }