dd-trace 2.10.0 → 2.12.1

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

@@ -0,0 +1,250 @@
+'use strict'
+
+const types = require('./types')
+const { addHook, channel, AsyncResource } = require('../helpers/instrument')
+const shimmer = require('../../../datadog-shimmer')
+
+const patched = new WeakSet()
+const instances = new WeakMap()
+
+const startChannel = channel('apm:grpc:client:request:start')
+const errorChannel = channel('apm:grpc:client:request:error')
+const finishChannel = channel('apm:grpc:client:request:finish')
+
+function createWrapMakeRequest (type) {
+  return function wrapMakeRequest (makeRequest) {
+    return function (path) {
+      const args = ensureMetadata(this, arguments, 4)
+
+      return callMethod(this, makeRequest, args, path, args[4], type)
+    }
+  }
+}
+
+function createWrapLoadPackageDefinition () {
+  return function wrapLoadPackageDefinition (loadPackageDefinition) {
+    return function (packageDef) {
+      const result = loadPackageDefinition.apply(this, arguments)
+
+      if (!result) return result
+
+      wrapPackageDefinition(result)
+
+      return result
+    }
+  }
+}
+
+function createWrapMakeClientConstructor () {
+  return function wrapMakeClientConstructor (makeClientConstructor) {
+    return function (methods) {
+      const ServiceClient = makeClientConstructor.apply(this, arguments)
+
+      wrapClientConstructor(ServiceClient, methods)
+
+      return ServiceClient
+    }
+  }
+}
+
+function wrapPackageDefinition (def) {
+  for (const name in def) {
+    if (def[name].format) continue
+    if (def[name].service && def[name].prototype) {
+      wrapClientConstructor(def[name], def[name].service)
+    } else {
+      wrapPackageDefinition(def[name])
+    }
+  }
+}
+
+function wrapClientConstructor (ServiceClient, methods) {
+  const proto = ServiceClient.prototype
+
+  if (typeof methods !== 'object' || 'format' in methods) return
+
+  Object.keys(methods)
+    .forEach(name => {
+      if (!methods[name]) return
+
+      const originalName = methods[name].originalName
+      const path = methods[name].path
+      const type = getType(methods[name])
+
+      if (methods[name]) {
+        proto[name] = wrapMethod(proto[name], path, type)
+      }
+
+      if (originalName) {
+        proto[originalName] = wrapMethod(proto[originalName], path, type)
+      }
+    })
+}
+
+function wrapMethod (method, path, type) {
+  if (typeof method !== 'function' || patched.has(method)) {
+    return method
+  }
+
+  const wrapped = function () {
+    const args = ensureMetadata(this, arguments, 1)
+
+    return callMethod(this, method, args, path, args[1], type)
+  }
+
+  Object.assign(wrapped, method)
+
+  patched.add(wrapped)
+
+  return wrapped
+}
+
+function wrapCallback (requestResource, parentResource, callback) {
+  return function (err) {
+    if (err) {
+      requestResource.runInAsyncScope(() => {
+        errorChannel.publish(err)
+      })
+    }
+
+    if (callback) {
+      return parentResource.runInAsyncScope(() => {
+        return callback.apply(this, arguments)
+      })
+    }
+  }
+}
+
+function wrapStream (call, requestResource, parentResource) {
+  if (!call || typeof call.emit !== 'function') return
+
+  shimmer.wrap(call, 'emit', emit => {
+    return function (eventName, ...args) {
+      requestResource.runInAsyncScope(() => {
+        switch (eventName) {
+          case 'error':
+            errorChannel.publish(args[0])
+
+            break
+          case 'status':
+            finishChannel.publish(args[0])
+
+            break
+        }
+      })
+
+      return parentResource.runInAsyncScope(() => {
+        return emit.apply(this, arguments)
+      })
+    }
+  })
+}
+
+function callMethod (client, method, args, path, metadata, type) {
+  if (!startChannel.hasSubscribers) return method.apply(client, args)
+
+  const length = args.length
+  const callback = args[length - 1]
+  const parentResource = new AsyncResource('bound-anonymous-fn')
+  const requestResource = new AsyncResource('bound-anonymous-fn')
+
+  return requestResource.runInAsyncScope(() => {
+    startChannel.publish({ metadata, path, type })
+
+    if (type === types.unary || type === types.client_stream) {
+      if (typeof callback === 'function') {
+        args[length - 1] = wrapCallback(requestResource, parentResource, callback)
+      } else {
+        args[length] = wrapCallback(requestResource, parentResource)
+      }
+    }
+
+    const call = method.apply(client, args)
+
+    wrapStream(call, requestResource, parentResource)
+
+    return call
+  })
+}
+
+function ensureMetadata (client, args, index) {
+  const grpc = getGrpc(client)
+
+  if (!client || !grpc) return args
+
+  const meta = args[index]
+  const normalized = []
+
+  for (let i = 0; i < index; i++) {
+    normalized.push(args[i])
+  }
+
+  if (!meta || !meta.constructor || meta.constructor.name !== 'Metadata') {
+    normalized.push(new grpc.Metadata())
+  }
+
+  if (meta) {
+    normalized.push(meta)
+  }
+
+  for (let i = index + 1; i < args.length; i++) {
+    normalized.push(args[i])
+  }
+
+  return normalized
+}
+
+function getType (definition) {
+  if (definition.requestStream) {
+    if (definition.responseStream) {
+      return types.bidi
+    }
+
+    return types.client_stream
+  }
+
+  if (definition.responseStream) {
+    return types.server_stream
+  }
+
+  return types.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) {
+  const proto = grpc.Client.prototype
+
+  instances.set(proto, grpc)
+
+  shimmer.wrap(proto, 'makeBidiStreamRequest', createWrapMakeRequest(types.bidi))
+  shimmer.wrap(proto, 'makeClientStreamRequest', createWrapMakeRequest(types.clientStream))
+  shimmer.wrap(proto, 'makeServerStreamRequest', createWrapMakeRequest(types.serverStream))
+  shimmer.wrap(proto, 'makeUnaryRequest', createWrapMakeRequest(types.unary))
+
+  return grpc
+}
+
+addHook({ name: 'grpc', versions: ['>=1.20.2'] }, patch)
+
+addHook({ name: 'grpc', versions: ['>=1.20.2'], file: 'src/client.js' }, client => {
+  shimmer.wrap(client, 'makeClientConstructor', createWrapMakeClientConstructor())
+
+  return client
+})
+
+addHook({ name: '@grpc/grpc-js', versions: ['>=1.0.3'] }, patch)
+
+addHook({ name: '@grpc/grpc-js', versions: ['>=1.0.3'], file: 'build/src/make-client.js' }, client => {
+  shimmer.wrap(client, 'makeClientConstructor', createWrapMakeClientConstructor())
+  shimmer.wrap(client, 'loadPackageDefinition', createWrapLoadPackageDefinition())
+
+  return client
+})

