@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,258 @@
+'use strict'
+
+const { addHook, channel } = require('../helpers/instrument')
+const shimmer = require('../../../datadog-shimmer')
+const types = require('./types')
+
+const patched = new WeakSet()
+const instances = new WeakMap()
+
+const startChannel = channel('apm:grpc:client:request:start')
+const asyncStartChannel = channel('apm:grpc:client:request:asyncStart')
+const errorChannel = channel('apm:grpc:client:request:error')
+const finishChannel = channel('apm:grpc:client:request:finish')
+const emitChannel = channel('apm:grpc:client:request:emit')
+
+function createWrapMakeRequest (type, hasPeer = false) {
+  return function wrapMakeRequest (makeRequest) {
+    return function (path) {
+      const args = ensureMetadata(this, arguments, 4)
+
+      return callMethod(this, makeRequest, args, path, args[4], type, hasPeer)
+    }
+  }
+}
+
+function createWrapLoadPackageDefinition (hasPeer = false) {
+  return function wrapLoadPackageDefinition (loadPackageDefinition) {
+    return function (packageDef) {
+      const result = loadPackageDefinition.apply(this, arguments)
+
+      if (!result) return result
+
+      wrapPackageDefinition(result, hasPeer)
+
+      return result
+    }
+  }
+}
+
+function createWrapMakeClientConstructor (hasPeer = false) {
+  return function wrapMakeClientConstructor (makeClientConstructor) {
+    return function (methods) {
+      const ServiceClient = makeClientConstructor.apply(this, arguments)
+      wrapClientConstructor(ServiceClient, methods, hasPeer)
+      return ServiceClient
+    }
+  }
+}
+
+function wrapPackageDefinition (def, hasPeer = false) {
+  for (const name in def) {
+    if (def[name].format) continue
+    if (def[name].service && def[name].prototype) {
+      wrapClientConstructor(def[name], def[name].service, hasPeer)
+    } else {
+      wrapPackageDefinition(def[name], hasPeer)
+    }
+  }
+}
+
+function wrapClientConstructor (ServiceClient, methods, hasPeer = false) {
+  const proto = ServiceClient.prototype
+
+  if (typeof methods !== 'object' || 'format' in methods) return
+
+  for (const [name, method] of Object.entries(methods)) {
+    if (!method) continue
+
+    const { originalName, path } = method
+    const type = getType(method)
+
+    proto[name] = wrapMethod(proto[name], path, type, hasPeer)
+
+    if (originalName) {
+      proto[originalName] = wrapMethod(proto[originalName], path, type, hasPeer)
+    }
+  }
+}
+
+function wrapMethod (method, path, type, hasPeer) {
+  if (typeof method !== 'function' || patched.has(method)) {
+    return method
+  }
+
+  const wrapped = shimmer.wrapFunction(method, method => function () {
+    const args = ensureMetadata(this, arguments, 1)
+    return callMethod(this, method, args, path, args[1], type, hasPeer)
+  })
+
+  patched.add(wrapped)
+
+  return wrapped
+}
+
+function wrapCallback (ctx, callback = () => {}) {
+  return shimmer.wrapFunction(callback, callback => function (err) {
+    if (err) {
+      ctx.error = err
+      errorChannel.publish(ctx)
+    }
+
+    return asyncStartChannel.runStores(ctx, () => {
+      return callback.apply(this, arguments)
+      // No async end channel needed
+    })
+  })
+}
+
+const onStatusWithPeer = function (ctx, arg1, thisArg) {
+  ctx.result = arg1
+  ctx.peer = thisArg.getPeer()
+  finishChannel.publish(ctx)
+}
+
+const onStatusWithoutPeer = function (ctx, arg1) {
+  ctx.result = arg1
+  finishChannel.publish(ctx)
+}
+
+function createWrapEmit (ctx, hasPeer = false) {
+  const onStatus = hasPeer ? onStatusWithPeer : onStatusWithoutPeer
+
+  return function wrapEmit (emit) {
+    return function (event, arg1) {
+      switch (event) {
+        case 'error':
+          ctx.error = arg1
+          errorChannel.publish(ctx)
+          break
+        case 'status':
+          onStatus(ctx, arg1, this)
+          break
+      }
+
+      return emitChannel.runStores(ctx, () => {
+        return emit.apply(this, arguments)
+      })
+    }
+  }
+}
+
+function callMethod (client, method, args, path, metadata, type, hasPeer = false) {
+  if (!startChannel.hasSubscribers) return method.apply(client, args)
+
+  const length = args.length
+  const callback = args[length - 1]
+
+  const ctx = { metadata, path, type }
+
+  return startChannel.runStores(ctx, () => {
+    try {
+      if (type === types.unary || type === types.client_stream) {
+        if (typeof callback === 'function') {
+          args[length - 1] = wrapCallback(ctx, callback)
+        } else {
+          args[length] = wrapCallback(ctx)
+        }
+      }
+
+      const call = method.apply(client, args)
+
+      if (call && typeof call.emit === 'function') {
+        shimmer.wrap(call, 'emit', createWrapEmit(ctx, hasPeer))
+      }
+
+      return call
+    } catch (e) {
+      ctx.error = e
+      errorChannel.publish(ctx)
+    }
+    // No end channel needed
+  })
+}
+
+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 (hasPeer = false) {
+  return function patch (grpc) {
+    const proto = grpc.Client.prototype
+
+    instances.set(proto, grpc)
+
+    shimmer.wrap(proto, 'makeBidiStreamRequest', createWrapMakeRequest(types.bidi, hasPeer))
+    shimmer.wrap(proto, 'makeClientStreamRequest', createWrapMakeRequest(types.clientStream, hasPeer))
+    shimmer.wrap(proto, 'makeServerStreamRequest', createWrapMakeRequest(types.serverStream, hasPeer))
+    shimmer.wrap(proto, 'makeUnaryRequest', createWrapMakeRequest(types.unary, hasPeer))
+
+    return grpc
+  }
+}
+
+addHook({ name: '@grpc/grpc-js', versions: ['>=1.0.3 <1.1.4'] }, patch(false))
+
+addHook({ name: '@grpc/grpc-js', versions: ['>=1.0.3 <1.1.4'], file: 'build/src/make-client.js' }, client => {
+  shimmer.wrap(client, 'makeClientConstructor', createWrapMakeClientConstructor(false))
+  shimmer.wrap(client, 'loadPackageDefinition', createWrapLoadPackageDefinition(false))
+
+  return client
+})
+
+addHook({ name: '@grpc/grpc-js', versions: ['>=1.1.4'] }, patch(true))
+
+addHook({ name: '@grpc/grpc-js', versions: ['>=1.1.4'], file: 'build/src/make-client.js' }, client => {
+  shimmer.wrap(client, 'makeClientConstructor', createWrapMakeClientConstructor(true))
+  shimmer.wrap(client, 'loadPackageDefinition', createWrapLoadPackageDefinition(true))
+
+  return client
+})

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

