dd-trace 2.2.1 → 2.4.0

package/packages/datadog-instrumentations/src/tedious.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+addHook({ name: 'tedious', versions: [ '>=1.0.0' ] }, tedious => {
+  const startCh = channel('apm:tedious:request:start')
+  const asyncEndCh = channel('apm:tedious:request:async-end')
+  const endCh = channel('apm:tedious:request:end')
+  const errorCh = channel('apm:tedious:request:error')
+  shimmer.wrap(tedious.Connection.prototype, 'makeRequest', makeRequest => function (request) {
+    if (!startCh.hasSubscribers) {
+      return request.apply(this, arguments)
+    }
+
+    const queryOrProcedure = getQueryOrProcedure(request)
+
+    if (!queryOrProcedure) {
+      return makeRequest.apply(this, arguments)
+    }
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+    const connectionConfig = this.config
+
+    startCh.publish({ queryOrProcedure, connectionConfig })
+
+    const cb = asyncResource.bind(request.callback, request)
+    request.callback = AsyncResource.bind(function (error) {
+      if (error) {
+        errorCh.publish(error)
+      }
+      asyncEndCh.publish(undefined)
+
+      return cb.apply(this, arguments)
+    }, null, request)
+
+    try {
+      return makeRequest.apply(this, arguments)
+    } catch (error) {
+      errorCh.publish(error)
+
+      throw error
+    } finally {
+      endCh.publish(undefined)
+    }
+  })
+
+  return tedious
+})
+
+function getQueryOrProcedure (request) {
+  if (!request.parameters) return
+
+  const statement = request.parametersByName.statement || request.parametersByName.stmt
+
+  if (!statement) {
+    return request.sqlTextOrProcedure
+  }
+
+  return statement.value
+}

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

@@ -1,120 +1,100 @@
 'use strict'
 
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
-function createWrapSend (tracer, config) {
-  return function wrapSend (send) {
-    return function sendWithTrace (msg, options) {
-      const span = startSendSpan(tracer, config, this)
-
-      try {
-        const promise = tracer.scope().activate(span, () => {
-          return send.apply(this, arguments)
-        })
-
-        return wrapPromise(promise, span)
-      } catch (e) {
-        finish(span, e)
-        throw e
-      }
-    }
+class Amqp10Plugin extends Plugin {
+  static get name () {
+    return 'amqp10'
   }
-}
-
-function createWrapMessageReceived (tracer, config) {
-  return function wrapMessageReceived (messageReceived) {
-    return function messageReceivedWithTrace (transferFrame) {
-      if (!transferFrame || transferFrame.aborted || transferFrame.more) {
-        return messageReceived.apply(this, arguments)
-      }
 
-      const span = startReceiveSpan(tracer, config, this)
-
-      return tracer.scope().activate(span, () => {
-        messageReceived.apply(this, arguments)
-        span.finish()
+  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
+        }
       })
-    }
-  }
-}
-
-function startSendSpan (tracer, config, link) {
-  const address = getAddress(link)
-  const target = getShortName(link)
-
-  const span = tracer.startSpan(`amqp.send`, {
-    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
-    }
-  })
 
-  addTags(tracer, config, span, link)
+      analyticsSampler.sample(span, this.config.measured)
 
-  analyticsSampler.sample(span, config.measured)
-
-  return span
-}
-
-function startReceiveSpan (tracer, config, link) {
-  const source = getShortName(link)
-  const span = tracer.startSpan(`amqp.receive`, {
-    tags: {
-      'resource.name': ['receive', source].filter(v => v).join(' '),
-      'span.kind': 'consumer',
-      'span.type': 'worker',
-      'amqp.link.source.address': source,
-      'amqp.link.role': 'receiver'
-    }
-  })
-
-  addTags(tracer, config, span, link)
+      this.enter(span, store)
+    })
 
