dd-trace 2.6.0 → 2.8.0

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

@@ -30,11 +30,9 @@ class NetPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub(`apm:net:ipc:end`, this.exit.bind(this))
-
     this.addSub(`apm:net:ipc:error`, errorHandler)
 
-    this.addSub(`apm:net:ipc:async-end`, defaultAsyncEnd)
+    this.addSub(`apm:net:ipc:finish`, defaultFinish)
 
     this.addSub(`apm:net:tcp:start`, ({ options }) => {
       const store = storage.getStore()
@@ -62,11 +60,9 @@ class NetPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub(`apm:net:tcp:end`, this.exit.bind(this))
-
     this.addSub(`apm:net:tcp:error`, errorHandler)
 
-    this.addSub(`apm:net:tcp:async-end`, defaultAsyncEnd)
+    this.addSub(`apm:net:tcp:finish`, defaultFinish)
 
     this.addSub(`apm:net:tcp:connection`, ({ socket }) => {
       const span = storage.getStore().span
@@ -78,7 +74,7 @@ class NetPlugin extends Plugin {
   }
 }
 
-function defaultAsyncEnd () {
+function defaultFinish () {
   storage.getStore().span.finish()
 }
 

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

@@ -1,105 +1,54 @@
 'use strict'
 
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
-const connectionAttributes = new WeakMap()
-const poolAttributes = new WeakMap()
+class OracledbPlugin extends Plugin {
+  static get name () {
+    return 'oracledb'
+  }
+
+  constructor (...args) {
+    super(...args)
 
-function createWrapExecute (tracer, config) {
-  return function wrapExecute (execute) {
-    return function executeWithTrace (dbQuery, ...args) {
-      const connAttrs = connectionAttributes.get(this)
-      const service = getServiceName(tracer, config, connAttrs)
+    this.addSub('apm:oracledb:execute:start', ({ query, connAttrs }) => {
+      const service = getServiceName(this.tracer, this.config, connAttrs)
       const connectStringObj = new URL('http://' + connAttrs.connectString)
       const tags = {
         'span.kind': 'client',
         'span.type': 'sql',
-        'sql.query': dbQuery,
+        'sql.query': query,
         'db.instance': connectStringObj.pathname.substring(1),
         'db.hostname': connectStringObj.hostname,
-        'db.user': config.user,
+        'db.user': this.config.user,
         'db.port': connectStringObj.port,
-        'resource.name': dbQuery,
+        'resource.name': query,
         'service.name': service
       }
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
+      const span = this.tracer.startSpan('oracle.query', {
+        childOf,
+        tags
+      })
+      analyticsSampler.sample(span, this.config.measured)
+      this.enter(span, store)
+    })
 
-      return tracer.wrap('oracle.query', { tags }, function (...args) {
-        const span = tracer.scope().active()
-
-        analyticsSampler.sample(span, config.measured)
-
-        return execute.apply(this, args)
-      }).apply(this, arguments)
-    }
-  }
-}
-
-function createWrapGetConnection (tracer, config) {
-  return function wrapGetConnection (getConnection) {
-    return function getConnectionWithTrace (connAttrs, callback) {
-      if (callback) {
-        arguments[1] = (err, connection) => {
-          if (connection) {
-            connectionAttributes.set(connection, connAttrs)
-          }
-          callback(err, connection)
-        }
-
-        getConnection.apply(this, arguments)
-      } else {
-        return getConnection.apply(this, arguments).then((connection) => {
-          connectionAttributes.set(connection, connAttrs)
-          return connection
-        })
-      }
-    }
-  }
-}
-
-function createWrapCreatePool (tracer, config) {
-  return function wrapCreatePool (createPool) {
-    return function createPoolWithTrace (poolAttrs, callback) {
-      if (callback) {
-        arguments[1] = (err, pool) => {
-          if (pool) {
-            poolAttributes.set(pool, poolAttrs)
-          }
-          callback(err, pool)
-        }
-
-        createPool.apply(this, arguments)
-      } else {
-        return createPool.apply(this, arguments).then((pool) => {
-          poolAttributes.set(pool, poolAttrs)
-          return pool
-        })
+    this.addSub('apm:oracledb:execute:error', err => {
+      const store = storage.getStore()
+      if (store && store.span) {
+        store.span.setTag('error', err)
       }
-    }
-  }
-}
+    })
 
-function createWrapPoolGetConnection (tracer, config) {
-  return function wrapPoolGetConnection (getConnection) {
-    return function poolGetConnectionWithTrace () {
-      let callback
-      if (typeof arguments[arguments.length - 1] === 'function') {
-        callback = arguments[arguments.length - 1]
-      }
-      if (callback) {
-        arguments[arguments.length - 1] = (err, connection) => {
-          if (connection) {
-            connectionAttributes.set(connection, poolAttributes.get(this))
-          }
-          callback(err, connection)
-        }
-        getConnection.apply(this, arguments)
-      } else {
-        return getConnection.apply(this, arguments).then((connection) => {
-          connectionAttributes.set(connection, poolAttributes.get(this))
-          return connection
-        })
+    this.addSub('apm:oracledb:execute:finish', () => {
+      const store = storage.getStore()
+      if (store && store.span) {
+        store.span.finish()
       }
-    }
+    })
   }
 }
 
@@ -113,19 +62,4 @@ function getServiceName (tracer, config, connAttrs) {
   }
 }
 
-module.exports = {
-  name: 'oracledb',
-  versions: ['5'],
-  patch (oracledb, tracer, config) {
-    this.wrap(oracledb.Connection.prototype, 'execute', createWrapExecute(tracer, config))
-    this.wrap(oracledb, 'getConnection', createWrapGetConnection(tracer, config))
-    this.wrap(oracledb, 'createPool', createWrapCreatePool(tracer, config))
-    this.wrap(oracledb.Pool.prototype, 'getConnection', createWrapPoolGetConnection(tracer, config))
-  },
-  unpatch (oracledb) {
-    this.unwrap(oracledb.Connection.prototype, 'execute')
-    this.unwrap(oracledb, 'getConnection')
-    this.unwrap(oracledb, 'createPool')
-    this.unwrap(oracledb.Pool.prototype, 'getConnection')
-  }
-}
+module.exports = OracledbPlugin

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

@@ -1,111 +1,25 @@
 'use strict'
 
-const web = require('../../dd-trace/src/plugins/util/web')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const PaperplaneLoggerPlugin = require('./logger')
+const PaperplaneServerPlugin = require('./server')
 
-const traceRoute = handler => req => {
-  const { original, route } = req
-
-  if (web.active(original)) {
-    web.enterRoute(original, route)
+class PaperplanePlugin extends Plugin {
+  static get name () {
+    return 'paperplane'
   }
 
-  return handler(req)
-}
-
-const wrapLogger = tracer => logger => record => {
-  const span = tracer.scope().active()
+  constructor (...args) {
+    super(...args)
 
-  if (!span) return logger(record)
-
-  const correlation = {
-    dd: {
-      trace_id: span.context().toTraceId(),
-      span_id: span.context().toSpanId()
-    }
+    this.server = new PaperplaneServerPlugin(...args)
+    this.logger = new PaperplaneLoggerPlugin(...args)
   }
 
-  record = record instanceof Error
-    ? Object.assign(record, correlation)
-    : Object.assign({}, record, correlation)
-
-  return logger(record)
-}
-
-const wrapMount = (tracer, config) => mount => opts => {
-  const handler = mount(opts)
-
-  const traced = (req, res) =>
-    web.instrument(
-      tracer, config, req, res, 'paperplane.request',
-      () => handler(req, res)
-    )
-
-  return traced
-}
-
-const wrapRoutes = tracer => routes => handlers => {
-  const traced = {}
-
-  for (const route in handlers) {
-    traced[route] = traceRoute(handlers[route])
+  configure (config) {
+    this.server.configure(config)
+    this.logger.configure(config)
   }
-
-  return routes(traced)
 }
 
-const nodeMajor = Number(process.versions.node.split('.')[0])
-const mainVersionRange = nodeMajor <= 12 ? ['>=2.3.2'] : nodeMajor <= 14 ? ['>=3.1.1'] : []
-
-module.exports = [
-  {
-    name: 'paperplane',
-    versions: mainVersionRange,
-    file: 'lib/logger.js',
-    patch (exports, tracer) {
-      if (tracer._logInjection) {
-        this.wrap(exports, 'logger', wrapLogger(tracer))
-      }
-    },
-    unpatch (exports) {
-      this.unwrap(exports, 'logger')
-    }
-  },
-  {
-    name: 'paperplane',
-    versions: mainVersionRange,
-    file: 'lib/mount.js',
-    patch (exports, tracer, config) {
-      config = web.normalizeConfig(config)
-      this.wrap(exports, 'mount', wrapMount(tracer, config))
-    },
-    unpatch (exports) {
-      this.unwrap(exports, 'mount')
-    }
-  },
-  {
-    name: 'paperplane',
-    versions: mainVersionRange,
-    file: 'lib/routes.js',
-    patch (exports, tracer) {
-      this.wrap(exports, 'routes', wrapRoutes(tracer))
-    },
-    unpatch (exports) {
-      this.unwrap(exports, 'routes')
-    }
-  }
-]
-
-if (nodeMajor <= 12) {
-  module.exports.push({
-    name: 'paperplane',
-    versions: ['2.3.0 - 2.3.1'],
-    patch (paperplane, tracer, config) {
-      config = web.normalizeConfig(config)
-      this.wrap(paperplane, 'mount', wrapMount(tracer, config))
-      this.wrap(paperplane, 'routes', wrapRoutes(tracer))
-    },
-    unpatch (paperplane) {
-      this.unwrap(paperplane, ['mount', 'routes'])
-    }
-  })
-}
+module.exports = PaperplanePlugin

package/packages/datadog-plugin-paperplane/src/logger.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const LogPlugin = require('../../dd-trace/src/plugins/log_plugin')
+
+class PaperplaneLoggerPlugin extends LogPlugin {
+  static get name () {
+    return 'paperplane'
+  }
+}
+
+module.exports = PaperplaneLoggerPlugin

package/packages/datadog-plugin-paperplane/src/server.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const RouterPlugin = require('../../datadog-plugin-router/src')
+const web = require('../../dd-trace/src/plugins/util/web')
+
+class PaperplaneServerPlugin extends RouterPlugin {
+  static get name () {
+    return 'paperplane'
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:paperplane:request:handle', req => {
+      this.setFramework(req, 'paperplane', this.config)
+    })
+
+    this.addSub('apm:paperplane:request:route', ({ req, route }) => {
+      web.setRoute(req, route)
+    })
+  }
+}
+
+module.exports = PaperplaneServerPlugin

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

@@ -40,16 +40,12 @@ class PGPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub(`apm:pg:query:end`, () => {
-      this.exit()
-    })
-
     this.addSub(`apm:pg:query:error`, err => {
       const span = storage.getStore().span
       span.setTag('error', err)
     })
 
-    this.addSub(`apm:pg:query:async-end`, () => {
+    this.addSub(`apm:pg:query:finish`, () => {
       const span = storage.getStore().span
       span.finish()
     })

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

@@ -55,16 +55,12 @@ class RedisPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub(`apm:${this.constructor.name}:command:end`, () => {
-      this.exit()
-    })
-
     this.addSub(`apm:${this.constructor.name}:command:error`, err => {
       const span = storage.getStore().span
       span.setTag('error', err)
     })
 
-    this.addSub(`apm:${this.constructor.name}:command:async-end`, () => {
+    this.addSub(`apm:${this.constructor.name}:command:finish`, () => {
       const span = storage.getStore().span
       span.finish()
     })

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

@@ -1,86 +1,24 @@
 'use strict'
 
+const RouterPlugin = require('../../datadog-plugin-router/src')
 const web = require('../../dd-trace/src/plugins/util/web')
-const handlers = ['use', 'pre']
-const methods = ['del', 'get', 'head', 'opts', 'post', 'put', 'patch']
 
-function createWrapSetupRequest (tracer, config, withRoute) {
-  config = web.normalizeConfig(config)
-
-  return function wrapSetupRequest (setupRequest) {
-    return function setupRequestWithTrace (req, res) {
-      return web.instrument(tracer, config, req, res, 'restify.request', () => {
-        web.beforeEnd(req, () => {
-          if (req.route && withRoute) {
-            web.enterRoute(req, req.route.path)
-          }
-        })
-
-        return setupRequest.apply(this, arguments)
-      })
-    }
-  }
-}
-
-function createWrapMethod (tracer, config) {
-  return function wrapMethod (method) {
-    return function methodWithTrace (path) {
-      const middleware = wrapMiddleware(Array.prototype.slice.call(arguments, 1))
-
-      return method.apply(this, [path].concat(middleware))
-    }
+class RestifyPlugin extends RouterPlugin {
+  static get name () {
+    return 'restify'
   }
-}
-
-function createWrapHandler (tracer, config) {
-  return function wrapMethod (method) {
-    return function methodWithTrace () {
-      return method.apply(this, wrapMiddleware(arguments))
-    }
-  }
-}
 
-function wrapMiddleware (middleware) {
-  return Array.prototype.map.call(middleware, wrapFn)
-}
+  constructor (...args) {
+    super(...args)
 
-function wrapFn (fn) {
-  if (Array.isArray(fn)) return wrapMiddleware(fn)
+    this.addSub('apm:restify:request:handle', ({ req }) => {
+      this.setFramework(req, 'restify', this.config)
+    })
 
-  return function (req, res, next) {
-    return web.reactivate(req, () => fn.apply(this, arguments))
+    this.addSub('apm:restify:request:route', ({ req, route }) => {
+      web.setRoute(req, route)
+    })
   }
 }
 
-module.exports = [
-  {
-    name: 'restify',
-    versions: ['>=7'],
-    file: 'lib/server.js',
-    patch (Server, tracer, config) {
-      this.wrap(Server.prototype, '_setupRequest', createWrapSetupRequest(tracer, config))
-      this.wrap(Server.prototype, handlers, createWrapHandler(tracer, config))
-      this.wrap(Server.prototype, methods, createWrapMethod(tracer, config))
-    },
-    unpatch (Server) {
-      this.unwrap(Server.prototype, '_setupRequest')
-      this.unwrap(Server.prototype, handlers)
-      this.unwrap(Server.prototype, methods)
-    }
-  },
-  {
-    name: 'restify',
-    versions: ['3 - 6'],
-    file: 'lib/server.js',
-    patch (Server, tracer, config) {
-      this.wrap(Server.prototype, '_setupRequest', createWrapSetupRequest(tracer, config, true))
-      this.wrap(Server.prototype, handlers, createWrapHandler(tracer, config))
-      this.wrap(Server.prototype, methods, createWrapMethod(tracer, config))
-    },
-    unpatch (Server) {
-      this.unwrap(Server.prototype, '_setupRequest')
-      this.unwrap(Server.prototype, handlers)
-      this.unwrap(Server.prototype, methods)
-    }
-  }
-]
+module.exports = RestifyPlugin

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

@@ -61,15 +61,11 @@ class RheaPlugin extends Plugin {
       storage.getStore().span.setTag('error', error)
     })
 
-    this.addSub(`apm:rhea:async-end`, () => {
+    this.addSub(`apm:rhea:finish`, () => {
       const span = storage.getStore().span
       span.finish()
     })
 
-    this.addSub(`apm:rhea:end`, () => {
-      this.exit()
-    })
-
     this.addSub(`apm:rhea:dispatch`, ({ state }) => {
       const span = storage.getStore().span
       span.setTag('amqp.delivery.state', state)