@@ -0,0 +1,154 @@
+'use strict'
+
+const { channel, addHook } = require('../helpers/instrument')
+const shimmer = require('../../../datadog-shimmer')
+const types = require('./types')
+
+const startChannel = channel('apm:grpc:server:request:start')
+const asyncStartChannel = channel('apm:grpc:server:request:asyncStart')
+const errorChannel = channel('apm:grpc:server:request:error')
+const updateChannel = channel('apm:grpc:server:request:update')
+const finishChannel = channel('apm:grpc:server:request:finish')
+const emitChannel = channel('apm:grpc:server:request:emit')
+
+// https://github.com/grpc/grpc/blob/master/doc/statuscodes.md
+const OK = 0
+const CANCELLED = 1
+
+const isValid = (server, args) => {
+  return Boolean(startChannel.hasSubscribers &&
+    server?.type &&
+    args[0] &&
+    (server.type === 'unary' ? typeof args[1] === 'function' : isEmitter(args[0])))
+}
+
+function wrapHandler (func, name) {
+  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 ctx = { name, metadata, type }
+
+    return startChannel.runStores(ctx, () => {
+      try {
+        const onCancel = () => {
+          ctx.code = CANCELLED
+          finishChannel.publish(ctx)
+        }
+
+        // Finish the span if the call was cancelled.
+        call.once('cancelled', onCancel)
+
+        if (isStream) {
+          wrapStream(call, ctx, onCancel)
+        } else {
+          arguments[1] = wrapCallback(callback, call, ctx, onCancel)
+        }
+
+        shimmer.wrap(call, 'emit', emit => {
+          return function () {
+            return emitChannel.runStores(ctx, () => {
+              return emit.apply(this, arguments)
+            })
+          }
+        })
+
+        return func.apply(this, arguments)
+      } catch (e) {
+        ctx.error = e
+        errorChannel.publish(ctx)
+      }
+      // No end channel needed
+    })
+  }
+}
+
+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 createWrapEmit (call, ctx, onCancel) {
+  return function wrapEmit (emit) {
+    return function (event, arg1) {
+      switch (event) {
+        case 'error':
+          ctx.error = arg1
+          errorChannel.publish(ctx)
+          ctx.code = arg1.code
+          finishChannel.publish(ctx)
+          call.removeListener('cancelled', onCancel)
+          break
+        // Streams are always cancelled before `finish` since 1.10.0 so we have
+        // to use `prefinish` instead to avoid cancellation false positives.
+        case 'prefinish':
+          if (call.status) {
+            updateChannel.publish(call.status)
+          }
+          if (!call.status || call.status.code === 0) {
+            finishChannel.publish(ctx)
+          }
+          call.removeListener('cancelled', onCancel)
+          break
+      }
+
+      return emit.apply(this, arguments)
+    }
+  }
+}
+
+function wrapStream (call, ctx, onCancel) {
+  if (call.call && call.call.sendStatus) {
+    call.call.sendStatus = wrapSendStatus(call.call.sendStatus, ctx)
+  }
+
+  shimmer.wrap(call, 'emit', createWrapEmit(call, ctx, onCancel))
+}
+
+function wrapCallback (callback = () => {}, call, ctx, onCancel) {
+  return shimmer.wrapFunction(callback, callback => function (err, value, trailer, flags) {
+    if (err) {
+      ctx.error = err
+      errorChannel.publish(ctx)
+    } else {
+      ctx.code = OK
+      ctx.trailer = trailer
+    }
+
+    finishChannel.publish(ctx)
+
+    call.removeListener('cancelled', onCancel)
+
+    return asyncStartChannel.runStores(ctx, () => {
+      return callback.apply(this, arguments)
+      // No async end channel needed
+    })
+  })
+}
+
+function wrapSendStatus (sendStatus, ctx) {
+  return function (status) {
+    ctx.status = status
+    updateChannel.publish(ctx)
+
+    return sendStatus.apply(this, arguments)
+  }
+}
+
+function isEmitter (obj) {
+  return typeof obj.emit === 'function' && typeof obj.once === 'function'
+}
+
+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/types.js

