dd-trace 2.10.0 → 2.11.0

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

@@ -1,218 +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')
 const Tags = require('../../../ext/tags')
 const { TEXT_MAP } = require('../../../ext/formats')
-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')
-
-  return function wrapMakeRequest (makeRequest) {
-    return function makeRequestWithTrace (path) {
-      const args = ensureMetadata(this, arguments, 4)
-
-      return callMethod(tracer, config, this, makeRequest, args, path, args[4], methodKind, filter)
-    }
-  }
-}
+class GrpcClientPlugin extends Plugin {
+  static get name () {
+    return 'grpc'
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:grpc:client:request:start', ({ metadata, path, type }) => {
+      const metadataFilter = this.config.metadataFilter
+      const store = storage.getStore()
+      const childOf = store && store.span
+      const span = this.tracer.startSpan('grpc.request', {
+        childOf,
+        tags: {
+          [Tags.SPAN_KIND]: 'client',
+          'span.type': 'http',
+          'resource.name': path,
+          'service.name': this.config.service || `${this.tracer._service}-grpc-client`,
+          'component': 'grpc'
+        }
+      })
 
-function createWrapLoadPackageDefinition (tracer, config) {
-  return function wrapLoadPackageDefinition (loadPackageDefinition) {
-    return function loadPackageDefinitionWithTrace (packageDef) {
-      const result = loadPackageDefinition.apply(this, arguments)
+      addMethodTags(span, path, type)
 
-      if (!result) return result
+      if (metadata) {
+        addMetadataTags(span, metadata, metadataFilter, 'request')
+        inject(this.tracer, span, metadata)
+      }
 
-      wrapPackageDefinition(tracer, config, result)
+      analyticsSampler.sample(span, this.config.measured)
 
-      return result
-    }
-  }
-}
+      this.enter(span, store)
+    })
 
-function createWrapMakeClientConstructor (tracer, config) {
-  return function wrapMakeClientConstructor (makeClientConstructor) {
-    return function makeClientConstructorWithTrace (methods) {
-      const ServiceClient = makeClientConstructor.apply(this, arguments)
+    this.addSub('apm:grpc:client:request:error', error => {
+      const store = storage.getStore()
 
-      wrapClientConstructor(tracer, config, ServiceClient, methods)
+      if (!store || !store.span) return
 
-      return ServiceClient
-    }
-  }
-}
-
-function wrapPackageDefinition (tracer, config, def) {
-  for (const name in def) {
-    if (def[name].format) continue
-    if (def[name].service && def[name].prototype) {
-      wrapClientConstructor(tracer, config, def[name], def[name].service)
-    } else {
-      wrapPackageDefinition(tracer, config, def[name])
-    }
-  }
-}
+      this.addCode(store.span, error.code)
+      this.addError(error)
+    })
 
