dd-trace 2.5.0 → 2.7.1

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

@@ -1,176 +1,24 @@
 'use strict'
 
+const RouterPlugin = require('../../datadog-plugin-router/src')
 const web = require('../../dd-trace/src/plugins/util/web')
 
-const originals = new WeakMap()
-
-function createWrapCallback (tracer, config) {
-  config = web.normalizeConfig(config)
-
-  return function wrapCallback (callback) {
-    return function callbackWithTrace () {
-      const handleRequest = callback.apply(this, arguments)
-
-      if (typeof handleRequest !== 'function') return handleRequest
-
-      return function handleRequestWithTrace (req, res) {
-        web.instrument(tracer, config, req, res, 'koa.request')
-
-        return handleRequest.apply(this, arguments)
-      }
-    }
-  }
-}
-
-function createWrapCreateContext () {
-  return function wrapCreateContext (createContext) {
-    return function createContextWithTrace (req, res) {
-      const ctx = createContext.apply(this, arguments)
-
-      if (!ctx) return ctx
-
-      web.patch(req)
-      web.beforeEnd(req, () => {
-        web.enterRoute(req, ctx.routePath)
-      })
-
-      return ctx
-    }
+class KoaPlugin extends RouterPlugin {
+  static get name () {
+    return 'koa'
   }
-}
-
-function createWrapUse () {
-  return function wrapUse (use) {
-    return function useWithTrace () {
-      const result = use.apply(this, arguments)
-
-      if (!Array.isArray(this.middleware)) return result
 
-      const fn = this.middleware.pop()
+  constructor (...args) {
+    super(...args)
 
-      this.middleware.push(wrapMiddleware(fn))
-
-      return result
-    }
-  }
-}
-
-function createWrapRegister (tracer, config) {
-  return function wrapRegister (register) {
-    return function registerWithTrace (path, methods, middleware, opts) {
-      const route = register.apply(this, arguments)
-
-      if (!Array.isArray(path) && route && Array.isArray(route.stack)) {
-        wrapStack(route)
-      }
-
-      return route
-    }
-  }
-}
-
-function createWrapRouterUse (tracer, config) {
-  return function wrapUse (use) {
-    return function useWithTrace () {
-      const router = use.apply(this, arguments)
-
-      router.stack.forEach(wrapStack)
-
-      return router
-    }
-  }
-}
-
-function wrapStack (layer) {
-  layer.stack = layer.stack.map(middleware => {
-    if (typeof middleware !== 'function') return middleware
-
-    const original = originals.get(middleware)
-
-    middleware = original || middleware
-
-    const wrappedMiddleware = wrapMiddleware(middleware)
-
-    const handler = function (ctx, next) {
-      if (!ctx || !web.active(ctx.req)) return middleware.apply(this, arguments)
-
-      web.exitRoute(ctx.req)
-      web.enterRoute(ctx.req, layer.path)
-
-      return wrappedMiddleware.apply(this, arguments)
-    }
-
-    originals.set(handler, middleware)
-
-    return handler
-  })
-}
-
-function wrapMiddleware (fn) {
-  if (typeof fn !== 'function') return fn
-
-  return function (ctx, next) {
-    if (!ctx) return fn.apply(this, arguments)
-
-    return web.wrapMiddleware(ctx.req, fn, 'koa.middleware', () => {
-      try {
-        const result = fn.apply(this, arguments)
-
-        if (result && typeof result.then === 'function') {
-          result.then(
-            () => web.finish(ctx.req),
-            err => web.finish(ctx.req, err)
-          )
-        } else {
-          web.finish(ctx.req)
-        }
+    this.addSub('apm:koa:request:handle', ({ req }) => {
+      this.setFramework(req, 'koa', this.config)
+    })
 
-        return result
-      } catch (e) {
-        web.finish(ctx.req, e)
-        throw e
-      }
+    this.addSub('apm:koa:request:route', ({ req, route }) => {
+      web.setRoute(req, route)
     })
   }
 }
 
-module.exports = [
-  {
-    name: 'koa',
-    versions: ['>=2'],
-    patch (Koa, tracer, config) {
-      this.wrap(Koa.prototype, 'callback', createWrapCallback(tracer, config))
-      this.wrap(Koa.prototype, 'createContext', createWrapCreateContext(tracer, config))
-      this.wrap(Koa.prototype, 'use', createWrapUse(tracer, config))
-    },
-    unpatch (Koa) {
-      this.unwrap(Koa.prototype, 'callback')
-      this.unwrap(Koa.prototype, 'createContext')
-      this.unwrap(Koa.prototype, 'use')
-    }
-  },
-  {
-    name: '@koa/router',
-    versions: ['>=8'],
-    patch (Router, tracer, config) {
-      this.wrap(Router.prototype, 'register', createWrapRegister(tracer, config))
-      this.wrap(Router.prototype, 'use', createWrapRouterUse(tracer, config))
-    },
-    unpatch (Router) {
-      this.unwrap(Router.prototype, 'register')
-      this.unwrap(Router.prototype, 'use')
-    }
-  },
-  {
-    name: 'koa-router',
-    versions: ['>=7'],
-    patch (Router, tracer, config) {
-      this.wrap(Router.prototype, 'register', createWrapRegister(tracer, config))
-      this.wrap(Router.prototype, 'use', createWrapRouterUse(tracer, config))
-    },
-    unpatch (Router) {
-      this.unwrap(Router.prototype, 'register')
-      this.unwrap(Router.prototype, 'use')
-    }
-  }
-]
+module.exports = KoaPlugin

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

@@ -6,10 +6,7 @@ const { storage } = require('../../datadog-core')
 const {
   CI_APP_ORIGIN,
   TEST_CODE_OWNERS,
-  TEST_TYPE,
-  TEST_NAME,
   TEST_SUITE,
-  TEST_FRAMEWORK_VERSION,
   TEST_STATUS,
   TEST_PARAMETERS,
   finishAllTraceSpans,
@@ -18,11 +15,9 @@ const {
   getTestParentSpan,
   getTestParametersString,
   getCodeOwnersFileEntries,
-  getCodeOwnersForFilename
+  getCodeOwnersForFilename,
+  getTestCommonTags
 } = require('../../dd-trace/src/plugins/util/test')
-const { SPAN_TYPE, RESOURCE_NAME, SAMPLING_PRIORITY } = require('../../../ext/tags')
-const { SAMPLING_RULE_DECISION } = require('../../dd-trace/src/constants')
-const { AUTO_KEEP } = require('../../../ext/priority')
 
 const skippedTests = new WeakSet()
 
@@ -33,16 +28,11 @@ function getTestSpanMetadata (tracer, test, sourceRoot) {
   const fullTestName = test.fullTitle()
   const testSuite = getTestSuitePath(testSuiteAbsolutePath, sourceRoot)
 
+  const commonTags = getTestCommonTags(fullTestName, testSuite, tracer._version)
+
   return {
     childOf,
-    [SPAN_TYPE]: 'test',
-    [TEST_TYPE]: 'test',
-    [TEST_NAME]: fullTestName,
-    [TEST_SUITE]: testSuite,
-    [SAMPLING_RULE_DECISION]: 1,
-    [SAMPLING_PRIORITY]: AUTO_KEEP,
-    [TEST_FRAMEWORK_VERSION]: tracer._version,
-    [RESOURCE_NAME]: `${testSuite}.${fullTestName}`
+    ...commonTags
   }
 }
 

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