@@ -0,0 +1,10 @@
+'use strict'
+
+module.exports = {
+  unary: 'unary',
+  bidi: 'bidi_streaming',
+  client_stream: 'client_streaming',
+  clientStream: 'client_streaming',
+  server_stream: 'server_streaming',
+  serverStream: 'server_streaming',
+}

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

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

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

@@ -0,0 +1,40 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { channel, addHook } = require('./helpers/instrument')
+
+const handlebarsCompileCh = channel('datadog:handlebars:compile:start')
+const handlebarsRegisterPartialCh = channel('datadog:handlebars:register-partial:start')
+
+function wrapCompile (compile) {
+  return function wrappedCompile (source) {
+    if (handlebarsCompileCh.hasSubscribers) {
+      handlebarsCompileCh.publish({ source })
+    }
+
+    return compile.apply(this, arguments)
+  }
+}
+
+function wrapRegisterPartial (registerPartial) {
+  return function wrappedRegisterPartial (name, partial) {
+    if (handlebarsRegisterPartialCh.hasSubscribers) {
+      handlebarsRegisterPartialCh.publish({ partial })
+    }
+
+    return registerPartial.apply(this, arguments)
+  }
+}
+
+addHook({ name: 'handlebars', file: 'dist/cjs/handlebars/compiler/compiler.js', versions: ['>=4.0.0'] }, compiler => {
+  shimmer.wrap(compiler, 'compile', wrapCompile)
+  shimmer.wrap(compiler, 'precompile', wrapCompile)
+
+  return compiler
+})
+
+addHook({ name: 'handlebars', file: 'dist/cjs/handlebars/base.js', versions: ['>=4.0.0'] }, base => {
+  shimmer.wrap(base.HandlebarsEnvironment.prototype, 'registerPartial', wrapRegisterPartial)
+
+  return base
+})

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

