dd-trace 2.7.0 → 2.9.0

package/scripts/install_plugin_modules.js

@@ -55,18 +55,15 @@ async function assertVersions () {
       const plugin = plugins[key]
       if (plugin.prototype instanceof Plugin) {
         const instrumentations = []
-        const instrument = {
-          addHook (instrumentation) {
-            instrumentations.push(instrumentation)
-          }
+        const name = plugin.name
+
+        try {
+          loadInstFile(`${name}/server.js`, instrumentations)
+          loadInstFile(`${name}/client.js`, instrumentations)
+        } catch (e) {
+          loadInstFile(`${name}.js`, instrumentations)
         }
-        const instPath = path.join(
-          __dirname,
-          `../packages/datadog-instrumentations/src/${plugin.name}.js`
-        )
-        proxyquire.noPreserveCache()(instPath, {
-          './helpers/instrument': instrument
-        })
+
         return instrumentations
       } else {
         return plugin
@@ -81,15 +78,13 @@ async function assertVersions () {
   const externalNames = Object.keys(externals).filter(name => ~names.indexOf(name))
   for (const name of externalNames) {
     for (const inst of [].concat(externals[name])) {
-      if (!inst.dep) {
-        await assertInstrumentation(inst, true)
-      }
+      await assertInstrumentation(inst, true)
     }
   }
 }
 
 async function assertInstrumentation (instrumentation, external) {
-  const versions = [].concat(instrumentation.versions)
+  const versions = [].concat(instrumentation.versions || [])
   for (const version of versions) {
     if (version) {
       await assertModules(instrumentation.name, semver.coerce(version).version, external)
@@ -230,3 +225,18 @@ function sha1 (str) {
   shasum.update(str)
   return shasum.digest('hex')
 }
+
+function loadInstFile (file, instrumentations) {
+  const instrument = {
+    addHook (instrumentation) {
+      instrumentations.push(instrumentation)
+    }
+  }
+
+  const instPath = path.join(__dirname, `../packages/datadog-instrumentations/src/${file}`)
+
+  proxyquire.noPreserveCache()(instPath, {
+    './helpers/instrument': instrument,
+    '../helpers/instrument': instrument
+  })
+}

package/packages/datadog-plugin-aws-sdk/src/helpers.js

@@ -1,103 +0,0 @@
-'use strict'
-
-const Tags = require('opentracing').Tags
-
-const services = {
-  cloudwatchlogs: getService(require('./services/cloudwatchlogs')),
-  dynamodb: getService(require('./services/dynamodb')),
-  kinesis: getService(require('./services/kinesis')),
-  lambda: getService(require('./services/lambda')),
-  s3: getService(require('./services/s3')),
-  redshift: getService(require('./services/redshift')),
-  sns: getService(require('./services/sns')),
-  sqs: getService(require('./services/sqs')),
-  eventbridge: getService(require('./services/eventbridge'))
-}
-
-function getService (Service) {
-  return new Service()
-}
-
-const helpers = {
-  finish (config, span, response, err) {
-    if (err) {
-      span.setTag('error', err)
-
-      if (err.requestId) {
-        span.addTags({ 'aws.response.request_id': err.requestId })
-      }
-    }
-
-    config.hooks.request(span, response)
-
-    span.finish()
-  },
-
-  isEnabled (serviceIdentifier, config, request) {
-    if (typeof config === 'boolean') {
-      return config
-    } else if (!config || typeof config !== 'object' || !services[serviceIdentifier]) {
-      return true
-    }
-
-    return services[serviceIdentifier].isEnabled
-      ? services[serviceIdentifier].isEnabled(config, request)
-      : true
-  },
-
-  addResponseTags (span, response, serviceName) {
-    if (!span) return
-
-    if (response.request) {
-      this.addServicesTags(span, response, serviceName)
-    }
-  },
-
-  addServicesTags (span, response, serviceName) {
-    if (!span) return
-
-    const params = response.request.params
-    const operation = response.request.operation
-    const extraTags = services[serviceName] ? services[serviceName].generateTags(params, operation, response) : {}
-    const tags = Object.assign({
-      'aws.response.request_id': response.requestId,
-      'resource.name': operation,
-      'span.kind': 'client'
-    }, extraTags)
-
-    span.addTags(tags)
-  },
-
-  responseExtract (serviceName, request, response, tracer) {
-    if (services[serviceName] && services[serviceName].responseExtract) {
-      const params = request.params
-      const operation = request.operation
-      return services[serviceName].responseExtract(params, operation, response, tracer)
-    }
-  },
-
-  requestInject (span, request, serviceName, tracer) {
-    if (!span) return
-
-    const service = services[serviceName] && services[serviceName]
-    if (service && service.requestInject) service.requestInject(span, request, tracer)
-  },
-
-  wrapCb (cb, serviceName, tags, request, tracer, childOf) {
-    const awsHelpers = this
-    return function wrappedCb (err, resp) {
-      const maybeChildOf = awsHelpers.responseExtract(serviceName, request, resp, tracer)
-      if (maybeChildOf) {
-        const options = {
-          childOf: maybeChildOf,
-          tags: Object.assign({}, tags, { [Tags.SPAN_KIND]: 'server' })
-        }
-        return tracer.wrap('aws.response', options, cb).apply(this, arguments)
-      } else {
-        return tracer.scope().bind(cb, childOf).apply(this, arguments)
-      }
-    }
-  }
-}
-
-module.exports = helpers

package/packages/datadog-plugin-hapi/src/route.js

@@ -1,75 +0,0 @@
-'use strict'
-
-const web = require('../../dd-trace/src/plugins/util/web')
-
-function createWrapRebuild () {
-  return function wrapRebuild (rebuild) {
-    return function rebuildWithTrace (event) {
-      const result = rebuild.apply(this, arguments)
-
-      if (this && Array.isArray(this._cycle)) {
-        this._cycle = this._cycle.map(wrapMiddleware)
-      }
-
-      return result
-    }
-  }
-}
-
-function createWrapLifecycle () {
-  return function wrapLifecycle (lifecycle) {
-    return function lifecycleWithTrace () {
-      const result = lifecycle.apply(this, arguments)
-
-      if (Array.isArray(result)) return result.map(wrapMiddleware)
-
-      return result
-    }
-  }
-}
-
-function wrapMiddleware (middleware) {
-  if (typeof middleware !== 'function') return middleware
-
-  return function (request, next) {
-    if (!request || !request.raw) return middleware.apply(this, arguments)
-
-    return web.reactivate(request.raw.req, () => middleware.apply(this, arguments))
-  }
-}
-
-module.exports = [
-  {
-    name: '@hapi/hapi',
-    versions: ['>=17.9'],
-    file: 'lib/route.js',
-    patch (Route, tracer, config) {
-      this.wrap(Route.prototype, 'rebuild', createWrapRebuild(tracer, config))
-    },
-    unpatch (Route) {
-      this.unwrap(Route.prototype, 'rebuild')
-    }
-  },
-  {
-    name: 'hapi',
-    versions: ['>=10.4'],
-    file: 'lib/route.js',
-    patch (Route, tracer, config) {
-      this.wrap(Route.prototype, 'rebuild', createWrapRebuild(tracer, config))
-    },
-    unpatch (Route) {
-      this.unwrap(Route.prototype, 'rebuild')
-    }
-  },
-  {
-    name: 'hapi',
-    versions: ['2 - 10.3'],
-    file: 'lib/route.js',
-    patch (Route, tracer, config) {
-      this.wrap(Route.prototype, 'lifecycle', createWrapLifecycle(tracer, config))
-    },
-    unpatch (Route) {
-      this.unwrap(Route.prototype, 'lifecycle')
-    }
-  }
-]

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

@@ -1,204 +0,0 @@
-'use strict'
-
-const web = require('../../dd-trace/src/plugins/util/web')
-
-function createWrapDispatch (tracer, config) {
-  config = web.normalizeConfig(config)
-
-  return function wrapDispatch (dispatch) {
-    return function dispatchWithTrace (options) {
-      const handler = dispatch.apply(this, arguments)
-
-      if (typeof handler !== 'function') return handler
-
-      return function (req, res) {
-        return web.instrument(tracer, config, req, res, 'hapi.request', () => {
-          return handler.apply(this, arguments)
-        })
-      }
-    }
-  }
-}
-
-function createWrapServer (tracer) {
-  return function wrapServer (server) {
-    return function serverWithTrace (options) {
-      const app = server.apply(this, arguments)
-
-      if (!app) return app
-
-      if (typeof app.ext === 'function') {
-        app.ext = createWrapExt(tracer)(app.ext)
-      }
-
-      if (typeof app.start === 'function') {
-        app.start = createWrapStart(tracer)(app.start)
-      }
-
-      return app
-    }
-  }
-}
-
-function createWrapStart () {
-  return function wrapStart (start) {
-    return function startWithTrace () {
-      if (this && typeof this.ext === 'function') {
-        this.ext('onPreResponse', onPreResponse)
-      }
-
-      return start.apply(this, arguments)
-    }
-  }
-}
-
-function createWrapExt () {
-  return function wrapExt (ext) {
-    return function extWithTrace (events, method, options) {
-      if (typeof events === 'object') {
-        arguments[0] = wrapEvents(events)
-      } else {
-        arguments[1] = wrapExtension(method)
-      }
-
-      return ext.apply(this, arguments)
-    }
-  }
-}
-
-function wrapExtension (method) {
-  return [].concat(method).map(wrapHandler)
-}
-
-function wrapEvents (events) {
-  return [].concat(events).map(event => {
-    if (!event || !event.method) return event
-
-    return Object.assign({}, event, {
-      method: wrapExtension(event.method)
-    })
-  })
-}
-
-function wrapHandler (handler) {
-  if (typeof handler !== 'function') return handler
-
-  return function (request, h) {
-    if (!request || !request.raw) return handler.apply(this, arguments)
-
-    return web.reactivate(request.raw.req, () => handler.apply(this, arguments))
-  }
-}
-
-function onPreResponse (request, h) {
-  if (!request || !request.raw) return reply(request, h)
-
-  const req = request.raw.req
-
-  web.addError(req, request.response)
-
-  if (request.route) {
-    web.enterRoute(req, 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()
-  }
-}
-
-module.exports = [
-  {
-    name: '@hapi/hapi',
-    versions: ['>=17.9'],
-    patch (hapi, tracer, config) {
-      this.wrap(hapi, ['server', 'Server'], createWrapServer(tracer, config))
-    },
-    unpatch (hapi) {
-      this.unwrap(hapi, ['server', 'Server'])
-    }
-  },
-  {
-    name: 'hapi',
-    versions: ['>=17'],
-    patch (hapi, tracer, config) {
-      this.wrap(hapi, ['server', 'Server'], createWrapServer(tracer, config))
-    },
-    unpatch (hapi) {
-      this.unwrap(hapi, ['server', 'Server'])
-    }
-  },
-  {
-    name: 'hapi',
-    versions: ['2 - 7.1', '8 - 16'],
-    patch (hapi, tracer, config) {
-      this.wrap(hapi.Server.prototype, 'start', createWrapStart(tracer, config))
-      this.wrap(hapi.Server.prototype, 'ext', createWrapExt(tracer, config))
-    },
-    unpatch (hapi) {
-      this.unwrap(hapi.Server.prototype, 'start')
-      this.unwrap(hapi.Server.prototype, 'ext')
-    }
-  },
-  {
-    name: 'hapi',
-    versions: ['^7.2'],
-    patch (hapi, tracer, config) {
-      this.wrap(hapi, 'createServer', createWrapServer(tracer, config))
-    },
-    unpatch (hapi) {
-      this.unwrap(hapi, 'createServer')
-    }
-  },
-  {
-    name: '@hapi/hapi',
-    versions: ['>=17.9'],
-    file: 'lib/core.js',
-    patch (Core, tracer, config) {
-      this.wrap(Core.prototype, '_dispatch', createWrapDispatch(tracer, config))
-    },
-    unpatch (Core) {
-      this.unwrap(Core.prototype, '_dispatch')
-    }
-  },
-  {
-    name: 'hapi',
-    versions: ['7.2 - 16'],
-    file: 'lib/connection.js',
-    patch (Connection, tracer, config) {
-      this.wrap(Connection.prototype, '_dispatch', createWrapDispatch(tracer, config))
-    },
-    unpatch (Connection) {
-      this.unwrap(Connection.prototype, '_dispatch')
-    }
-  },
-  {
-    name: 'hapi',
-    versions: ['>=17'],
-    file: 'lib/core.js',
-    patch (Core, tracer, config) {
-      this.wrap(Core.prototype, '_dispatch', createWrapDispatch(tracer, config))
-    },
-    unpatch (Core) {
-      this.unwrap(Core.prototype, '_dispatch')
-    }
-  },
-  {
-    name: 'hapi',
-    versions: ['2 - 7.1'],
-    file: 'lib/server.js',
-    patch (Server, tracer, config) {
-      this.wrap(Server.prototype, '_dispatch', createWrapDispatch(tracer, config))
-    },
-    unpatch (Server) {
-      this.unwrap(Server.prototype, '_dispatch')
-    }
-  }
-]