dd-trace 2.7.0 → 2.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "2.7.0",
+  "version": "2.7.1",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",

package/packages/datadog-instrumentations/index.js

@@ -2,6 +2,7 @@
 
 require('./src/amqplib')
 require('./src/amqp10')
+require('./src/aws-sdk')
 require('./src/bluebird')
 require('./src/bunyan')
 require('./src/cassandra-driver')

package/packages/datadog-instrumentations/src/aws-sdk.js

@@ -0,0 +1,104 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+function wrapRequest (send) {
+  return function wrappedRequest (cb) {
+    if (!this.service) return send.apply(this, arguments)
+
+    const serviceIdentifier = this.service.serviceIdentifier
+    const channelSuffix = getChannelSuffix(serviceIdentifier)
+    const startCh = channel(`apm:aws:request:start:${channelSuffix}`)
+    if (!startCh.hasSubscribers) return send.apply(this, arguments)
+    const outerAr = new AsyncResource('apm:aws:request:outer')
+
+    this.on('complete', response => {
+      channel(`apm:aws:request:complete:${channelSuffix}`).publish({ response })
+    })
+
+    return new AsyncResource('apm:aws:request:inner').runInAsyncScope(() => {
+      startCh.publish({
+        serviceIdentifier,
+        operation: this.operation,
+        awsRegion: this.service.config && this.service.config.region,
+        awsService: this.service.api && this.service.api.className,
+        request: this
+      })
+
+      if (typeof cb === 'function') {
+        arguments[0] = wrapCb(cb, channelSuffix, this, outerAr)
+      }
+      return send.apply(this, arguments)
+    })
+  }
+}
+
+function wrapCb (cb, serviceName, request, ar) {
+  return function wrappedCb (err, response) {
+    const obj = { request, response }
+    return ar.runInAsyncScope(() => {
+      channel(`apm:aws:response:start:${serviceName}`).publish(obj)
+      // TODO(bengl) make this work without needing a needsFinish property added to the object
+      if (!obj.needsFinish) {
+        return cb.apply(this, arguments)
+      }
+      const finishChannel = channel(`apm:aws:response:finish:${serviceName}`)
+      try {
+        let result = cb.apply(this, arguments)
+        if (result && result.then) {
+          result = result.then(x => {
+            finishChannel.publish()
+            return x
+          }, e => {
+            finishChannel.publish(e)
+            throw e
+          })
+        } else {
+          finishChannel.publish()
+        }
+        return result
+      } catch (e) {
+        finishChannel.publish(e)
+        throw e
+      }
+    })
+  }
+}
+
+function getChannelSuffix (name) {
+  return [
+    'cloudwatchlogs',
+    'dynamodb',
+    'eventbridge',
+    'kinesis',
+    'lambda',
+    'redshift',
+    's3',
+    'sns',
+    'sqs'
+  ].includes(name) ? name : 'default'
+}
+
+addHook({ name: 'aws-sdk', versions: ['>=2.3.0'] }, AWS => {
+  shimmer.wrap(AWS.Request.prototype, 'promise', wrapRequest)
+  shimmer.wrap(AWS.config, 'setPromisesDependency', setPromisesDependency => {
+    return function wrappedSetPromisesDependency (dep) {
+      const result = setPromisesDependency.apply(this, arguments)
+      shimmer.wrap(AWS.Request.prototype, 'promise', wrapRequest)
+      return result
+    }
+  })
+  return AWS
+})
+
+// <2.1.35 has breaking changes for instrumentation
+// https://github.com/aws/aws-sdk-js/pull/629
+addHook({ name: 'aws-sdk', versions: ['>=2.1.35'] }, AWS => {
+  shimmer.wrap(AWS.Request.prototype, 'send', wrapRequest)
+  return AWS
+})

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