-function wrapClientConstructor (tracer, config, ServiceClient, methods) {
-  const proto = ServiceClient.prototype
+    this.addSub('apm:grpc:client:request:finish', ({ code, metadata }) => {
+      const store = storage.getStore()
 
-  if (typeof methods !== 'object' || 'format' in methods) return
+      if (!store || !store.span) return
 
-  Object.keys(methods)
-    .forEach(name => {
-      if (!methods[name]) return
+      const span = store.span
+      const metadataFilter = this.config.metadataFilter
 
-      const originalName = methods[name].originalName
-      const path = methods[name].path
-      const methodKind = getMethodKind(methods[name])
+      this.addCode(span, code)
 
-      if (methods[name]) {
-        proto[name] = wrapMethod(tracer, config, proto[name], path, methodKind)
+      if (metadata && metadataFilter) {
+        addMetadataTags(span, metadata, metadataFilter, 'response')
       }
 
-      if (originalName) {
-        proto[originalName] = wrapMethod(tracer, config, proto[originalName], path, methodKind)
-      }
+      store.span.finish()
     })
-}
-
-function wrapMethod (tracer, config, method, path, methodKind) {
-  if (typeof method !== 'function' || patched.has(method)) {
-    return method
   }
 
-  const filter = getFilter(config, 'metadata')
-
-  const methodWithTrace = function methodWithTrace () {
-    const args = ensureMetadata(this, arguments, 1)
-
-    return callMethod(tracer, config, this, method, args, path, args[1], methodKind, filter)
-  }
-
-  Object.assign(methodWithTrace, method)
-
-  patched.add(methodWithTrace)
-
-  return methodWithTrace
-}
-
-function wrapCallback (span, callback) {
-  const scope = span.tracer().scope()
-  const parent = scope.active()
-
-  return function (err) {
-    err && span.setTag(ERROR, err)
-
-    if (callback) {
-      return scope.bind(callback, parent).apply(this, arguments)
-    }
-  }
-}
-
-function wrapStream (span, call, filter) {
-  if (!call || typeof call.emit !== 'function') return
-
-  const emit = call.emit
-
-  call.emit = function (eventName, ...args) {
-    switch (eventName) {
-      case 'error':
-        span.setTag(ERROR, args[0] || 1)
-
-        break
-      case 'status':
-        if (args[0]) {
-          span.setTag('grpc.status.code', args[0].code)
-
-          addMetadataTags(span, args[0].metadata, filter, 'response')
-        }
-
-        span.finish()
-
-        break
-    }
-
-    return emit.apply(this, arguments)
-  }
-}
-
-function callMethod (tracer, config, client, method, args, path, metadata, methodKind, filter) {
-  const length = args.length
-  const callback = args[length - 1]
-  const scope = tracer.scope()
-  const span = startSpan(tracer, config, path, methodKind)
+  configure (config) {
+    const metadataFilter = getFilter(config, 'metadata')
 
-  if (metadata) {
-    addMetadataTags(span, metadata, filter, 'request')
-    inject(tracer, span, metadata)
+    return super.configure({ ...config, metadataFilter })
   }
 
-  if (methodKind === kinds.unary || methodKind === kinds.client_stream) {
-    if (typeof callback === 'function') {
-      args[length - 1] = wrapCallback(span, callback)
-    } else {
-      args[length] = wrapCallback(span)
+  addCode (span, code) {
+    if (code !== undefined) {
+      span.setTag('grpc.status.code', code)
     }
   }
-
-  const call = scope.bind(method, span).apply(client, args)
-
-  wrapStream(span, call, filter)
-
-  return scope.bind(call)
-}
-
-function startSpan (tracer, config, path, methodKind) {
-  const scope = tracer.scope()
-  const childOf = scope.active()
-  const span = tracer.startSpan('grpc.request', {
-    childOf,
-    tags: {
-      [Tags.SPAN_KIND]: 'client',
-      'span.type': 'http',
-      'resource.name': path,
-      'service.name': config.service || `${tracer._service}-grpc-client`,
-      'component': 'grpc'
-    }
-  })
-
-  analyticsSampler.sample(span, config.measured)
-  addMethodTags(span, path, methodKind)
-
-  return span
-}
-
-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 inject (tracer, span, metadata) {
@@ -227,100 +94,4 @@ function inject (tracer, span, metadata) {
   }
 }
 
-function getMethodKind (definition) {
-  if (definition.requestStream) {
-    if (definition.responseStream) {
-      return kinds.bidi
-    }
-
-    return kinds.client_stream
-  }
-
-  if (definition.responseStream) {
-    return kinds.server_stream
-  }
-
-  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
-
-  config = config.client || config
-
-  const proto = grpc.Client.prototype
-
-  instances.set(proto, grpc)
-
-  this.wrap(proto, 'makeBidiStreamRequest', createWrapMakeRequest(tracer, config, kinds.bidi))
-  this.wrap(proto, 'makeClientStreamRequest', createWrapMakeRequest(tracer, config, kinds.clientStream))
-  this.wrap(proto, 'makeServerStreamRequest', createWrapMakeRequest(tracer, config, kinds.serverStream))
-  this.wrap(proto, 'makeUnaryRequest', createWrapMakeRequest(tracer, config, kinds.unary))
-}
-
-function unpatch (grpc) {
-  const proto = grpc.Client.prototype
-
-  instances.delete(proto)
-
-  this.unwrap(proto, 'makeBidiStreamRequest')
-  this.unwrap(proto, 'makeClientStreamRequest')
-  this.unwrap(proto, 'makeServerStreamRequest')
-  this.unwrap(proto, 'makeUnaryRequest')
-}
-
-module.exports = [
-  {
-    name: 'grpc',
-    versions: ['>=1.20.2'],
-    patch,
-    unpatch
-  },
-  {
-    name: 'grpc',
-    versions: ['>=1.20.2'],
-    file: 'src/client.js',
-    patch (client, tracer, config) {
-      if (config.client === false) return
-
-      config = config.client || config
-
-      this.wrap(client, 'makeClientConstructor', createWrapMakeClientConstructor(tracer, config))
-    },
-    unpatch (client) {
-      this.unwrap(client, 'makeClientConstructor')
-    }
-  },
-  {
-    name: '@grpc/grpc-js',
-    versions: ['>=1.0.3'],
-    patch,
-    unpatch
-  },
-  {
-    name: '@grpc/grpc-js',
-    versions: ['>=1.0.3'],
-    file: 'build/src/make-client.js',
-    patch (client, tracer, config) {
-      if (config.client === false) return
-
-      config = config.client || config
-
-      this.wrap(client, 'makeClientConstructor', createWrapMakeClientConstructor(tracer, config))
-      this.wrap(client, 'loadPackageDefinition', createWrapLoadPackageDefinition(tracer, config))
-    },
-    unpatch (client) {
-      this.unwrap(client, 'makeClientConstructor')
-      this.unwrap(client, 'loadPackageDefinition')
-    }
-  }
-]
+module.exports = GrpcClientPlugin

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

@@ -1,6 +1,34 @@
 'use strict'
 
-const client = require('./client')
-const server = require('./server')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const GrpcServerPlugin = require('./server')
+const GrpcClientPlugin = require('./client')
 
-module.exports = [].concat(client, server)
+class GrpcPlugin extends Plugin {
+  static get name () {
+    return 'grpc'
+  }
+
+  constructor (...args) {
+    super(...args)
+    this.server = new GrpcServerPlugin(...args)
+    this.client = new GrpcClientPlugin(...args)
+  }
+
+  configure (config) {
+    const clientConfig = config.client === false ? false : {
+      ...config,
+      ...config.client
+    }
+
+    const serverConfig = config.server === false ? false : {
+      ...config,
+      ...config.server
+    }
+
+    this.server.configure(serverConfig)
+    this.client.configure(clientConfig)
+  }
+}
+
+module.exports = GrpcPlugin

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

@@ -1,153 +1,88 @@
 'use strict'
 
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 const Tags = require('../../../ext/tags')
 const { TEXT_MAP } = require('../../../ext/formats')
-const { ERROR } = require('../../../ext/tags')
-const kinds = require('./kinds')
 const { addMethodTags, addMetadataTags, getFilter } = require('./util')
 
-// https://github.com/grpc/grpc/blob/master/doc/statuscodes.md
-const OK = 0
-const CANCELLED = 1
-
-function createWrapHandler (tracer, config, handler) {
-  const filter = getFilter(config, 'metadata')
-
-  return function wrapHandler (func) {
-    const isValid = (server, args) => {
-      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
-    }
+class GrpcServerPlugin extends Plugin {
+  static get name () {
+    return 'http'
+  }
 
-    return function funcWithTrace (call, callback) {
-      if (!isValid(this, arguments)) return func.apply(this, arguments)
+  constructor (...args) {
+    super(...args)
 
-      const metadata = call.metadata
-      const type = this.type
-      const isStream = type !== 'unary'
-      const scope = tracer.scope()
-      const childOf = extract(tracer, metadata)
-      const span = tracer.startSpan('grpc.request', {
+    this.addSub('apm:grpc:server:request:start', ({ name, metadata, type }) => {
+      const metadataFilter = this.config.metadataFilter
+      const store = storage.getStore()
+      const childOf = extract(this.tracer, metadata)
+      const span = this.tracer.startSpan('grpc.request', {
         childOf,
         tags: {
           [Tags.SPAN_KIND]: 'server',
           'span.type': 'web',
-          'resource.name': handler,
-          'service.name': config.service || `${tracer._service}`,
+          'resource.name': name,
+          'service.name': this.config.service || `${this.tracer._service}`,
           'component': 'grpc'
         }
       })
 
-      analyticsSampler.sample(span, config.measured, true)
-      addMethodTags(span, handler, kinds[type])
-      addMetadataTags(span, metadata, filter, 'request')
+      addMethodTags(span, name, type)
+      addMetadataTags(span, metadata, metadataFilter, 'request')
 
-      scope.bind(call)
+      analyticsSampler.sample(span, this.config.measured, true)
 
-      // Finish the span if the call was cancelled.
-      call.once('cancelled', () => {
-        span.setTag('grpc.status.code', CANCELLED)
-        span.finish()
-      })
-
-      if (isStream) {
-        wrapStream(span, call)
-      } else {
-        arguments[1] = wrapCallback(span, callback, filter, childOf)
-      }
-
-      return scope.bind(func, span).apply(this, arguments)
-    }
-  }
-}
-
-function createWrapRegister (tracer, config) {
-  config = config.server || config
-
-  return function wrapRegister (register) {
-    return function registerWithTrace (name, handler, serialize, deserialize, type) {
-      if (typeof handler === 'function') {
-        arguments[1] = createWrapHandler(tracer, config, name)(handler)
-      }
-
-      return register.apply(this, arguments)
-    }
-  }
-}
+      this.enter(span, store)
+    })
 
-function wrapStream (span, call, tracer) {
-  const emit = call.emit
+    this.addSub('apm:grpc:server:request:error', error => {
+      const store = storage.getStore()
 
-  if (call.call && call.call.sendStatus) {
-    call.call.sendStatus = wrapSendStatus(call.call.sendStatus, span)
-  }
+      if (!store || !store.span) return
 
-  call.emit = function (eventName, ...args) {
-    switch (eventName) {
-      case 'error':
-        span.addTags({
-          [ERROR]: args[0] || 1,
-          'grpc.status.code': args[0] && args[0].code
-        })
+      this.addCode(store.span, error.code)
+      this.addError(error)
+    })
 
-        span.finish()
+    this.addSub('apm:grpc:server:request:update', ({ code }) => {
+      const store = storage.getStore()
 
-        break
+      if (!store || !store.span) return
 
-      // 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) {
-          span.setTag('grpc.status.code', call.status.code)
-        }
+      this.addCode(store.span, code)
+    })
 
-        if (!call.status || call.status.code === 0) {
-          span.finish()
-        }
+    this.addSub('apm:grpc:server:request:finish', ({ code, trailer } = {}) => {
+      const store = storage.getStore()
 
-        break
-    }
+      if (!store || !store.span) return
 
-    return emit.apply(this, arguments)
-  }
-}
+      const span = store.span
+      const metadataFilter = this.config.metadataFilter
 
-function wrapCallback (span, callback, filter, childOf) {
-  const scope = span.tracer().scope()
+      this.addCode(span, code)
 
-  return function (err, value, trailer, flags) {
-    if (err instanceof Error) {
-      if (err.code) {
-        span.setTag('grpc.status.code', err.code)
+      if (trailer && metadataFilter) {
+        addMetadataTags(span, trailer, metadataFilter, 'response')
       }
 
-      span.setTag(ERROR, err)
-    } else {
-      span.setTag('grpc.status.code', OK)
-    }
-
-    if (trailer && filter) {
-      addMetadataTags(span, trailer, filter, 'response')
-    }
+      store.span.finish()
+    })
+  }
 
-    span.finish()
+  configure (config) {
+    const metadataFilter = getFilter(config, 'metadata')
 
-    if (callback) {
-      return scope.bind(callback, childOf).apply(this, arguments)
-    }
+    return super.configure({ ...config, metadataFilter })
   }
-}
-
-function wrapSendStatus (sendStatus, span) {
-  return function sendStatusWithTrace (status) {
-    span.setTag('grpc.status.code', status.code)
 
-    return sendStatus.apply(this, arguments)
+  addCode (span, code) {
+    if (code !== undefined) {
+      span.setTag('grpc.status.code', code)
+    }
   }
 }
 
@@ -157,34 +92,4 @@ function extract (tracer, metadata) {
   return tracer.extract(TEXT_MAP, metadata.getMap())
 }
 
-function isEmitter (obj) {
-  return typeof obj.emit === 'function' && typeof obj.once === 'function'
-}
-
-module.exports = [
-  {
-    name: 'grpc',
-    versions: ['>=1.20.2'],
-    file: 'src/server.js',
-    patch (server, tracer, config) {
-      if (config.server === false) return
-      this.wrap(server.Server.prototype, 'register', createWrapRegister(tracer, config))
-    },
-    unpatch (server) {
-      this.unwrap(server.Server.prototype, 'register')
-    }
-  },
-  {
-    name: '@grpc/grpc-js',
-    versions: ['>=1'],
-    file: 'build/src/server.js',
-    patch (server, tracer, config) {
-      if (config.server === false) return
-
-      this.wrap(server.Server.prototype, 'register', createWrapRegister(tracer, config))
-    },
-    unpatch (server) {
-      this.unwrap(server.Server.prototype, 'register')
-    }
-  }
-]
+module.exports = GrpcServerPlugin