dd-trace 2.2.0 → 2.2.1

package/packages/datadog-plugin-google-cloud-pubsub/src/index.js

@@ -2,6 +2,8 @@
 
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
+const messageSpans = new WeakMap()
+
 function createWrapRequest (tracer, config) {
   return function wrapRequest (request) {
     return function requestWithTrace (cfg = { reqOpts: {} }, cb) {
@@ -45,11 +47,11 @@ function createWrapRequest (tracer, config) {
 function createWrapSubscriptionEmit (tracer, config) {
   return function wrapSubscriptionEmit (emit) {
     return function emitWithTrace (eventName, message) {
-      if (eventName !== 'message' || !message || !message._datadog_span) {
-        return emit.apply(this, arguments)
-      }
+      if (eventName !== 'message' || !message) return emit.apply(this, arguments)
+
+      const span = messageSpans.get(message)
 
-      const span = message._datadog_span
+      if (!span) return emit.apply(this, arguments)
 
       return tracer.scope().activate(span, () => {
         try {
@@ -83,7 +85,7 @@ function createWrapLeaseDispense (tracer, config) {
 
       analyticsSampler.sample(span, config.measured, true)
 
-      message._datadog_span = span
+      messageSpans.set(message, span)
 
       return dispense.apply(this, arguments)
     }
@@ -119,7 +121,7 @@ function getTopic (cfg) {
 }
 
 function finish (message) {
-  const span = message._datadog_span
+  const span = messageSpans.get(message)
 
   if (!span) return
 

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

@@ -4,6 +4,11 @@ const pick = require('lodash.pick')
 const log = require('../../dd-trace/src/log')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
+const contexts = new WeakMap()
+const documentSources = new WeakMap()
+const patchedTypes = new WeakSet()
+const patchedResolvers = new WeakSet()
+
 let tools
 
 function createWrapExecute (tracer, config, defaultFieldResolver) {
@@ -12,11 +17,11 @@ function createWrapExecute (tracer, config, defaultFieldResolver) {
       const args = normalizeArgs(arguments, tracer, config, defaultFieldResolver)
       const schema = args.schema
       const document = args.document
-      const source = document && document._datadog_source
+      const source = documentSources.get(document)
       const contextValue = args.contextValue
       const operation = getOperation(document, args.operationName)
 
-      if (contextValue._datadog_graphql) {
+      if (contexts.has(contextValue)) {
         return execute.apply(this, arguments)
       }
 
@@ -26,11 +31,12 @@ function createWrapExecute (tracer, config, defaultFieldResolver) {
       }
 
       const span = startExecutionSpan(tracer, config, operation, args)
+      const context = { source, span, fields: {} }
 
-      contextValue._datadog_graphql = { source, span, fields: {} }
+      contexts.set(contextValue, context)
 
       return call(execute, span, this, arguments, (err, res) => {
-        finishResolvers(contextValue, config)
+        finishResolvers(context)
 
         setError(span, err || (res && res.errors && res.errors[0]))
         config.hooks.execute(span, args, res)
@@ -55,7 +61,7 @@ function createWrapParse (tracer, config) {
         if (!operation) return document // skip schema parsing
 
         if (source) {
-          document._datadog_source = source.body || source
+          documentSources.set(document, source.body || source)
         }
 
         addDocumentTags(span, document, config)
@@ -103,11 +109,11 @@ function createWrapValidate (tracer, config) {
 }
 
 function wrapFields (type, tracer, config) {
-  if (!type || !type._fields || type._datadog_patched) {
+  if (!type || !type._fields || patchedTypes.has(type)) {
     return
   }
 
-  type._datadog_patched = true
+  patchedTypes.add(type)
 
   Object.keys(type._fields).forEach(key => {
     const field = type._fields[key]
@@ -136,14 +142,16 @@ function wrapFieldType (field, tracer, config) {
 }
 
 function wrapResolve (resolve, tracer, config) {
-  if (resolve._datadog_patched || typeof resolve !== 'function') return resolve
+  if (typeof resolve !== 'function' || patchedResolvers.has(resolve)) return resolve
 
   const responsePathAsArray = config.collapse
     ? withCollapse(pathToArray)
     : pathToArray
 
   function resolveWithTrace (source, args, contextValue, info) {
-    if (!contextValue._datadog_graphql) return resolve.apply(this, arguments)
+    const context = contexts.get(contextValue)
+
+    if (!context) return resolve.apply(this, arguments)
 
     const path = responsePathAsArray(info && info.path)
 
@@ -151,18 +159,18 @@ function wrapResolve (resolve, tracer, config) {
       const depth = path.filter(item => typeof item === 'string').length
 
       if (config.depth < depth) {
-        const parent = getParentField(tracer, contextValue, path)
+        const parent = getParentField(tracer, context, path)
 
         return call(resolve, parent.span, this, arguments)
       }
     }
 
-    const field = assertField(tracer, config, contextValue, info, path)
+    const field = assertField(tracer, config, context, info, path)
 
     return call(resolve, field.span, this, arguments, err => updateField(field, err))
   }
 
-  resolveWithTrace._datadog_patched = true
+  patchedResolvers.add(resolveWithTrace)
 
   return resolveWithTrace
 }
@@ -191,9 +199,9 @@ function call (fn, span, thisArg, args, callback) {
   }
 }
 
-function getParentField (tracer, contextValue, path) {
+function getParentField (tracer, context, path) {
   for (let i = path.length - 1; i > 0; i--) {
-    const field = getField(contextValue, path.slice(0, i))
+    const field = getField(context, path.slice(0, i))
 
     if (field) {
       return field
@@ -201,12 +209,12 @@ function getParentField (tracer, contextValue, path) {
   }
 
   return {
-    span: contextValue._datadog_graphql.span
+    span: context.span
   }
 }
 
-function getField (contextValue, path) {
-  return contextValue._datadog_graphql.fields[path.join('.')]
+function getField (context, path) {
+  return context.fields[path.join('.')]
 }
 
 function normalizeArgs (args, tracer, config, defaultFieldResolver) {
@@ -267,8 +275,8 @@ function addExecutionTags (span, config, operation, document, operationName) {
 function addDocumentTags (span, document, config) {
   const tags = {}
 
-  if (config.source && document && document._datadog_source) {
-    tags['graphql.source'] = document._datadog_source
+  if (config.source && document) {
+    tags['graphql.source'] = documentSources.get(document)
   }
 
   span.addTags(tags)
@@ -300,9 +308,9 @@ function startSpan (tracer, config, name, options) {
   })
 }
 
-function startResolveSpan (tracer, config, childOf, path, info, contextValue) {
+function startResolveSpan (tracer, config, childOf, path, info, { source }) {
   const span = startSpan(tracer, config, 'resolve', { childOf })
-  const document = contextValue._datadog_graphql.source
+  const document = source
   const fieldNode = info.fieldNodes.find(fieldNode => fieldNode.kind === 'Field')
 
   analyticsSampler.sample(span, config.measured)
@@ -345,9 +353,7 @@ function finish (span, finishTime) {
   span.finish(finishTime)
 }
 
-function finishResolvers (contextValue) {
-  const fields = contextValue._datadog_graphql.fields
-
+function finishResolvers ({ fields }) {
   Object.keys(fields).reverse().forEach(key => {
     const field = fields[key]
 
@@ -369,18 +375,18 @@ function withCollapse (responsePathAsArray) {
   }
 }
 
-function assertField (tracer, config, contextValue, info, path) {
+function assertField (tracer, config, context, info, path) {
   const pathString = path.join('.')
-  const fields = contextValue._datadog_graphql.fields
+  const fields = context.fields
 
   let field = fields[pathString]
 
   if (!field) {
-    const parent = getParentField(tracer, contextValue, path)
+    const parent = getParentField(tracer, context, path)
 
     field = fields[pathString] = {
       parent,
-      span: startResolveSpan(tracer, config, parent.span, path, info, contextValue),
+      span: startResolveSpan(tracer, config, parent.span, path, info, context),
       error: null
     }
   }

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