dd-trace 2.3.0 → 2.4.1

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

@@ -1,201 +1,79 @@
 'use strict'
 
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
-const dd = Symbol('datadog')
-const circularBufferConstructor = Symbol('circularBufferConstructor')
-const inFlightDeliveries = Symbol('inFlightDeliveries')
+class RheaPlugin extends Plugin {
+  static get name () {
+    return 'rhea'
+  }
 
-const patched = new WeakSet()
+  constructor (...args) {
+    super(...args)
 
-function createWrapSend (tracer, config, instrumenter) {
-  return function wrapSend (send) {
-    return function sendWithTrace (msg, tag, format) {
-      if (!canTrace(this)) {
-        // we can't handle disconnects or ending spans, so we can't safely instrument
-        return send.apply(this, arguments)
-      }
-      const name = getResourceNameFromSender(this)
-      const { host, port } = getHostAndPort(this.connection)
-      return tracer.trace('amqp.send', {
+    this.addSub(`apm:rhea:send:start`, ({ targetAddress, host, port, msg }) => {
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
+      const name = targetAddress || 'amq.topic'
+      const span = this.tracer.startSpan('amqp.send', {
+        childOf,
         tags: {
           'component': 'rhea',
           'resource.name': name,
-          'service.name': config.service || `${tracer._service}-amqp-producer`,
+          'service.name': this.config.service || `${this.tracer._service}-amqp-producer`,
           'span.kind': 'producer',
           'amqp.link.target.address': name,
           'amqp.link.role': 'sender',
           'out.host': host,
           'out.port': port
         }
-      }, (span, done) => {
-        analyticsSampler.sample(span, config.measured)
-        addDeliveryAnnotations(msg, tracer, span)
-        const delivery = send.apply(this, arguments)
-        delivery[dd] = { done, span }
-        addToInFlightDeliveries(this.connection, delivery)
-        return delivery
       })
-    }
-  }
-}
-
-function createWrapConnectionDispatch (tracer, config) {
-  return function wrapDispatch (dispatch) {
-    return function dispatchWithTrace (eventName, obj) {
-      if (eventName === 'disconnected') {
-        const error = obj.error || this.saved_error
-        if (this[inFlightDeliveries]) {
-          this[inFlightDeliveries].forEach(delivery => {
-            const { span } = delivery[dd]
-            span.addTags({ error })
-            finish(delivery, null)
-          })
-        }
-      }
-      return dispatch.apply(this, arguments)
-    }
-  }
-}
+      analyticsSampler.sample(span, this.config.measured)
+      addDeliveryAnnotations(msg, this.tracer, span)
 
-function createWrapReceiverDispatch (tracer, config, instrumenter) {
-  return function wrapDispatch (dispatch) {
-    return function dispatchWithTrace (eventName, msgObj) {
-      if (!canTrace(this)) {
-        // we can't handle disconnects or ending spans, so we can't safely instrument
-        return dispatch.apply(this, arguments)
-      }
-      if (eventName === 'message' && msgObj) {
-        const name = getResourceNameFromMessage(msgObj)
-        const childOf = getAnnotations(msgObj, tracer)
-        return tracer.trace('amqp.receive', {
-          type: 'worker',
-          tags: {
-            'component': 'rhea',
-            'resource.name': name,
-            'service.name': config.service || tracer._service,
-            'span.kind': 'consumer',
-            'amqp.link.source.address': name,
-            'amqp.link.role': 'receiver'
-          },
-          childOf
-        }, (span, done) => {
-          analyticsSampler.sample(span, config.measured, true)
-          if (msgObj.delivery) {
-            msgObj.delivery[dd] = { done, span }
-            msgObj.delivery.update = wrapDeliveryUpdate(msgObj.delivery.update)
-            addToInFlightDeliveries(this.connection, msgObj.delivery)
-          }
-          return dispatch.apply(this, arguments)
-        })
-      }
+      this.enter(span, store)
+    })
 
-      return dispatch.apply(this, arguments)
-    }
-  }
-}
+    this.addSub(`apm:rhea:receive:start`, ({ msgObj, connection }) => {
+      const name = getResourceNameFromMessage(msgObj)
 
-function createWrapCircularBufferPopIf () {
-  return function wrapCircularBufferPopIf (popIf) {
-    return function wrappedPopIf (fn) {
-      arguments[0] = entry => {
-        const shouldPop = fn(entry)
-        if (shouldPop && entry[dd]) {
-          const remoteState = entry.remote_state
-          const state = remoteState && remoteState.constructor
-            ? entry.remote_state.constructor.composite_type : undefined
-          finish(entry, state)
-        }
-        return shouldPop
-      }
-      return popIf.apply(this, arguments)
-    }
-  }
-}
-
-function wrapDeliveryUpdate (update) {
-  return function wrappedUpdate (settled, stateData) {
-    if (this[dd]) {
-      const state = getStateFromData(stateData)
-      this[dd].span.setTag('amqp.delivery.state', state)
-    }
-    return update.apply(this, arguments)
-  }
-}
-
-function patchCircularBuffer (proto, instrumenter) {
-  Object.defineProperty(proto, 'outgoing', {
-    configurable: true,
-    get () {},
-    set (outgoing) {
-      delete proto.outgoing // removes the setter on the prototype
-      this.outgoing = outgoing // assigns on the instance, like normal
-      if (outgoing) {
-        let CircularBuffer
-        if (outgoing.deliveries) {
-          CircularBuffer = outgoing.deliveries.constructor
-        }
-        if (CircularBuffer && !patched.has(CircularBuffer.prototype)) {
-          instrumenter.wrap(CircularBuffer.prototype, 'pop_if', createWrapCircularBufferPopIf())
-          patched.add(CircularBuffer.prototype)
-          const Session = proto.constructor
-          if (Session) {
-            Session[circularBufferConstructor] = CircularBuffer
-          }
+      const store = storage.getStore()
+      const childOf = extractTextMap(msgObj, this.tracer)
+      const span = this.tracer.startSpan('amqp.receive', {
+        childOf,
+        tags: {
+          'span.type': 'worker',
+          'component': 'rhea',
+          'resource.name': name,
+          'service.name': this.config.service || this.tracer._service,
+          'span.kind': 'consumer',
+          'amqp.link.source.address': name,
+          'amqp.link.role': 'receiver'
         }
-      }
-    }
-  })
-}
+      })
+      analyticsSampler.sample(span, this.config.measured, true)
 
-function addToInFlightDeliveries (connection, delivery) {
-  let deliveries = connection[inFlightDeliveries]
-  if (!deliveries) {
-    deliveries = new Set()
-    connection[inFlightDeliveries] = deliveries
-  }
-  deliveries.add(delivery)
-  delivery[dd].connection = connection
-}
+      this.enter(span, store)
+    })
 
-function getHostAndPort (connection) {
-  let host
-  let port
-  if (connection && connection.options) {
-    host = connection.options.host
-    port = connection.options.port
-  }
-  return { host, port }
-}
+    this.addSub(`apm:rhea:error`, error => {
+      storage.getStore().span.setTag('error', error)
+    })
 
-function addDeliveryAnnotations (msg, tracer, span) {
-  if (msg) {
-    msg.delivery_annotations = msg.delivery_annotations || {}
-    tracer.inject(span, 'text_map', msg.delivery_annotations)
-  }
-}
+    this.addSub(`apm:rhea:async-end`, () => {
+      const span = storage.getStore().span
+      span.finish()
+    })
 
-function getStateFromData (stateData) {
-  if (stateData && stateData.descriptor && stateData.descriptor) {
-    switch (stateData.descriptor.value) {
-      case 0x24: return 'accepted'
-      case 0x25: return 'rejected'
-      case 0x26: return 'released'
-      case 0x27: return 'modified'
-    }
-  }
-}
+    this.addSub(`apm:rhea:end`, () => {
+      this.exit()
+    })
 
-function finish (delivery, state) {
-  if (delivery[dd]) {
-    if (state) {
-      delivery[dd].span.setTag('amqp.delivery.state', state)
-    }
-    delivery[dd].done()
-    if (delivery[dd].connection && delivery[dd].connection[inFlightDeliveries]) {
-      delivery[dd].connection[inFlightDeliveries].delete(delivery)
-    }
-    delete delivery[dd]
+    this.addSub(`apm:rhea:dispatch`, ({ state }) => {
+      const span = storage.getStore().span
+      span.setTag('amqp.delivery.state', state)
+    })
   }
 }
 
@@ -211,62 +89,18 @@ function getResourceNameFromMessage (msgObj) {
   return resourceName
 }
 
-function getResourceNameFromSender (sender) {
-  let resourceName = 'amq.topic'
-  if (sender.options && sender.options.target && sender.options.target.address) {
-    resourceName = sender.options.target.address
-  }
-  return resourceName
-}
-
-function getAnnotations (msgObj, tracer) {
+function extractTextMap (msgObj, tracer) {
   if (msgObj.message) {
     return tracer.extract('text_map', msgObj.message.delivery_annotations)
   }
 }
 
-function canTrace (link) {
-  return link.connection && link.session && link.session.outgoing
-}
+function addDeliveryAnnotations (msg, tracer, span) {
+  if (msg) {
+    msg.delivery_annotations = msg.delivery_annotations || {}
 
-module.exports = [
-  {
-    name: 'rhea',
-    versions: ['>=1'],
-    file: 'lib/link.js',
-    patch ({ Sender, Receiver }, tracer, config) {
-      this.wrap(Sender.prototype, 'send', createWrapSend(tracer, config, this))
-      this.wrap(Receiver.prototype, 'dispatch', createWrapReceiverDispatch(tracer, config, this))
-    },
-    unpatch ({ Sender, Receiver }, tracer) {
-      this.unwrap(Sender.prototype, 'send')
-      this.unwrap(Receiver.prototype, 'dispatch')
-    }
-  },
-  {
-    name: 'rhea',
-    versions: ['>=1'],
-    file: 'lib/connection.js',
-    patch (Connection, tracer, config) {
-      this.wrap(Connection.prototype, 'dispatch', createWrapConnectionDispatch(tracer, config))
-    },
-    unpatch (Connection, tracer) {
-      this.unwrap(Connection.prototype, 'dispatch')
-    }
-  },
-  {
-    name: 'rhea',
-    versions: ['>=1'],
-    file: 'lib/session.js',
-    patch (Session, tracer, config) {
-      patchCircularBuffer(Session.prototype, this)
-    },
-    unpatch (Session, tracer) {
-      const CircularBuffer = Session[circularBufferConstructor]
-      if (CircularBuffer) {
-        patched.delete(CircularBuffer.prototype)
-        this.unwrap(CircularBuffer.prototype, 'pop_if')
-      }
-    }
+    tracer.inject(span, 'text_map', msg.delivery_annotations)
   }
-]
+}
+
+module.exports = RheaPlugin

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

@@ -1,102 +1,54 @@
 'use strict'
 
-const Tags = require('../../../ext/tags')
-const Kinds = require('../../../ext/kinds')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-const tx = require('../../dd-trace/src/plugins/util/tx')
 
-function createWrapMakeRequest (tracer, config) {
-  return function wrapMakeRequest (makeRequest) {
-    return function makeRequestWithTrace (request) {
-      const connectionConfig = this.config
-      const scope = tracer.scope()
-      const childOf = scope.active()
-      const queryOrProcedure = getQueryOrProcedure(request)
+class TediousPlugin extends Plugin {
+  static get name () {
+    return 'tedious'
+  }
 
-      if (!queryOrProcedure) {
-        return makeRequest.apply(this, arguments)
-      }
+  constructor (...args) {
+    super(...args)
 
-      const span = tracer.startSpan('tedious.request', {
+    this.addSub(`apm:tedious:request:start`, ({ queryOrProcedure, connectionConfig }) => {
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
+      const span = this.tracer.startSpan('tedious.request', {
         childOf,
         tags: {
-          [Tags.SPAN_KIND]: Kinds.CLIENT,
+          'span.kind': 'client',
           'db.type': 'mssql',
           'span.type': 'sql',
           'component': 'tedious',
-          'service.name': config.service || `${tracer._service}-mssql`,
-          'resource.name': queryOrProcedure
+          'service.name': this.config.service || `${this.tracer._service}-mssql`,
+          'resource.name': queryOrProcedure,
+          'out.host': connectionConfig.server,
+          'out.port': connectionConfig.options.port,
+          'db.user': connectionConfig.userName || connectionConfig.authentication.options.userName,
+          'db.name': connectionConfig.options.database,
+          'db.instance': connectionConfig.options.instanceName
         }
       })
-
-      addConnectionTags(span, connectionConfig)
-      addDatabaseTags(span, connectionConfig)
-
-      analyticsSampler.sample(span, config.measured)
-      request.callback = tx.wrap(span, request.callback)
-
-      return scope.bind(makeRequest, span).apply(this, arguments)
-    }
-  }
-}
-
-function createWrapGetRowStream (tracer) {
-  return function wrapGetRowStream (getRowStream) {
-    return function getRowStreamWithTrace () {
-      const scope = tracer.scope()
-
-      const rowToPacketTransform = getRowStream.apply(this, arguments)
-      return scope.bind(rowToPacketTransform)
-    }
+      analyticsSampler.sample(span, this.config.measured)
+      this.enter(span, store)
+    })
+
+    this.addSub(`apm:tedious:request:end`, () => {
+      this.exit()
+    })
+
+    this.addSub(`apm:tedious:request:error`, err => {
+      const span = storage.getStore().span
+      span.setTag('error', err)
+    })
+
+    this.addSub(`apm:tedious:request:async-end`, () => {
+      const span = storage.getStore().span
+      span.finish()
+    })
   }
 }
 
-function getQueryOrProcedure (request) {
-  if (!request.parameters) return
-
-  const statement = request.parametersByName.statement || request.parametersByName.stmt
-
-  if (!statement) {
-    return request.sqlTextOrProcedure
-  }
-
-  return statement.value
-}
-
-function addConnectionTags (span, connectionConfig) {
-  span.setTag('out.host', connectionConfig.server)
-  span.setTag('out.port', connectionConfig.options.port)
-}
-
-function addDatabaseTags (span, connectionConfig) {
-  span.setTag('db.user', connectionConfig.userName || connectionConfig.authentication.options.userName)
-  span.setTag('db.name', connectionConfig.options.database)
-  span.setTag('db.instance', connectionConfig.options.instanceName)
-}
-
-module.exports = [
-  {
-    name: 'tedious',
-    versions: [ '>=1.0.0' ],
-    patch (tedious, tracer, config) {
-      this.wrap(tedious.Connection.prototype, 'makeRequest', createWrapMakeRequest(tracer, config))
-
-      if (tedious.BulkLoad && tedious.BulkLoad.prototype.getRowStream) {
-        this.wrap(tedious.BulkLoad.prototype, 'getRowStream', createWrapGetRowStream(tracer))
-      }
-
-      tracer.scope().bind(tedious.Request.prototype)
-      tracer.scope().bind(tedious.Connection.prototype)
-    },
-    unpatch (tedious, tracer) {
-      this.unwrap(tedious.Connection.prototype, 'makeRequest')
-
-      if (tedious.BulkLoad) {
-        this.unwrap(tedious.BulkLoad.prototype, 'getRowStream')
-      }
-
-      tracer.scope().unbind(tedious.Request.prototype)
-      tracer.scope().unbind(tedious.Connection.prototype)
-    }
-  }
-]
+module.exports = TediousPlugin

package/packages/dd-trace/lib/version.js

@@ -1 +1 @@
-module.exports = '2.3.0'
+module.exports = '2.4.1'