@@ -45,7 +45,7 @@ function wrapAddHook (addHook) {
 
       if (!requestResource) return fn.apply(this, arguments)
 
-      requestResource.runInAsyncScope(() => {
+      return requestResource.runInAsyncScope(() => {
         const hookResource = new AsyncResource('bound-anonymous-fn')
 
         try {

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

@@ -0,0 +1,146 @@
+'use strict'
+
+const Tags = require('opentracing').Tags
+const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
+
+class BaseAwsSdkPlugin extends Plugin {
+  get serviceIdentifier () {
+    const id = this.constructor.name.toLowerCase()
+    Object.defineProperty(this, 'serviceIdentifier', {
+      configurable: true,
+      writable: true,
+      enumerable: true,
+      value: id
+    })
+    return id
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub(`apm:aws:request:start:${this.serviceIdentifier}`, ({
+      request,
+      operation,
+      awsRegion,
+      awsService,
+      serviceIdentifier
+    }) => {
+      if (!this.isEnabled(request)) {
+        return
+      }
+      const serviceName = this.getServiceName(serviceIdentifier)
+      const childOf = this.tracer.scope().active()
+      const tags = {
+        [Tags.SPAN_KIND]: 'client',
+        'service.name': serviceName,
+        'aws.operation': operation,
+        'aws.region': awsRegion,
+        'aws.service': awsService,
+        'component': 'aws-sdk'
+      }
+      if (this.requestTags) this.requestTags.set(request, tags)
+
+      const span = this.tracer.startSpan('aws.request', { childOf, tags })
+
+      analyticsSampler.sample(span, this.config.measured)
+
+      this.requestInject(span, request)
+
+      const store = storage.getStore()
+
+      this.enter(span, store)
+    })
+
+    this.addSub(`apm:aws:request:complete:${this.serviceIdentifier}`, ({ response }) => {
+      const store = storage.getStore()
+      if (!store) return
+      const { span } = store
+      if (!span) return
+      this.addResponseTags(span, response)
+      this.finish(span, response, response.error)
+    })
+  }
+
+  requestInject (span, request) {
+    // implemented by subclasses, or not
+  }
+
+  isEnabled (request) {
+    return true
+  }
+
+  addResponseTags (span, response) {
+    if (!span || !response.request) return
+    const params = response.request.params
+    const operation = response.request.operation
+    const extraTags = this.generateTags(params, operation, response) || {}
+    const tags = Object.assign({
+      'aws.response.request_id': response.requestId,
+      'resource.name': operation,
+      'span.kind': 'client'
+    }, extraTags)
+
+    span.addTags(tags)
+  }
+
+  generateTags () {
+    // implemented by subclasses, or not
+  }
+
+  finish (span, response, err) {
+    if (err) {
+      span.setTag('error', err)
+
+      if (err.requestId) {
+        span.addTags({ 'aws.response.request_id': err.requestId })
+      }
+    }
+
+    if (response) {
+      this.config.hooks.request(span, response)
+    }
+
+    span.finish()
+  }
+
+  configure (config) {
+    super.configure(normalizeConfig(config, this.serviceIdentifier))
+  }
+
+  // TODO: test splitByAwsService when the test suite is fixed
+  getServiceName (serviceIdentifier) {
+    return this.config.service
+      ? this.config.service
+      : `${this.tracer._service}-aws-${serviceIdentifier}`
+  }
+}
+
+function normalizeConfig (config, serviceIdentifier) {
+  const hooks = getHooks(config)
+
+  let specificConfig = config[serviceIdentifier]
+  switch (typeof specificConfig) {
+    case 'undefined':
+      specificConfig = {}
+      break
+    case 'boolean':
+      specificConfig = { enabled: specificConfig }
+      break
+  }
+
+  return Object.assign({}, config, specificConfig, {
+    splitByAwsService: config.splitByAwsService !== false,
+    hooks
+  })
+}
+
+function getHooks (config) {
+  const noop = () => {}
+  const request = (config.hooks && config.hooks.request) || noop
+
+  return { request }
+}
+
+module.exports = BaseAwsSdkPlugin

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

@@ -1,118 +1,28 @@
 'use strict'
 
-const Tags = require('opentracing').Tags
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-const awsHelpers = require('./helpers')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
 
-function createWrapRequest (tracer, config) {
-  config = normalizeConfig(config)
-  return function wrapRequest (send) {
-    return function requestWithTrace (cb) {
-      if (!this.service) return send.apply(this, arguments)
+const services = require('./services')
 
-      const serviceIdentifier = this.service.serviceIdentifier
-
-      if (!awsHelpers.isEnabled(serviceIdentifier, config[serviceIdentifier], this)) {
-        return send.apply(this, arguments)
-      }
-
-      const serviceName = getServiceName(serviceIdentifier, tracer, config)
-      const childOf = tracer.scope().active()
-      const tags = {
-        [Tags.SPAN_KIND]: 'client',
-        'service.name': serviceName,
-        'aws.operation': this.operation,
-        'aws.region': this.service.config && this.service.config.region,
-        'aws.service': this.service.api && this.service.api.className,
-        'component': 'aws-sdk'
-      }
-
-      const span = tracer.startSpan('aws.request', {
-        childOf,
-        tags
-      })
-
-      this.on('complete', response => {
-        if (!span) return
-
-        awsHelpers.addResponseTags(span, response, serviceIdentifier, config, tracer)
-        awsHelpers.finish(config, span, response, response.error)
-      })
-
-      analyticsSampler.sample(span, config.measured)
-
-      awsHelpers.requestInject(span, this, serviceIdentifier, tracer)
-
-      const request = this
+class AwsSdkPlugin extends Plugin {
+  static get name () {
+    return 'aws-sdk'
+  }
 
-      return tracer.scope().activate(span, () => {
-        if (typeof cb === 'function') {
-          arguments[0] = awsHelpers.wrapCb(cb, serviceIdentifier, tags, request, tracer, childOf)
-        }
-        return send.apply(this, arguments)
-      })
+  constructor (...args) {
+    super(...args)
+    this.services = {}
+    for (const name in services) {
+      const ServicePlugin = services[name]
+      this.services[name] = new ServicePlugin(...args)
     }
   }
-}
-
-function createWrapSetPromisesDependency (tracer, config, instrumenter, AWS) {
-  return function wrapSetPromisesDependency (setPromisesDependency) {
-    return function setPromisesDependencyWithTrace (dep) {
-      const result = setPromisesDependency.apply(this, arguments)
-
-      instrumenter.wrap(AWS.Request.prototype, 'promise', createWrapRequest(tracer, config))
 
-      return result
+  configure (config) {
+    for (const service of Object.values(this.services)) {
+      service.configure(config)
     }
   }
 }
 
-function normalizeConfig (config) {
-  const hooks = getHooks(config)
-
-  return Object.assign({}, config, {
-    splitByAwsService: config.splitByAwsService !== false,
-    hooks
-  })
-}
-
-function getHooks (config) {
-  const noop = () => {}
-  const request = (config.hooks && config.hooks.request) || noop
-
-  return { request }
-}
-
-// TODO: test splitByAwsService when the test suite is fixed
-function getServiceName (serviceIdentifier, tracer, config) {
-  return config.service
-    ? config.service
-    : `${tracer._service}-aws-${serviceIdentifier}`
-}
-
-// <2.1.35 has breaking changes for instrumentation
-// https://github.com/aws/aws-sdk-js/pull/629
-module.exports = [
-  {
-    name: 'aws-sdk',
-    versions: ['>=2.3.0'],
-    patch (AWS, tracer, config) {
-      this.wrap(AWS.Request.prototype, 'promise', createWrapRequest(tracer, config))
-      this.wrap(AWS.config, 'setPromisesDependency', createWrapSetPromisesDependency(tracer, config, this, AWS))
-    },
-    unpatch (AWS) {
-      this.unwrap(AWS.Request.prototype, 'promise')
-      this.unwrap(AWS.config, 'setPromisesDependency')
-    }
-  },
-  {
-    name: 'aws-sdk',
-    versions: ['>=2.1.35'],
-    patch (AWS, tracer, config) {
-      this.wrap(AWS.Request.prototype, 'send', createWrapRequest(tracer, config))
-    },
-    unpatch (AWS) {
-      this.unwrap(AWS.Request.prototype, 'send')
-    }
-  }
-]
+module.exports = AwsSdkPlugin

package/packages/datadog-plugin-aws-sdk/src/services/cloudwatchlogs.js

@@ -1,7 +1,9 @@
 'use strict'
 
-class CloudwatchLogs {
-  generateTags (params, operation, response) {
+const BaseAwsSdkPlugin = require('../base')
+
+class CloudwatchLogs extends BaseAwsSdkPlugin {
+  generateTags (params, operation) {
     const tags = {}
 
     if (!params || !params.logGroupName) return tags

package/packages/datadog-plugin-aws-sdk/src/services/default.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const BaseAwsSdkPlugin = require('../base')
+
+class Default extends BaseAwsSdkPlugin {}
+
+module.exports = Default

package/packages/datadog-plugin-aws-sdk/src/services/dynamodb.js

@@ -1,6 +1,8 @@
 'use strict'
 
-class DynamoDb {
+const BaseAwsSdkPlugin = require('../base')
+
+class DynamoDb extends BaseAwsSdkPlugin {
   generateTags (params, operation, response) {
     const tags = {}
 

package/packages/datadog-plugin-aws-sdk/src/services/eventbridge.js

@@ -1,6 +1,8 @@
 'use strict'
 const log = require('../../../dd-trace/src/log')
-class EventBridge {
+const BaseAwsSdkPlugin = require('../base')
+
+class EventBridge extends BaseAwsSdkPlugin {
   generateTags (params, operation, response) {
     if (!params || !params.source) return {}
 
@@ -14,14 +16,13 @@ class EventBridge {
    * requestInject
    * @param {*} span
    * @param {*} request
-   * @param {*} tracer
    *
    * Docs: https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEventsRequestEntry.html
    * We cannot use the traceHeader field as that's reserved for X-Ray.
    * Detail must be a valid JSON string
    * Max size per event is 256kb (https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-putevent-size.html)
    */
-  requestInject (span, request, tracer) {
+  requestInject (span, request) {
     const operation = request.operation
     if (operation === 'putEvents' &&
       request.params &&
@@ -31,7 +32,7 @@ class EventBridge {
       try {
         const details = JSON.parse(request.params.Entries[0].Detail)
         details._datadog = {}
-        tracer.inject(span, 'text_map', details._datadog)
+        this.tracer.inject(span, 'text_map', details._datadog)
         const finalData = JSON.stringify(details)
         const byteSize = Buffer.byteLength(finalData)
         if (byteSize >= (1024 * 256)) {

package/packages/datadog-plugin-aws-sdk/src/services/index.js

@@ -0,0 +1,12 @@
+'use strict'
+
+exports.cloudwatchlogs = require('./cloudwatchlogs')
+exports.dynamodb = require('./dynamodb')
+exports.eventbridge = require('./eventbridge')
+exports.kinesis = require('./kinesis')
+exports.lambda = require('./lambda')
+exports.redshift = require('./redshift')
+exports.s3 = require('./s3')
+exports.sns = require('./sns')
+exports.sqs = require('./sqs')
+exports.default = require('./default')

package/packages/datadog-plugin-aws-sdk/src/services/kinesis.js

@@ -1,6 +1,7 @@
 'use strict'
 const log = require('../../../dd-trace/src/log')
-class Kinesis {
+const BaseAwsSdkPlugin = require('../base')
+class Kinesis extends BaseAwsSdkPlugin {
   generateTags (params, operation, response) {
     if (!params || !params.StreamName) return {}
 
@@ -26,7 +27,7 @@ class Kinesis {
     }
   }
 
-  requestInject (span, request, tracer) {
+  requestInject (span, request) {
     const operation = request.operation
     if (operation === 'putRecord' || operation === 'putRecords') {
       if (!request.params) {
@@ -34,7 +35,7 @@ class Kinesis {
       }
 
       const traceData = {}
-      tracer.inject(span, 'text_map', traceData)
+      this.tracer.inject(span, 'text_map', traceData)
       let injectPath
       if (request.params.Records && request.params.Records.length > 0) {
         injectPath = request.params.Records[0]

package/packages/datadog-plugin-aws-sdk/src/services/lambda.js

@@ -1,8 +1,9 @@
 'use strict'
 
 const log = require('../../../dd-trace/src/log')
+const BaseAwsSdkPlugin = require('../base')
 
-class Lambda {
+class Lambda extends BaseAwsSdkPlugin {
   generateTags (params, operation, response) {
     const tags = {}
 
@@ -14,7 +15,7 @@ class Lambda {
     })
   }
 
-  requestInject (span, request, tracer) {
+  requestInject (span, request) {
     const operation = request.operation
     if (operation === 'invoke') {
       if (!request.params) {
@@ -35,7 +36,7 @@ class Lambda {
           if (!clientContext.custom) {
             clientContext.custom = {}
           }
-          tracer.inject(span, 'text_map', clientContext.custom)
+          this.tracer.inject(span, 'text_map', clientContext.custom)
           const newContextBase64 = Buffer.from(JSON.stringify(clientContext)).toString('base64')
           request.params.ClientContext = newContextBase64
         } catch (err) {

package/packages/datadog-plugin-aws-sdk/src/services/redshift.js

@@ -1,6 +1,8 @@
 'use strict'
 
-class Redshift {
+const BaseAwsSdkPlugin = require('../base')
+
+class Redshift extends BaseAwsSdkPlugin {
   generateTags (params, operation, response) {
     const tags = {}
 

package/packages/datadog-plugin-aws-sdk/src/services/s3.js

@@ -1,6 +1,8 @@
 'use strict'
 
-class S3 {
+const BaseAwsSdkPlugin = require('../base')
+
+class S3 extends BaseAwsSdkPlugin {
   generateTags (params, operation, response) {
     const tags = {}
 

package/packages/datadog-plugin-aws-sdk/src/services/sns.js

@@ -1,7 +1,8 @@
 'use strict'
 const log = require('../../../dd-trace/src/log')
+const BaseAwsSdkPlugin = require('../base')
 
-class Sns {
+class Sns extends BaseAwsSdkPlugin {
   generateTags (params, operation, response) {
     if (!params) return {}
 
@@ -16,7 +17,7 @@ class Sns {
     // for example if it contains a phone number?
   }
 
-  requestInject (span, request, tracer) {
+  requestInject (span, request) {
     const operation = request.operation
     if (operation === 'publish' || operation === 'publishBatch') {
       if (!request.params) {
@@ -36,7 +37,7 @@ class Sns {
         return
       }
       const ddInfo = {}
-      tracer.inject(span, 'text_map', ddInfo)
+      this.tracer.inject(span, 'text_map', ddInfo)
       injectPath.MessageAttributes._datadog = {
         DataType: 'Binary',
         BinaryValue: JSON.stringify(ddInfo) // BINARY types are automatically base64 encoded

package/packages/datadog-plugin-aws-sdk/src/services/sqs.js

@@ -1,9 +1,48 @@
 'use strict'
 
+const Tags = require('opentracing').Tags
 const log = require('../../../dd-trace/src/log')
+const BaseAwsSdkPlugin = require('../base')
+const { storage } = require('../../../datadog-core')
 
-class Sqs {
-  isEnabled (config, request) {
+class Sqs extends BaseAwsSdkPlugin {
+  constructor (...args) {
+    super(...args)
+    //
+    // TODO(bengl) Find a way to create the response span tags without this WeakMap being populated
+    // in the base class
+    this.requestTags = new WeakMap()
+
+    this.addSub('apm:aws:response:start:sqs', obj => {
+      const { request, response } = obj
+      const store = storage.getStore()
+      const plugin = this
+      const maybeChildOf = this.responseExtract(request.params, request.operation, response)
+      if (maybeChildOf) {
+        obj.needsFinish = true
+        const options = {
+          childOf: maybeChildOf,
+          tags: Object.assign(
+            {},
+            this.requestTags.get(request) || {},
+            { [Tags.SPAN_KIND]: 'server' }
+          )
+        }
+        const span = plugin.tracer.startSpan('aws.response', options)
+        this.enter(span, store)
+      }
+    })
+
+    this.addSub('apm:aws:response:finish:sqs', err => {
+      const { span } = storage.getStore()
+      this.finish(span, null, err)
+    })
+  }
+
+  isEnabled (request) {
+    // TODO(bengl) Figure out a way to make separate plugins for consumer and producer so that
+    // config can be isolated to `.configure()` instead of this whole isEnabled() thing.
+    const config = this.config
     switch (request.operation) {
       case 'receiveMessage':
         return config.consumer !== false
@@ -39,7 +78,7 @@ class Sqs {
     return tags
   }
 
-  responseExtract (params, operation, response, tracer) {
+  responseExtract (params, operation, response) {
     if (operation === 'receiveMessage') {
       if (
         (!params.MaxNumberOfMessages || params.MaxNumberOfMessages === 1) &&
@@ -52,7 +91,7 @@ class Sqs {
       ) {
         const textMap = response.Messages[0].MessageAttributes._datadog.StringValue
         try {
-          return tracer.extract('text_map', JSON.parse(textMap))
+          return this.tracer.extract('text_map', JSON.parse(textMap))
         } catch (err) {
           log.error(err)
           return undefined
@@ -61,7 +100,7 @@ class Sqs {
     }
   }
 
-  requestInject (span, request, tracer) {
+  requestInject (span, request) {
     const operation = request.operation
     if (operation === 'sendMessage') {
       if (!request.params) {
@@ -74,7 +113,7 @@ class Sqs {
         return
       }
       const ddInfo = {}
-      tracer.inject(span, 'text_map', ddInfo)
+      this.tracer.inject(span, 'text_map', ddInfo)
       request.params.MessageAttributes._datadog = {
         DataType: 'String',
         StringValue: JSON.stringify(ddInfo)

package/packages/dd-trace/lib/version.js

@@ -1 +1 @@
-module.exports = '2.7.0'
+module.exports = '2.7.1'

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