dd-trace 2.3.0 → 2.4.1

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

@@ -1,145 +1,89 @@
 'use strict'
 
-const tx = require('../../dd-trace/src/plugins/util/tx')
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
 const { storage } = require('../../datadog-core')
+const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
-function createWrapConnect (tracer, config) {
-  return function wrapConnect (connect) {
-    return function connectWithTrace () {
-      const store = storage.getStore()
-
-      if (store && store.noop) return connect.apply(this, arguments)
-
-      const scope = tracer.scope()
-      const options = getOptions(arguments)
-      const lastIndex = arguments.length - 1
-      const callback = arguments[lastIndex]
-
-      if (!options) return connect.apply(this, arguments)
-
-      if (typeof callback === 'function') {
-        arguments[lastIndex] = scope.bind(callback)
-      }
-
-      const span = options.path
-        ? wrapIpc(tracer, config, this, options)
-        : wrapTcp(tracer, config, this, options)
-
-      analyticsSampler.sample(span, config.measured)
-
-      return scope.bind(connect, span).apply(this, arguments)
-    }
+class NetPlugin extends Plugin {
+  static get name () {
+    return 'net'
   }
-}
 
-function wrapTcp (tracer, config, socket, options) {
-  const host = options.host || 'localhost'
-  const port = options.port || 0
-  const family = options.family || 4
+  constructor (...args) {
+    super(...args)
 
-  const span = startSpan(tracer, config, 'tcp', {
-    'resource.name': [host, port].filter(val => val).join(':'),
-    'tcp.remote.host': host,
-    'tcp.remote.port': port,
-    'tcp.family': `IPv${family}`,
-    'out.host': host,
-    'out.port': port
-  })
-
-  setupListeners(socket, span, 'tcp')
+    this.addSub(`apm:net:ipc:start`, ({ options }) => {
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
+
+      const span = this.tracer.startSpan('ipc.connect', {
+        childOf,
+        tags: {
+          'resource.name': options.path,
+          'ipc.path': options.path,
+          'span.kind': 'client',
+          'service.name': this.config.service || this.tracer._service
+        }
+      })
 
-  return span
-}
+      analyticsSampler.sample(span, this.config.measured)
+      this.enter(span, store)
+    })
 
-function wrapIpc (tracer, config, socket, options) {
-  const span = startSpan(tracer, config, 'ipc', {
-    'resource.name': options.path,
-    'ipc.path': options.path
-  })
+    this.addSub(`apm:net:ipc:end`, this.exit.bind(this))
 
-  setupListeners(socket, span, 'ipc')
+    this.addSub(`apm:net:ipc:error`, errorHandler)
 
-  return span
-}
+    this.addSub(`apm:net:ipc:async-end`, defaultAsyncEnd)
 
-function startSpan (tracer, config, protocol, tags) {
-  const childOf = tracer.scope().active()
-  const span = tracer.startSpan(`${protocol}.connect`, {
-    childOf,
-    tags: Object.assign({
-      'span.kind': 'client',
-      'service.name': config.service || tracer._service
-    }, tags)
-  })
-
-  return span
-}
-
-function getOptions (args) {
-  if (!args[0]) return
-
-  switch (typeof args[0]) {
-    case 'object':
-      if (Array.isArray(args[0])) return getOptions(args[0])
-      return args[0]
-    case 'string':
-      if (isNaN(parseFloat(args[0]))) {
-        return {
-          path: args[0]
+    this.addSub(`apm:net:tcp:start`, ({ options }) => {
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
+
+      const host = options.host || 'localhost'
+      const port = options.port || 0
+      const family = options.family || 4
+
+      const span = this.tracer.startSpan('tcp.connect', {
+        childOf,
+        tags: {
+          'resource.name': [host, port].filter(val => val).join(':'),
+          'tcp.remote.host': host,
+          'tcp.remote.port': port,
+          'tcp.family': `IPv${family}`,
+          'out.host': host,
+          'out.port': port,
+          'span.kind': 'client',
+          'service.name': this.config.service || this.tracer._service
         }
-      }
-    case 'number': // eslint-disable-line no-fallthrough
-      return {
-        port: args[0],
-        host: typeof args[1] === 'string' ? args[1] : 'localhost'
-      }
-  }
-}
+      })
 
-function setupListeners (socket, span, protocol) {
-  const events = ['connect', 'error', 'close', 'timeout']
+      analyticsSampler.sample(span, this.config.measured)
+      this.enter(span, store)
+    })
 
-  const wrapListener = tx.wrap(span)
+    this.addSub(`apm:net:tcp:end`, this.exit.bind(this))
 
-  const localListener = () => {
-    span.addTags({
-      'tcp.local.address': socket.localAddress,
-      'tcp.local.port': socket.localPort
-    })
-  }
+    this.addSub(`apm:net:tcp:error`, errorHandler)
 
-  const cleanupListener = () => {
-    socket.removeListener('connect', localListener)
+    this.addSub(`apm:net:tcp:async-end`, defaultAsyncEnd)
 
-    events.forEach(event => {
-      socket.removeListener(event, wrapListener)
-      socket.removeListener(event, cleanupListener)
+    this.addSub(`apm:net:tcp:connection`, ({ socket }) => {
+      const span = storage.getStore().span
+      span.addTags({
+        'tcp.local.address': socket.localAddress,
+        'tcp.local.port': socket.localPort
+      })
     })
   }
-
-  if (protocol === 'tcp') {
-    socket.once('connect', localListener)
-  }
-
-  events.forEach(event => {
-    socket.once(event, wrapListener)
-    socket.once(event, cleanupListener)
-  })
 }
 
-module.exports = {
-  name: 'net',
-  patch (net, tracer, config) {
-    require('dns') // net will otherwise get an unpatched version for DNS lookups
-
-    tracer.scope().bind(net.Socket.prototype)
-
-    this.wrap(net.Socket.prototype, 'connect', createWrapConnect(tracer, config))
-  },
-  unpatch (net, tracer) {
-    tracer.scope().unbind(net.Socket.prototype)
+function defaultAsyncEnd () {
+  storage.getStore().span.finish()
+}
 
-    this.unwrap(net.Socket.prototype, 'connect')
-  }
+function errorHandler (error) {
+  storage.getStore().span.setTag('error', error)
 }
+
+module.exports = NetPlugin

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

@@ -20,15 +20,15 @@ function createWrapHandleApiRequest (tracer, config) {
       return trace(tracer, config, req, res, () => {
         const promise = handleApiRequest.apply(this, arguments)
 
-        promise.then(handled => {
-          if (!handled) return
+        return promise.then(handled => {
+          if (!handled) return handled
 
           const page = getPageFromPath(pathname, this.dynamicRoutes)
 
           addPage(req, page)
-        })
 
-        return promise
+          return handled
+        })
       })
     }
   }
@@ -118,12 +118,10 @@ function trace (tracer, config, req, res, handler) {
   // TODO: Use CLS when it will be available in core.
   span._nextReq = req
 
-  promise.then(
-    () => finish(span, config, req, res),
-    err => finish(span, config, req, res, err)
+  return promise.then(
+    result => finish(span, config, req, res, result),
+    err => finish(span, config, req, res, null, err)
   )
-
-  return promise
 }
 
 function addPage (req, page) {
@@ -137,13 +135,15 @@ function addPage (req, page) {
   })
 }
 
-function finish (span, config, req, res, err) {
+function finish (span, config, req, res, result, err) {
   span.setTag('error', err || !config.validateStatus(res.statusCode))
   span.addTags({
     'http.status_code': res.statusCode
   })
   config.hooks.request(span, req, res)
   span.finish()
+
+  return result || err
 }
 
 function normalizeConfig (config) {

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

@@ -1,44 +1,32 @@
 'use strict'
 
-const Tags = require('opentracing').Tags
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
-const OPERATION_NAME = 'pg.query'
+class PGPlugin extends Plugin {
+  static get name () {
+    return 'pg'
+  }
+
+  constructor (...args) {
+    super(...args)
 
-function createWrapQuery (tracer, config) {
-  return function wrapQuery (query) {
-    return function queryWithTrace () {
-      const scope = tracer.scope()
-      const childOf = scope.active()
-      const params = this.connectionParameters
-      const service = getServiceName(tracer, config, params)
-      const span = tracer.startSpan(OPERATION_NAME, {
+    this.addSub(`apm:pg:query:start`, ({ params, statement }) => {
+      const service = getServiceName(this.tracer, this.config, params)
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
+      const span = this.tracer.startSpan('pg.query', {
         childOf,
         tags: {
-          [Tags.SPAN_KIND]: Tags.SPAN_KIND_RPC_CLIENT,
           'service.name': service,
           'span.type': 'sql',
           'span.kind': 'client',
-          'db.type': 'postgres'
+          'db.type': 'postgres',
+          'resource.name': statement
         }
       })
 
-      analyticsSampler.sample(span, config.measured)
-
-      const retval = scope.bind(query, span).apply(this, arguments)
-      const queryQueue = this.queryQueue || this._queryQueue
-      const activeQuery = this.activeQuery || this._activeQuery
-      const pgQuery = queryQueue[queryQueue.length - 1] || activeQuery
-
-      if (!pgQuery) {
-        return retval
-      }
-
-      const originalCallback = pgQuery.callback
-      const statement = pgQuery.text
-
-      span.setTag('resource.name', statement)
-
       if (params) {
         span.addTags({
           'db.name': params.database,
@@ -48,26 +36,23 @@ function createWrapQuery (tracer, config) {
         })
       }
 
-      const finish = (error) => {
-        span.setTag('error', error)
-        span.finish()
-      }
+      analyticsSampler.sample(span, this.config.measured)
+      this.enter(span, store)
+    })
 
-      if (originalCallback) {
-        pgQuery.callback = scope.bind((err, res) => {
-          finish(err)
-          originalCallback(err, res)
-        }, childOf)
-      } else if (pgQuery.once) {
-        pgQuery
-          .once('error', finish)
-          .once('end', () => finish())
-      } else {
-        pgQuery.then(() => finish(), finish)
-      }
+    this.addSub(`apm:pg:query:end`, () => {
+      this.exit()
+    })
+
+    this.addSub(`apm:pg:query:error`, err => {
+      const span = storage.getStore().span
+      span.setTag('error', err)
+    })
 
-      return retval
-    }
+    this.addSub(`apm:pg:query:async-end`, () => {
+      const span = storage.getStore().span
+      span.finish()
+    })
   }
 }
 
@@ -81,26 +66,4 @@ function getServiceName (tracer, config, params) {
   }
 }
 
-module.exports = [
-  {
-    name: 'pg',
-    versions: ['>=4'],
-    patch (pg, tracer, config) {
-      this.wrap(pg.Client.prototype, 'query', createWrapQuery(tracer, config))
-    },
-    unpatch (pg) {
-      this.unwrap(pg.Client.prototype, 'query')
-    }
-  },
-  {
-    name: 'pg',
-    versions: ['>=4'],
-    file: 'lib/native/index.js',
-    patch (Client, tracer, config) {
-      this.wrap(Client.prototype, 'query', createWrapQuery(tracer, config))
-    },
-    unpatch (Client) {
-      this.unwrap(Client.prototype, 'query')
-    }
-  }
-]
+module.exports = PGPlugin