dd-trace 2.2.0 → 2.3.1

package/packages/datadog-plugin-grpc/src/client.js

@@ -7,6 +7,9 @@ const { ERROR } = require('../../../ext/tags')
 const kinds = require('./kinds')
 const { addMethodTags, addMetadataTags, getFilter } = require('./util')
 
+const patched = new WeakSet()
+const instances = new WeakMap()
+
 function createWrapMakeRequest (tracer, config, methodKind) {
   const filter = getFilter(config, 'metadata')
 
@@ -80,7 +83,7 @@ function wrapClientConstructor (tracer, config, ServiceClient, methods) {
 }
 
 function wrapMethod (tracer, config, method, path, methodKind) {
-  if (typeof method !== 'function' || method._datadog_patched) {
+  if (typeof method !== 'function' || patched.has(method)) {
     return method
   }
 
@@ -94,7 +97,7 @@ function wrapMethod (tracer, config, method, path, methodKind) {
 
   Object.assign(methodWithTrace, method)
 
-  methodWithTrace._datadog_patched = true
+  patched.add(methodWithTrace)
 
   return methodWithTrace
 }
@@ -186,7 +189,9 @@ function startSpan (tracer, config, path, methodKind) {
 }
 
 function ensureMetadata (client, args, index) {
-  if (!client || !client._datadog) return args
+  const grpc = getGrpc(client)
+
+  if (!client || !grpc) return args
 
   const meta = args[index]
   const normalized = []
@@ -196,7 +201,7 @@ function ensureMetadata (client, args, index) {
   }
 
   if (!meta || !meta.constructor || meta.constructor.name !== 'Metadata') {
-    normalized.push(new client._datadog.grpc.Metadata())
+    normalized.push(new grpc.Metadata())
   }
 
   if (meta) {
@@ -238,6 +243,15 @@ function getMethodKind (definition) {
   return kinds.unary
 }
 
+function getGrpc (client) {
+  let proto = client
+
+  do {
+    const instance = instances.get(proto)
+    if (instance) return instance
+  } while ((proto = Object.getPrototypeOf(proto)))
+}
+
 function patch (grpc, tracer, config) {
   if (config.client === false) return
 
@@ -245,7 +259,7 @@ function patch (grpc, tracer, config) {
 
   const proto = grpc.Client.prototype
 
-  proto._datadog = { grpc }
+  instances.set(proto, grpc)
 
   this.wrap(proto, 'makeBidiStreamRequest', createWrapMakeRequest(tracer, config, kinds.bidi))
   this.wrap(proto, 'makeClientStreamRequest', createWrapMakeRequest(tracer, config, kinds.clientStream))
@@ -256,7 +270,7 @@ function patch (grpc, tracer, config) {
 function unpatch (grpc) {
   const proto = grpc.Client.prototype
 
-  delete proto._datadog
+  instances.delete(proto)
 
   this.unwrap(proto, 'makeBidiStreamRequest')
   this.unwrap(proto, 'makeClientStreamRequest')

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

@@ -1,5 +1,7 @@
 'use strict'
 
+// TODO: remove usage of req._datadog when the plugin is re-enabled
+
 const web = require('../../dd-trace/src/plugins/util/web')
 const shimmer = require('../../datadog-shimmer')
 

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

@@ -1,41 +1,11 @@
 'use strict'
 
-const tx = require('../../dd-trace/src/plugins/util/redis')
+const RedisPlugin = require('../../datadog-plugin-redis/src')
 
-function createWrapSendCommand (tracer, config) {
-  return function wrapSendCommand (sendCommand) {
-    return function sendCommandWithTrace (command, stream) {
-      if (!command || !command.promise || !config.filter(command.name)) return sendCommand.apply(this, arguments)
-
-      const options = this.options || {}
-      const connectionName = this.options.connectionName
-      const db = options.db
-      const span = tx.instrument(tracer, config, db, command.name, command.args)
-
-      tx.setHost(span, options.host, options.port)
-      tx.wrap(span, command.promise)
-
-      if (config.splitByInstance && connectionName) {
-        const service = config.service
-          ? `${config.service}-${connectionName}`
-          : connectionName
-
-        span.setTag('service.name', service)
-      }
-
-      return tracer.scope().bind(sendCommand, span).apply(this, arguments)
-    }
+class IORedisPlugin extends RedisPlugin {
+  static get name () {
+    return 'ioredis'
   }
 }
 
-module.exports = {
-  name: 'ioredis',
-  versions: ['>=2'],
-  patch (Redis, tracer, config) {
-    config = tx.normalizeConfig(config)
-    this.wrap(Redis.prototype, 'sendCommand', createWrapSendCommand(tracer, config))
-  },
-  unpatch (Redis) {
-    this.unwrap(Redis.prototype, 'sendCommand')
-  }
-}
+module.exports = IORedisPlugin

package/packages/datadog-plugin-jest/src/jest-environment.js

@@ -22,6 +22,8 @@ const {
   setSuppressedErrors
 } = require('./util')
 
+const originals = new WeakMap()
+
 function getVmContext (environment) {
   if (typeof environment.getVmContext === 'function') {
     return environment.getVmContext()
@@ -234,43 +236,37 @@ function createHandleTestEvent (tracer, testEnvironmentMetadata, instrumenter) {
   }
 }
 
+function patch (Environment, tracer, config) {
+  const testEnvironmentMetadata = getTestEnvironmentMetadata('jest', config)
+  const proto = Environment.prototype
+
+  this.wrap(proto, 'teardown', createWrapTeardown(tracer, this))
+
+  const newHandleTestEvent = createHandleTestEvent(tracer, testEnvironmentMetadata, this)
+  originals.set(newHandleTestEvent, proto.handleTestEvent)
+  proto.handleTestEvent = newHandleTestEvent
+
+  return wrapEnvironment(Environment)
+}
+
+function unpatch (Environment) {
+  const proto = Environment.prototype
+
+  this.unwrap(Environment.prototype, 'teardown')
+  proto.handleTestEvent = originals.get(proto.handleTestEvent)
+}
+
 module.exports = [
   {
     name: 'jest-environment-node',
     versions: ['>=24.8.0'],
-    patch: function (NodeEnvironment, tracer, config) {
-      const testEnvironmentMetadata = getTestEnvironmentMetadata('jest', config)
-
-      this.wrap(NodeEnvironment.prototype, 'teardown', createWrapTeardown(tracer, this))
-
-      const newHandleTestEvent = createHandleTestEvent(tracer, testEnvironmentMetadata, this)
-      newHandleTestEvent._dd_original = NodeEnvironment.prototype.handleTestEvent
-      NodeEnvironment.prototype.handleTestEvent = newHandleTestEvent
-
-      return wrapEnvironment(NodeEnvironment)
-    },
-    unpatch: function (NodeEnvironment) {
-      this.unwrap(NodeEnvironment.prototype, 'teardown')
-      NodeEnvironment.prototype.handleTestEvent = NodeEnvironment.prototype.handleTestEvent._dd_original
-    }
+    patch,
+    unpatch
   },
   {
     name: 'jest-environment-jsdom',
     versions: ['>=24.8.0'],
-    patch: function (JsdomEnvironment, tracer, config) {
-      const testEnvironmentMetadata = getTestEnvironmentMetadata('jest', config)
-
-      this.wrap(JsdomEnvironment.prototype, 'teardown', createWrapTeardown(tracer, this))
-
-      const newHandleTestEvent = createHandleTestEvent(tracer, testEnvironmentMetadata, this)
-      newHandleTestEvent._dd_original = JsdomEnvironment.prototype.handleTestEvent
-      JsdomEnvironment.prototype.handleTestEvent = newHandleTestEvent
-
-      return wrapEnvironment(JsdomEnvironment)
-    },
-    unpatch: function (JsdomEnvironment) {
-      this.unwrap(JsdomEnvironment.prototype, 'teardown')
-      JsdomEnvironment.prototype.handleTestEvent = JsdomEnvironment.prototype.handleTestEvent._dd_original
-    }
+    patch,
+    unpatch
   }
 ]

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

@@ -2,6 +2,8 @@
 
 const web = require('../../dd-trace/src/plugins/util/web')
 
+const originals = new WeakMap()
+
 function createWrapCallback (tracer, config) {
   config = web.normalizeConfig(config)
 
@@ -83,7 +85,9 @@ function wrapStack (layer) {
   layer.stack = layer.stack.map(middleware => {
     if (typeof middleware !== 'function') return middleware
 
-    middleware = middleware._dd_original || middleware
+    const original = originals.get(middleware)
+
+    middleware = original || middleware
 
     const wrappedMiddleware = wrapMiddleware(middleware)
 
@@ -96,7 +100,7 @@ function wrapStack (layer) {
       return wrappedMiddleware.apply(this, arguments)
     }
 
-    handler._dd_original = middleware
+    originals.set(handler, middleware)
 
     return handler
   })

package/packages/datadog-plugin-microgateway-core/src/index.js

@@ -84,9 +84,7 @@ function wrapPluginInit (init) {
   return function initWithTrace (config, logging, stats) {
     const handler = init.apply(this, arguments)
 
-    if (!handler._dd_patched) {
-      wrapListeners(handler)
-    }
+    wrapListeners(handler)
 
     return handler
   }

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

@@ -18,6 +18,8 @@ const {
   getTestSuitePath
 } = require('../../dd-trace/src/plugins/util/test')
 
+const skippedTests = new WeakSet()
+
 function getTestSpanMetadata (tracer, test, sourceRoot) {
   const childOf = getTestParentSpan(tracer)
 
@@ -131,12 +133,12 @@ function createWrapRunTests (tracer, testEnvironmentMetadata, sourceRoot) {
         // We call `getAllTestsInSuite` with the root suite so every skipped test
         // should already have an associated test span.
         // This function is called with every suite, so we need a way to mark
-        // the test as already accounted for. We do this through `__datadog_skipped`.
+        // the test as already accounted for. We do this through `skippedTests`.
         // If the test is already marked as skipped, we don't create an additional test span.
-        if (!isSkipped || test.__datadog_skipped) {
+        if (!isSkipped || skippedTests.has(test)) {
           return
         }
-        test.__datadog_skipped = true
+        skippedTests.add(test)
         const { childOf, resource, ...testSpanMetadata } = getTestSpanMetadata(tracer, test, sourceRoot)
 
         const testSpan = tracer

package/packages/datadog-plugin-mongodb-core/src/util.js

@@ -94,15 +94,39 @@ function getResource (ns, query, operationName) {
   return parts.join(' ')
 }
 
-function sanitize (input) {
-  const output = {}
-
-  if (!isObject(input) || Buffer.isBuffer(input) || isBSON(input)) return '?'
+function shouldHide (input) {
+  return !isObject(input) || Buffer.isBuffer(input) || isBSON(input)
+}
 
-  for (const key in input) {
-    if (typeof input[key] === 'function') continue
+function sanitize (input) {
+  if (shouldHide(input)) return '?'
 
-    output[key] = sanitize(input[key])
+  const output = {}
+  const queue = [{
+    input,
+    output,
+    depth: 0
+  }]
+
+  while (queue.length) {
+    const {
+      input, output, depth
+    } = queue.pop()
+    const nextDepth = depth + 1
+    for (const key in input) {
+      if (typeof input[key] === 'function') continue
+
+      const child = input[key]
+      if (depth >= 20 || shouldHide(child)) {
+        output[key] = '?'
+      } else {
+        queue.push({
+          input: child,
+          output: output[key] = {},
+          depth: nextDepth
+        })
+      }
+    }
   }
 
   return output

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

@@ -4,6 +4,8 @@
 
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
+const contexts = new WeakMap()
+
 function createWrapHandleRequest (tracer, config) {
   return function wrapHandleRequest (handleRequest) {
     return function handleRequestWithTrace (req, res, pathname, query) {
@@ -92,8 +94,9 @@ function getPageFromPath (page, dynamicRoutes = []) {
 
 function trace (tracer, config, req, res, handler) {
   const scope = tracer.scope()
+  const context = contexts.get(req)
 
-  if (req._datadog_next) return scope.activate(req._datadog_next.span, handler)
+  if (context) return scope.activate(context.span, handler)
 
   const childOf = scope.active()
   const tags = {
@@ -107,7 +110,7 @@ function trace (tracer, config, req, res, handler) {
 
   analyticsSampler.sample(span, config.measured, true)
 
-  req._datadog_next = { span }
+  contexts.set(req, { span })
 
   const promise = scope.activate(span, handler)
 
@@ -124,9 +127,11 @@ function trace (tracer, config, req, res, handler) {
 }
 
 function addPage (req, page) {
-  if (!req || !req._datadog_next) return
+  const context = contexts.get(req)
+
+  if (!context) return
 
-  req._datadog_next.span.addTags({
+  context.span.addTags({
     'resource.name': `${req.method} ${page}`.trim(),
     'next.page': page
   })

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

@@ -2,10 +2,13 @@
 
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
+const connectionAttributes = new WeakMap()
+const poolAttributes = new WeakMap()
+
 function createWrapExecute (tracer, config) {
   return function wrapExecute (execute) {
     return function executeWithTrace (dbQuery, ...args) {
-      const connAttrs = this._dd_connAttrs
+      const connAttrs = connectionAttributes.get(this)
       const service = getServiceName(tracer, config, connAttrs)
       const connectStringObj = new URL('http://' + connAttrs.connectString)
       const tags = {
@@ -37,7 +40,7 @@ function createWrapGetConnection (tracer, config) {
       if (callback) {
         arguments[1] = (err, connection) => {
           if (connection) {
-            connection._dd_connAttrs = connAttrs
+            connectionAttributes.set(connection, connAttrs)
           }
           callback(err, connection)
         }
@@ -45,7 +48,7 @@ function createWrapGetConnection (tracer, config) {
         getConnection.apply(this, arguments)
       } else {
         return getConnection.apply(this, arguments).then((connection) => {
-          connection._dd_connAttrs = connAttrs
+          connectionAttributes.set(connection, connAttrs)
           return connection
         })
       }
@@ -59,7 +62,7 @@ function createWrapCreatePool (tracer, config) {
       if (callback) {
         arguments[1] = (err, pool) => {
           if (pool) {
-            pool._dd_poolAttrs = poolAttrs
+            poolAttributes.set(pool, poolAttrs)
           }
           callback(err, pool)
         }
@@ -67,7 +70,7 @@ function createWrapCreatePool (tracer, config) {
         createPool.apply(this, arguments)
       } else {
         return createPool.apply(this, arguments).then((pool) => {
-          pool._dd_poolAttrs = poolAttrs
+          poolAttributes.set(pool, poolAttrs)
           return pool
         })
       }
@@ -85,14 +88,14 @@ function createWrapPoolGetConnection (tracer, config) {
       if (callback) {
         arguments[arguments.length - 1] = (err, connection) => {
           if (connection) {
-            connection._dd_connAttrs = this._dd_poolAttrs
+            connectionAttributes.set(connection, poolAttributes.get(this))
           }
           callback(err, connection)
         }
         getConnection.apply(this, arguments)
       } else {
         return getConnection.apply(this, arguments).then((connection) => {
-          connection._dd_connAttrs = this._dd_poolAttrs
+          connectionAttributes.set(connection, poolAttributes.get(this))
           return connection
         })
       }

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

@@ -1,164 +1,11 @@
 'use strict'
 
-const { LOG } = require('../../../ext/formats')
+const LogPlugin = require('../../dd-trace/src/plugins/log_plugin')
 
-function createWrapPino (tracer, config, symbol, wrapper) {
-  return function wrapPino (pino) {
-    return function pinoWithTrace () {
-      const instance = pino.apply(this, arguments)
-
-      Object.defineProperty(instance, symbol, {
-        configurable: true,
-        enumerable: true,
-        writable: true,
-        value: wrapper(tracer, config)(instance[symbol])
-      })
-
-      return instance
-    }
+class PinoPlugin extends LogPlugin {
+  static get name () {
+    return 'pino'
   }
 }
 
-function createWrapAsJson (tracer, config) {
-  return function wrapAsJson (asJson) {
-    return function asJsonWithTrace (obj, msg, num, time) {
-      const span = tracer.scope().active()
-
-      obj = arguments[0] = obj || {}
-
-      tracer.inject(span, LOG, obj)
-
-      const json = asJson.apply(this, arguments)
-
-      obj && delete obj.dd
-
-      return json
-    }
-  }
-}
-
-function createWrapMixin (tracer, config) {
-  return function wrapMixin (mixin) {
-    return function mixinWithTrace () {
-      let obj = {}
-
-      if (mixin) {
-        obj = mixin.apply(this, arguments)
-      }
-
-      const span = tracer.scope().active()
-
-      tracer.inject(span, LOG, obj)
-
-      return obj
-    }
-  }
-}
-
-function createWrapPrettifyObject (tracer, config) {
-  return function wrapPrettifyObject (prettifyObject) {
-    return function prettifyObjectWithTrace (input) {
-      const span = tracer.scope().active()
-
-      tracer.inject(span, LOG, input.input)
-
-      return prettifyObject.apply(this, arguments)
-    }
-  }
-}
-
-function createWrapPrettyFactory (tracer, config) {
-  return function wrapPrettyFactory (prettyFactory) {
-    return function prettyFactoryWithTrace () {
-      const pretty = prettyFactory.apply(this, arguments)
-
-      return function prettyWithTrace (obj) {
-        const span = tracer.scope().active()
-
-        tracer.inject(span, LOG, obj)
-
-        return pretty.apply(this, arguments)
-      }
-    }
-  }
-}
-
-module.exports = [
-  {
-    name: 'pino',
-    versions: ['2 - 3', '4', '>=5 <5.14.0'],
-    patch (pino, tracer, config) {
-      if (!tracer._logInjection) return
-
-      const asJsonSym = (pino.symbols && pino.symbols.asJsonSym) || 'asJson'
-
-      return this.wrapExport(pino, createWrapPino(tracer, config, asJsonSym, createWrapAsJson)(pino))
-    },
-    unpatch (pino) {
-      return this.unwrapExport(pino)
-    }
-  },
-  {
-    name: 'pino',
-    versions: ['>=5.14.0 <6.8.0'],
-    patch (pino, tracer, config) {
-      if (!tracer._logInjection) return
-
-      const mixinSym = pino.symbols.mixinSym
-
-      return this.wrapExport(pino, createWrapPino(tracer, config, mixinSym, createWrapMixin)(pino))
-    },
-    unpatch (pino) {
-      return this.unwrapExport(pino)
-    }
-  },
-  {
-    name: 'pino',
-    versions: ['>=6.8.0'],
-    patch (pino, tracer, config) {
-      if (!tracer._logInjection) return
-
-      const mixinSym = pino.symbols.mixinSym
-
-      const wrapped = this.wrapExport(pino, createWrapPino(tracer, config, mixinSym, createWrapMixin)(pino))
-
-      wrapped.pino = wrapped
-      wrapped.default = wrapped
-
-      return wrapped
-    },
-    unpatch (pino) {
-      const unwrapped = this.unwrapExport(pino)
-
-      unwrapped.pino = unwrapped
-      unwrapped.default = unwrapped
-
-      return unwrapped
-    }
-  },
-  {
-    name: 'pino-pretty',
-    versions: ['>=3'], // will only work starting from pino@5.0.0 as previous versions are not using pino-pretty
-    file: 'lib/utils.js',
-    patch (utils, tracer, config) {
-      if (!tracer._logInjection) return
-
-      this.wrap(utils, 'prettifyObject', createWrapPrettifyObject(tracer, config))
-    },
-    unpatch (utils) {
-      this.unwrap(utils, 'prettifyObject')
-    }
-  },
-  {
-    name: 'pino-pretty',
-    versions: ['1 - 2'],
-    patch (prettyFactory, tracer, config) {
-      if (!tracer._logInjection) return
-
-      return this.wrapExport(prettyFactory, createWrapPrettyFactory(tracer, config)(prettyFactory))
-    },
-    unpatch (prettyFactory) {
-      return this.unwrapExport(prettyFactory)
-    }
-  }
-]
+module.exports = PinoPlugin