dd-trace 2.4.2 → 2.7.0

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

@@ -1,90 +1,85 @@
 'use strict'
 
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
-function createWrapProducer (tracer, config) {
-  return function wrapProducer (createProducer) {
-    return function producerWithTrace () {
-      const serviceName = config.service || `${tracer._service}-kafka`
-      const producer = createProducer.apply(this, arguments)
-
-      const send = producer.send
-
-      const tags = {
-        'service.name': serviceName,
-        'span.kind': 'producer',
-        'component': 'kafkajs'
-      }
+class KafkajsPlugin extends Plugin {
+  static get name () {
+    return 'kafkajs'
+  }
 
-      producer.send = tracer.wrap('kafka.produce', { tags }, function (...args) {
-        const { topic, messages = [] } = args[0]
-        const currentSpan = tracer.scope().active()
+  constructor (...args) {
+    super(...args)
+
+    this.addSub(`apm:kafkajs:produce:start`, ({ topic, messages }) => {
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
+      const span = this.tracer.startSpan('kafka.produce', {
+        childOf,
+        tags: {
+          'service.name': this.config.service || `${this.tracer._service}-kafka`,
+          'span.kind': 'producer',
+          'component': 'kafkajs'
+        }
+      })
 
-        analyticsSampler.sample(currentSpan, config.measured)
+      analyticsSampler.sample(span, this.config.measured)
+      this.enter(span, store)
 
-        currentSpan.addTags({
+      span.addTags({
+        'resource.name': topic,
+        'kafka.topic': topic,
+        'kafka.batch_size': messages.length
+      })
+      for (const message of messages) {
+        if (typeof message === 'object') {
+          this.tracer.inject(span, 'text_map', message.headers)
+        }
+      }
+    })
+
+    this.addSub(`apm:kafkajs:consume:start`, ({ topic, partition, message }) => {
+      const store = storage.getStore()
+      const childOf = extract(this.tracer, message.headers)
+      const span = this.tracer.startSpan('kafka.consume', {
+        childOf,
+        tags: {
+          'service.name': this.config.service || `${this.tracer._service}-kafka`,
+          'span.kind': 'consumer',
+          'span.type': 'worker',
+          'component': 'kafkajs',
           'resource.name': topic,
           'kafka.topic': topic,
-          'kafka.batch_size': messages.length
-        })
-
-        for (const message of messages) {
-          message.headers = message.headers || {}
-          tracer.inject(currentSpan, 'text_map', message.headers)
+          'kafka.partition': partition,
+          'kafka.message.offset': message.offset
         }
-
-        return send.apply(this, args)
       })
 
-      return producer
-    }
-  }
-}
+      analyticsSampler.sample(span, this.config.measured, true)
+      this.enter(span, store)
+    })
 
-function createWrapConsumer (tracer, config) {
-  return function wrapConsumer (createConsumer) {
-    return function consumerWithTrace () {
-      const serviceName = config.service || `${tracer._service}-kafka`
-      const consumer = createConsumer.apply(this, arguments)
-      const run = consumer.run
-
-      const tags = {
-        'service.name': serviceName,
-        'span.kind': 'consumer',
-        'span.type': 'worker',
-        'component': 'kafkajs'
-      }
+    this.addSub(`apm:kafkajs:end`, () => {
+      this.exit()
+    })
 
-      consumer.run = function ({ eachMessage, ...runArgs }) {
-        if (typeof eachMessage !== 'function') return run({ eachMessage, ...runArgs })
+    this.addSub(`apm:kafkajs:consume:error`, errorHandler)
 
-        return run({
-          eachMessage: function (...eachMessageArgs) {
-            const { topic, partition, message } = eachMessageArgs[0]
-            const childOf = extract(tracer, message.headers)
+    this.addSub(`apm:kafkajs:consume:finish`, finishHandler)
 
-            return tracer.trace('kafka.consume', { childOf, tags }, () => {
-              const currentSpan = tracer.scope().active()
+    this.addSub(`apm:kafkajs:produce:error`, errorHandler)
 
-              analyticsSampler.sample(currentSpan, config.measured, true)
-
-              currentSpan.addTags({
-                'resource.name': topic,
-                'kafka.topic': topic,
-                'kafka.partition': partition,
-                'kafka.message.offset': message.offset
-              })
+    this.addSub(`apm:kafkajs:produce:finish`, finishHandler)
+  }
+}
 
-              return eachMessage.apply(this, eachMessageArgs)
-            })
-          },
-          ...runArgs
-        })
-      }
+function finishHandler () {
+  storage.getStore().span.finish()
+}
 
-      return consumer
-    }
-  }
+function errorHandler (error) {
+  storage.getStore().span.setTag('error', error)
 }
 
 function extract (tracer, bufferMap) {
@@ -99,25 +94,4 @@ function extract (tracer, bufferMap) {
   return tracer.extract('text_map', textMap)
 }
 
-module.exports = [
-  {
-    name: 'kafkajs',
-    versions: ['>=1.4'],
-    patch ({ Kafka }, tracer, config) {
-      this.wrap(
-        Kafka.prototype,
-        'producer',
-        createWrapProducer(tracer, config)
-      )
-      this.wrap(
-        Kafka.prototype,
-        'consumer',
-        createWrapConsumer(tracer, config)
-      )
-    },
-    unpatch ({ Kafka }) {
-      this.unwrap(Kafka.prototype, 'producer')
-      this.unwrap(Kafka.prototype, 'consumer')
-    }
-  }
-]
+module.exports = KafkajsPlugin

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

@@ -5,21 +5,19 @@ const { storage } = require('../../datadog-core')
 
 const {
   CI_APP_ORIGIN,
-  TEST_TYPE,
-  TEST_NAME,
+  TEST_CODE_OWNERS,
   TEST_SUITE,
-  TEST_FRAMEWORK_VERSION,
   TEST_STATUS,
   TEST_PARAMETERS,
   finishAllTraceSpans,
   getTestEnvironmentMetadata,
   getTestSuitePath,
   getTestParentSpan,
-  getTestParametersString
+  getTestParametersString,
+  getCodeOwnersFileEntries,
+  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()
 
@@ -30,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
   }
 }
 
@@ -54,6 +47,7 @@ class MochaPlugin extends Plugin {
     this._testNameToParams = {}
     this.testEnvironmentMetadata = getTestEnvironmentMetadata('mocha', this.config)
     this.sourceRoot = process.cwd()
+    this.codeOwnersEntries = getCodeOwnersFileEntries(this.sourceRoot)
 
     this.addSub('ci:mocha:test:start', (test) => {
       const store = storage.getStore()
@@ -139,6 +133,11 @@ class MochaPlugin extends Plugin {
     if (testParametersString) {
       testSpanMetadata[TEST_PARAMETERS] = testParametersString
     }
+    const codeOwners = getCodeOwnersForFilename(testSpanMetadata[TEST_SUITE], this.codeOwnersEntries)
+
+    if (codeOwners) {
+      testSpanMetadata[TEST_CODE_OWNERS] = codeOwners
+    }
 
     const testSpan = this.tracer
       .startSpan('mocha.test', {

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