-  analyticsSampler.sample(span, config.measured, true)
+    this.addSub(`apm:amqp10:send:end`, () => {
+      this.exit()
+    })
 
-  return span
-}
+    this.addSub(`apm:amqp10:send:error`, err => {
+      const span = storage.getStore().span
+      span.setTag('error', err)
+    })
 
-function addTags (tracer, config, span, link = {}) {
-  const address = getAddress(link)
+    this.addSub(`apm:amqp10:send:async-end`, () => {
+      const span = storage.getStore().span
+      span.finish()
+    })
 
-  span.addTags({
-    'service.name': config.service || `${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
-  })
+    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
+        }
+      })
 
-  return span
-}
+      analyticsSampler.sample(span, this.config.measured)
 
-function finish (span, error) {
-  if (error) {
-    span.addTags({
-      'error.type': error.name,
-      'error.msg': error.message,
-      'error.stack': error.stack
+      this.enter(span, store)
     })
-  }
 
-  span.finish()
-}
+    this.addSub(`apm:amqp10:receive:end`, () => {
+      storage.getStore().span.finish()
+      this.exit()
+    })
 
-function wrapPromise (promise, span) {
-  if (!promise) {
-    finish(span)
-    return promise
+    this.addSub(`apm:amqp10:receive:error`, err => {
+      const span = storage.getStore().span
+      span.setTag('error', err)
+    })
   }
-
-  promise.then(() => finish(span), e => finish(span, e))
-
-  return promise
 }
 
 function getShortName (link) {
@@ -129,27 +109,4 @@ function getAddress (link) {
   return link.session.connection.address || {}
 }
 
-module.exports = [
-  {
-    name: 'amqp10',
-    file: 'lib/sender_link.js',
-    versions: ['>=3'],
-    patch (SenderLink, tracer, config) {
-      this.wrap(SenderLink.prototype, 'send', createWrapSend(tracer, config))
-    },
-    unpatch (SenderLink) {
-      this.unwrap(SenderLink.prototype, 'send')
-    }
-  },
-  {
-    name: 'amqp10',
-    file: 'lib/receiver_link.js',
-    versions: ['>=3'],
-    patch (ReceiverLink, tracer, config) {
-      this.wrap(ReceiverLink.prototype, '_messageReceived', createWrapMessageReceived(tracer, config))
-    },
-    unpatch (ReceiverLink) {
-      this.unwrap(ReceiverLink.prototype, '_messageReceived')
-    }
-  }
-]
+module.exports = Amqp10Plugin

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

@@ -1,74 +1,92 @@
 'use strict'
 
-const kebabCase = require('lodash.kebabcase')
+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')
 
-let methods = {}
-
-function createWrapSendImmediately (tracer, config) {
-  return function wrapSendImmediately (sendImmediately) {
-    return function sendImmediatelyWithTrace (method, fields) {
-      return sendWithTrace(sendImmediately, this, arguments, tracer, config, methods[method], fields)
-    }
+class AmqplibPlugin extends Plugin {
+  static get name () {
+    return 'amqplib'
   }
-}
-
-function createWrapSendMessage (tracer, config) {
-  return function wrapSendMessage (sendMessage) {
-    return function sendMessageWithTrace (fields) {
-      return sendWithTrace(sendMessage, this, arguments, tracer, config, 'basic.publish', fields)
-    }
-  }
-}
 
-function createWrapDispatchMessage (tracer, config) {
-  return function wrapDispatchMessage (dispatchMessage) {
-    return function dispatchMessageWithTrace (fields, message) {
-      const childOf = extract(tracer, message)
-      const span = tracer.startSpan('amqp.command', { childOf })
-
-      addTags(this, tracer, config, span, 'basic.deliver', fields)
-
-      analyticsSampler.sample(span, config.measured, true)
-
-      tracer.scope().activate(span, () => {
-        try {
-          dispatchMessage.apply(this, arguments)
-        } catch (e) {
-          throw addError(span, e)
-        } finally {
-          span.finish()
+  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)
         }
       })
-    }
-  }
-}
-
-function sendWithTrace (send, channel, args, tracer, config, method, fields) {
-  const childOf = tracer.scope().active()
-  const span = tracer.startSpan('amqp.command', { childOf })
-
-  fields.headers = fields.headers || {}
-
-  addTags(channel, tracer, config, span, method, fields)
-  tracer.inject(span, TEXT_MAP, fields.headers)
 
-  analyticsSampler.sample(span, config.measured)
+      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)
+    })
 
-  return tracer.scope().activate(span, () => {
-    try {
-      return send.apply(channel, args)
-    } catch (e) {
-      throw addError(span, e)
-    } finally {
+    this.addSub(`apm:amqplib:command:end`, () => {
+      const span = storage.getStore().span
       span.finish()
-    }
-  })
-}
+      this.exit()
+    })
 
-function isCamelCase (str) {
-  return /([A-Z][a-z0-9]+)+/.test(str)
+    this.addSub(`apm:amqplib:command:error`, err => {
+      const span = storage.getStore().span
+      span.setTag('error', err)
+    })
+  }
 }
 
 function getResourceName (method, fields = {}) {
@@ -82,93 +100,10 @@ function getResourceName (method, fields = {}) {
   ].filter(val => val).join(' ')
 }
 
-function addError (span, error) {
-  span.addTags({
-    'error.type': error.name,
-    'error.msg': error.message,
-    'error.stack': error.stack
-  })
-
-  return error
-}
-
-function addTags (channel, tracer, config, span, method, fields) {
-  const fieldNames = [
-    'queue',
-    'exchange',
-    'routingKey',
-    'consumerTag',
-    'source',
-    'destination'
-  ]
-
-  span.addTags({
-    'service.name': config.service || `${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
-    })
-  }
-
-  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])
-  })
-}
-
 function extract (tracer, message) {
   return message
     ? tracer.extract(TEXT_MAP, message.properties.headers)
     : null
 }
 