@@ -0,0 +1,178 @@
+'use strict'
+
+const tracingChannel = require('dc-polyfill').tracingChannel
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel } = require('./helpers/instrument')
+
+const handleChannel = channel('apm:hapi:request:handle')
+const routeChannel = channel('apm:hapi:request:route')
+const errorChannel = channel('apm:hapi:request:error')
+const hapiTracingChannel = tracingChannel('apm:hapi:extension')
+
+function wrapServer (server) {
+  return function (options) {
+    const app = server.apply(this, arguments)
+
+    if (!app) return app
+
+    if (typeof app.ext === 'function') {
+      app.ext = wrapExt(app.ext)
+    }
+
+    if (typeof app.start === 'function') {
+      app.start = wrapStart(app.start)
+    }
+
+    return app
+  }
+}
+
+function wrapStart (start) {
+  return shimmer.wrapFunction(start, start => function () {
+    if (this && typeof this.ext === 'function') {
+      this.ext('onPreResponse', onPreResponse)
+    }
+
+    return start.apply(this, arguments)
+  })
+}
+
+function wrapExt (ext) {
+  return shimmer.wrapFunction(ext, ext => function (events, method, options) {
+    if (events !== null && typeof events === 'object') {
+      arguments[0] = wrapEvents(events)
+    } else {
+      // The method should never be an array. The check is done as a safe guard
+      // during a refactoring where it was unclear if this would be possible or
+      // not.
+      arguments[1] = Array.isArray(method) ? method.map(wrapHandler) : [wrapHandler(method)]
+    }
+
+    return ext.apply(this, arguments)
+  })
+}
+
+function wrapDispatch (dispatch) {
+  return function (options) {
+    const handler = dispatch.apply(this, arguments)
+
+    if (typeof handler !== 'function') return handler
+
+    return function (req, res) {
+      handleChannel.publish({ req, res })
+
+      return handler.apply(this, arguments)
+    }
+  }
+}
+
+function wrapRebuild (rebuild) {
+  return function (event) {
+    const result = rebuild.apply(this, arguments)
+
+    if (this && Array.isArray(this._cycle)) {
+      this._cycle = this._cycle.map(wrapHandler)
+    }
+
+    return result
+  }
+}
+
+function wrapEvents (events, flat = false) {
+  const eventsArray = Array.isArray(events) ? events : [events]
+
+  return eventsArray.map(event => {
+    if (!event?.method) return event
+
+    return { ...event, method: wrapHandler(event.method) }
+  })
+}
+
+function wrapHandler (handler) {
+  if (typeof handler !== 'function') return handler
+
+  return shimmer.wrapFunction(handler, handler => function (request, h) {
+    const req = request?.raw?.req
+
+    if (!req) return handler.apply(this, arguments)
+
+    return hapiTracingChannel.traceSync(() => {
+      return handler.apply(this, arguments)
+    })
+  })
+}
+
+function onPreResponse (request, h) {
+  if (!request || !request.raw) return reply(request, h)
+
+  const req = request.raw.req
+
+  if (request.response instanceof Error) {
+    errorChannel.publish(request.response)
+  }
+
+  if (request.route) {
+    routeChannel.publish({ req, route: request.route.path })
+  }
+
+  return reply(request, h)
+}
+
+function reply (request, h) {
+  if (h.continue) {
+    return typeof h.continue === 'function'
+      ? h.continue()
+      : h.continue
+  } else if (typeof h === 'function') {
+    return h()
+  }
+}
+
+addHook({ name: '@hapi/hapi', versions: ['>=17.9'] }, hapi => {
+  shimmer.massWrap(hapi, ['server', 'Server'], wrapServer)
+
+  return hapi
+})
+
+addHook({ name: '@hapi/hapi', versions: ['>=17.9'], file: 'lib/core.js' }, Core => {
+  shimmer.wrap(Core.prototype, '_dispatch', wrapDispatch)
+
+  return Core
+})
+
+addHook({ name: '@hapi/hapi', versions: ['>=17.9'], file: 'lib/route.js' }, Route => {
+  shimmer.wrap(Route.prototype, 'rebuild', wrapRebuild)
+
+  return Route
+})
+
+addHook({ name: 'hapi', versions: ['>=17'] }, hapi => {
+  shimmer.massWrap(hapi, ['server', 'Server'], wrapServer)
+
+  return hapi
+})
+
+addHook({ name: 'hapi', versions: ['16'] }, hapi => {
+  shimmer.wrap(hapi.Server.prototype, 'start', wrapStart)
+  shimmer.wrap(hapi.Server.prototype, 'ext', wrapExt)
+
+  return hapi
+})
+
+addHook({ name: 'hapi', versions: ['16'], file: 'lib/connection.js' }, Connection => {
+  shimmer.wrap(Connection.prototype, '_dispatch', wrapDispatch)
+
+  return Connection
+})
+
+addHook({ name: 'hapi', versions: ['>=17'], file: 'lib/core.js' }, Core => {
+  shimmer.wrap(Core.prototype, '_dispatch', wrapDispatch)
+
+  return Core
+})
+
+addHook({ name: 'hapi', versions: ['>=16'], file: 'lib/route.js' }, Route => {
+  shimmer.wrap(Route.prototype, 'rebuild', wrapRebuild)
+
+  return Route
+})