package/packages/datadog-instrumentations/src/grpc/server.js

@@ -0,0 +1,144 @@
+'use strict'
+
+const types = require('./types')
+const { channel, addHook, AsyncResource } = require('../helpers/instrument')
+const shimmer = require('../../../datadog-shimmer')
+
+const startChannel = channel('apm:grpc:server:request:start')
+const errorChannel = channel('apm:grpc:server:request:error')
+const updateChannel = channel('apm:grpc:server:request:update')
+const finishChannel = channel('apm:grpc:server:request:finish')
+
+// https://github.com/grpc/grpc/blob/master/doc/statuscodes.md
+const OK = 0
+const CANCELLED = 1
+
+function wrapHandler (func, name) {
+  const isValid = (server, args) => {
+    if (!startChannel.hasSubscribers) return false
+    if (!server || !server.type) return false
+    if (!args[0]) return false
+    if (server.type !== 'unary' && !isEmitter(args[0])) return false
+    if (server.type === 'unary' && typeof args[1] !== 'function') return false
+
+    return true
+  }
+
+  return function (call, callback) {
+    if (!isValid(this, arguments)) return func.apply(this, arguments)
+
+    const metadata = call.metadata
+    const type = types[this.type]
+    const isStream = type !== 'unary'
+
+    const parentResource = new AsyncResource('bound-anonymous-fn')
+    const requestResource = new AsyncResource('bound-anonymous-fn')
+
+    return requestResource.runInAsyncScope(() => {
+      startChannel.publish({ name, metadata, type })
+
+      // Finish the span if the call was cancelled.
+      call.once('cancelled', requestResource.bind(() => {
+        finishChannel.publish({ code: CANCELLED })
+      }))
+
+      if (isStream) {
+        wrapStream(call, requestResource, parentResource)
+      } else {
+        arguments[1] = wrapCallback(callback, requestResource, parentResource)
+      }
+
+      shimmer.wrap(call, 'emit', emit => requestResource.bind(emit))
+
+      return func.apply(this, arguments)
+    })
+  }
+}
+
+function wrapRegister (register) {
+  return function (name, handler, serialize, deserialize, type) {
+    if (typeof handler === 'function') {
+      arguments[1] = wrapHandler(handler, name)
+    }
+
+    return register.apply(this, arguments)
+  }
+}
+
+function wrapStream (call, requestResource) {
+  if (call.call && call.call.sendStatus) {
+    call.call.sendStatus = wrapSendStatus(call.call.sendStatus, requestResource)
+  }
+
+  shimmer.wrap(call, 'emit', emit => {
+    return function (eventName, ...args) {
+      switch (eventName) {
+        case 'error':
+          errorChannel.publish(args[0])
+          finishChannel.publish({ code: args[0].code })
+
+          break
+
+          // Finish the span of the response only if it was successful.
+          // Otherwise it'll be finished in the `error` listener.
+        case 'finish':
+          if (call.status) {
+            updateChannel.publish(call.status)
+          }
+
+          if (!call.status || call.status.code === 0) {
+            finishChannel.publish()
+          }
+
+          break
+      }
+
+      return emit.apply(this, arguments)
+    }
+  })
+}
+
+function wrapCallback (callback, requestResource, parentResource) {
+  return function (err, value, trailer, flags) {
+    requestResource.runInAsyncScope(() => {
+      if (err instanceof Error) {
+        errorChannel.publish(err)
+        finishChannel.publish(err)
+      } else {
+        finishChannel.publish({ code: OK, trailer })
+      }
+    })
+
+    if (callback) {
+      return parentResource.runInAsyncScope(() => {
+        return callback.apply(this, arguments)
+      })
+    }
+  }
+}
+
+function wrapSendStatus (sendStatus, requestResource) {
+  return function (status) {
+    requestResource.runInAsyncScope(() => {
+      updateChannel.publish(status)
+    })
+
+    return sendStatus.apply(this, arguments)
+  }
+}
+
+function isEmitter (obj) {
+  return typeof obj.emit === 'function' && typeof obj.once === 'function'
+}
+
+addHook({ name: 'grpc', versions: ['>=1.20.2'], file: 'src/server.js' }, server => {
+  shimmer.wrap(server.Server.prototype, 'register', wrapRegister)
+
+  return server
+})
+
+addHook({ name: '@grpc/grpc-js', versions: ['>=1.0.3'], file: 'build/src/server.js' }, server => {
+  shimmer.wrap(server.Server.prototype, 'register', wrapRegister)
+
+  return server
+})