-module.exports = [
-  {
-    name: 'amqplib',
-    file: 'lib/defs.js',
-    versions: ['>=0.5'],
-    patch (defs, tracer, config) {
-      methods = Object.keys(defs)
-        .filter(key => Number.isInteger(defs[key]))
-        .filter(key => isCamelCase(key))
-        .reduce((acc, key) => Object.assign(acc, { [defs[key]]: kebabCase(key).replace('-', '.') }), {})
-    },
-    unpatch (defs) {
-      methods = {}
-    }
-  },
-  {
-    name: 'amqplib',
-    file: 'lib/channel.js',
-    versions: ['>=0.5'],
-    patch (channel, tracer, config) {
-      this.wrap(channel.Channel.prototype, 'sendImmediately', createWrapSendImmediately(tracer, config))
-      this.wrap(channel.Channel.prototype, 'sendMessage', createWrapSendMessage(tracer, config))
-      this.wrap(channel.BaseChannel.prototype, 'dispatchMessage', createWrapDispatchMessage(tracer, config))
-    },
-    unpatch (channel) {
-      this.unwrap(channel.Channel.prototype, 'sendImmediately')
-      this.unwrap(channel.Channel.prototype, 'sendMessage')
-      this.unwrap(channel.BaseChannel.prototype, 'dispatchMessage')
-    }
-  }
-]
+module.exports = AmqplibPlugin

package/packages/datadog-plugin-aws-sdk/src/services/sns.js

@@ -38,8 +38,8 @@ class Sns {
       const ddInfo = {}
       tracer.inject(span, 'text_map', ddInfo)
       injectPath.MessageAttributes._datadog = {
-        DataType: 'String',
-        StringValue: JSON.stringify(ddInfo)
+        DataType: 'Binary',
+        BinaryValue: JSON.stringify(ddInfo) // BINARY types are automatically base64 encoded
       }
     }
   }