package/packages/datadog-instrumentations/src/grpc.js

@@ -0,0 +1,4 @@
+'use strict'
+
+require('./grpc/client')
+require('./grpc/server')

package/packages/datadog-instrumentations/src/http2/client.js

@@ -0,0 +1,67 @@
+'use strict'
+
+const shimmer = require('../../../datadog-shimmer')
+const { addHook, channel, AsyncResource } = require('../helpers/instrument')
+
+const startChannel = channel('apm:http2:client:request:start')
+const finishChannel = channel('apm:http2:client:request:finish')
+const errorChannel = channel('apm:http2:client:request:error')
+const responseChannel = channel('apm:http2:client:response')
+
+function createWrapEmit (requestResource, parentResource) {
+  return function wrapEmit (emit) {
+    return function (event, arg1) {
+      requestResource.runInAsyncScope(() => {
+        switch (event) {
+          case 'response':
+            responseChannel.publish(arg1)
+            break
+          case 'error':
+            errorChannel.publish(arg1)
+          case 'close': // eslint-disable-line no-fallthrough
+            finishChannel.publish()
+            break
+        }
+      })
+
+      return parentResource.runInAsyncScope(() => {
+        return emit.apply(this, arguments)
+      })
+    }
+  }
+}
+
+function createWrapRequest (authority, options) {
+  return function wrapRequest (request) {
+    return function (headers) {
+      const parentResource = new AsyncResource('bound-anonymous-fn')
+      const requestResource = new AsyncResource('bound-anonymous-fn')
+
+      return requestResource.runInAsyncScope(() => {
+        startChannel.publish({ headers, authority, options })
+
+        const req = request.apply(this, arguments)
+
+        shimmer.wrap(req, 'emit', createWrapEmit(requestResource, parentResource))
+
+        return req
+      })
+    }
+  }
+}
+
+function wrapConnect (connect) {
+  return function (authority, options) {
+    const session = connect.apply(this, arguments)
+
+    shimmer.wrap(session, 'request', createWrapRequest(authority, options))
+
+    return session
+  }
+}
+
+addHook({ name: 'http2' }, http2 => {
+  shimmer.wrap(http2, 'connect', wrapConnect)
+
+  return http2
+})

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

@@ -0,0 +1,3 @@
+'use strict'
+
+// Instrumentation temporarily disabled. See https://github.com/DataDog/dd-trace-js/issues/312

package/packages/datadog-instrumentations/src/http2.js

@@ -0,0 +1,4 @@
+'use strict'
+
+require('./http2/client')
+require('./http2/server')

package/packages/datadog-instrumentations/src/koa.js

@@ -4,6 +4,7 @@ const shimmer = require('../../datadog-shimmer')
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 
 const enterChannel = channel('apm:koa:middleware:enter')
+const exitChannel = channel('apm:koa:middleware:exit')
 const errorChannel = channel('apm:koa:middleware:error')
 const nextChannel = channel('apm:koa:middleware:next')
 const handleChannel = channel('apm:koa:request:handle')
@@ -95,7 +96,7 @@ function wrapMiddleware (fn, layer) {
       enterChannel.publish({ req, name, route })
 
       if (typeof next === 'function') {
-        arguments[1] = next
+        arguments[1] = wrapNext(req, next)
       }
 
       try {
@@ -125,19 +126,27 @@ function wrapMiddleware (fn, layer) {
 }
 
 function fulfill (ctx, error) {
-  if (error) {
-    errorChannel.publish(error)
-  }
-
   const req = ctx.req
   const route = ctx.routePath
 
+  if (error) {
+    errorChannel.publish({ req, error })
+  }
+
   // TODO: make sure that the parent class cannot override this in `enter`
   if (route) {
     routeChannel.publish({ req, route })
   }
 
-  nextChannel.publish(ctx)
+  exitChannel.publish({ req })
+}
+
+function wrapNext (req, next) {
+  return function () {
+    nextChannel.publish({ req })
+
+    return next.apply(null, arguments)
+  }
 }
 
 addHook({ name: 'koa', versions: ['>=2'] }, Koa => {

package/packages/datadog-instrumentations/src/microgateway-core.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+
+const handleChannel = channel('apm:microgateway-core:request:handle')
+const routeChannel = channel('apm:microgateway-core:request:route')
+const errorChannel = channel('apm:microgateway-core:request:error')
+
+const name = 'microgateway-core'
+const versions = ['>=2.1']
+const requestResources = new WeakMap()
+
+function wrapConfigProxyFactory (configProxyFactory) {
+  return function () {
+    const configProxy = configProxyFactory.apply(this, arguments)
+
+    return function (req, res, next) {
+      const requestResource = new AsyncResource('bound-anonymous-fn')
+
+      requestResources.set(req, requestResource)
+
+      handleChannel.publish({ req, res })
+
+      return configProxy.apply(this, arguments)
+    }
+  }
+}
+
+function wrapPluginsFactory (pluginsFactory) {
+  return function (plugins) {
+    const pluginsMiddleware = pluginsFactory.apply(this, arguments)
+
+    return function pluginsMiddlewareWithTrace (req, res, next) {
+      arguments[2] = wrapNext(req, res, next)
+
+      return pluginsMiddleware.apply(this, arguments)
+    }
+  }
+}
+
+function wrapNext (req, res, next) {
+  return function nextWithTrace (err) {
+    const requestResource = requestResources.get(req)
+
+    requestResource.runInAsyncScope(() => {
+      if (err) {
+        errorChannel.publish(err)
+      }
+
+      if (res.proxy && res.proxy.base_path) {
+        routeChannel.publish({ req, res, route: res.proxy.base_path })
+      }
+    })
+
+    return next.apply(this, arguments)
+  }
+}
+
+addHook({ name, versions, file: 'lib/config-proxy-middleware.js' }, configProxyFactory => {
+  return shimmer.wrap(configProxyFactory, wrapConfigProxyFactory(configProxyFactory))
+})
+
+addHook({ name, versions, file: 'lib/plugins-middleware.js' }, pluginsFactory => {
+  return shimmer.wrap(pluginsFactory, wrapPluginsFactory(pluginsFactory))
+})