dd-trace 2.1.1 → 2.2.0

package/index.d.ts

@@ -406,6 +406,28 @@ export declare interface TracerOptions {
    * @default true
    */
   orphanable?: boolean
+
+  /**
+   * Configuration of the AppSec protection. Can be a boolean as an alias to `appsec.enabled`.
+   */
+  appsec?: boolean | {
+    /**
+     * Whether to enable AppSec.
+     * @default false
+     */
+    enabled?: boolean,
+
+    /**
+     * Specifies a path to a custom rules file.
+     */
+    rules?: string,
+
+    /**
+     * Controls the maximum amount of traces sampled by AppSec attacks, per second.
+     * @default 100
+     */
+    rateLimit?: number
+  };
 }
 
 /** @hidden */

package/package.json

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

package/packages/datadog-instrumentations/index.js

@@ -1,11 +1,13 @@
 'use strict'
 
+require('./src/bluebird')
+require('./src/couchbase')
 require('./src/dns')
+require('./src/elasticsearch')
 require('./src/memcached')
 require('./src/mysql')
 require('./src/mysql2')
-require('./src/bluebird')
-require('./src/when')
 require('./src/promise')
-require('./src/q')
 require('./src/promise-js')
+require('./src/q')
+require('./src/when')

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

@@ -0,0 +1,143 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^2.6.5'] }, Bucket => {
+  const startCh = channel('apm:couchbase:query:start')
+  const asyncEndCh = channel('apm:couchbase:query:async-end')
+  const endCh = channel('apm:couchbase:query:end')
+  const errorCh = channel('apm:couchbase:query:error')
+
+  Bucket.prototype._maybeInvoke = wrapMaybeInvoke(Bucket.prototype._maybeInvoke)
+  Bucket.prototype.query = wrapQuery(Bucket.prototype.query)
+
+  shimmer.wrap(Bucket.prototype, '_n1qlReq', _n1qlReq => function (host, q, adhoc, emitter) {
+    if (!startCh.hasSubscribers) {
+      return _n1qlReq.apply(this, arguments)
+    }
+
+    if (!emitter || !emitter.once) return _n1qlReq.apply(this, arguments)
+
+    const n1qlQuery = q && q.statement
+
+    startCh.publish({ resource: n1qlQuery, bucket: this })
+
+    emitter.once('rows', AsyncResource.bind(() => {
+      asyncEndCh.publish(undefined)
+    }))
+
+    emitter.once('error', AsyncResource.bind((error) => {
+      errorCh.publish(error)
+      asyncEndCh.publish(undefined)
+    }))
+
+    try {
+      return _n1qlReq.apply(this, arguments)
+    } catch (err) {
+      err.stack // trigger getting the stack at the original throwing point
+      errorCh.publish(err)
+
+      throw err
+    } finally {
+      endCh.publish(undefined)
+    }
+  })
+
+  Bucket.prototype.upsert = wrap('apm:couchbase:upsert', Bucket.prototype.upsert)
+  Bucket.prototype.insert = wrap('apm:couchbase:insert', Bucket.prototype.insert)
+  Bucket.prototype.replace = wrap('apm:couchbase:replace', Bucket.prototype.replace)
+  Bucket.prototype.append = wrap('apm:couchbase:append', Bucket.prototype.append)
+  Bucket.prototype.prepend = wrap('apm:couchbase:prepend', Bucket.prototype.prepend)
+
+  return Bucket
+})
+
+addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^2.6.5'] }, Cluster => {
+  Cluster.prototype._maybeInvoke = wrapMaybeInvoke(Cluster.prototype._maybeInvoke)
+  Cluster.prototype.query = wrapQuery(Cluster.prototype.query)
+
+  return Cluster
+})
+
+function findCallbackIndex (args) {
+  for (let i = args.length - 1; i >= 2; i--) {
+    if (typeof args[i] === 'function') return i
+  }
+  return -1
+}
+
+function wrapMaybeInvoke (_maybeInvoke) {
+  const wrapped = function (fn, args) {
+    if (!Array.isArray(args)) return _maybeInvoke.apply(this, arguments)
+
+    const callbackIndex = args.length - 1
+    const callback = args[callbackIndex]
+
+    if (callback instanceof Function) {
+      args[callbackIndex] = AsyncResource.bind(callback)
+    }
+
+    return _maybeInvoke.apply(this, arguments)
+  }
+  return shimmer.wrap(_maybeInvoke, wrapped)
+}
+
+function wrapQuery (query) {
+  const wrapped = function (q, params, callback) {
+    callback = AsyncResource.bind(arguments[arguments.length - 1])
+
+    if (typeof callback === 'function') {
+      arguments[arguments.length - 1] = callback
+    }
+
+    const res = query.apply(this, arguments)
+    return res
+  }
+  return shimmer.wrap(query, wrapped)
+}
+
+function wrap (prefix, fn) {
+  const startCh = channel(prefix + ':start')
+  const endCh = channel(prefix + ':end')
+  const asyncEndCh = channel(prefix + ':async-end')
+  const errorCh = channel(prefix + ':error')
+
+  const wrapped = function (key, value, options, callback) {
+    if (!startCh.hasSubscribers) {
+      return fn.apply(this, arguments)
+    }
+
+    const callbackIndex = findCallbackIndex(arguments)
+
+    if (callbackIndex < 0) return fn.apply(this, arguments)
+
+    const cb = arguments[callbackIndex]
+
+    startCh.publish({ bucket: this })
+
+    arguments[callbackIndex] = function (error, result) {
+      if (error) {
+        errorCh.publish(error)
+      }
+      asyncEndCh.publish(result)
+      return cb.apply(this, arguments)
+    }
+
+    try {
+      return fn.apply(this, arguments)
+    } catch (error) {
+      error.stack // trigger getting the stack at the original throwing point
+      errorCh.publish(error)
+
+      throw error
+    } finally {
+      endCh.publish(undefined)
+    }
+  }
+  return shimmer.wrap(fn, wrapped)
+}

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

@@ -0,0 +1,74 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const startCh = channel('apm:elasticsearch:query:start')
+const asyncEndCh = channel('apm:elasticsearch:query:async-end')
+const endCh = channel('apm:elasticsearch:query:end')
+const errorCh = channel('apm:elasticsearch:query:error')
+
+addHook({ name: '@elastic/elasticsearch', file: 'lib/Transport.js', versions: ['>=5.6.16'] }, Transport => {
+  shimmer.wrap(Transport.prototype, 'request', wrapRequest)
+  return Transport
+})
+
+addHook({ name: 'elasticsearch', file: 'src/lib/transport.js', versions: ['>=10'] }, Transport => {
+  shimmer.wrap(Transport.prototype, 'request', wrapRequest)
+  return Transport
+})
+
+function wrapRequest (request) {
+  return function (params, options, cb) {
+    if (!startCh.hasSubscribers) {
+      return request.apply(this, arguments)
+    }
+
+    if (!params) return request.apply(this, arguments)
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+    startCh.publish({ params })
+
+    try {
+      const lastIndex = arguments.length - 1
+      cb = arguments[lastIndex]
+
+      if (typeof cb === 'function') {
+        cb = asyncResource.bind(cb)
+
+        arguments[lastIndex] = AsyncResource.bind(function (error) {
+          finish(params, error)
+          return cb.apply(null, arguments)
+        })
+        return request.apply(this, arguments)
+      } else {
+        const promise = request.apply(this, arguments)
+        if (promise && typeof promise.then === 'function') {
+          promise.then(() => finish(params), e => finish(params, e))
+        } else {
+          finish(params)
+        }
+        return promise
+      }
+    } catch (err) {
+      err.stack // trigger getting the stack at the original throwing point
+      errorCh.publish(err)
+
+      throw err
+    } finally {
+      endCh.publish(undefined)
+    }
+  }
+}
+
+function finish (params, error) {
+  if (error) {
+    errorCh.publish(error)
+  }
+  asyncEndCh.publish({ params })
+}

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

@@ -1,171 +1,74 @@
 'use strict'
 
-const Tags = require('../../../ext/tags')
-const Kinds = require('../../../ext/kinds')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
-function startSpan (tracer, config, operation, resource) {
-  const childOf = tracer.scope().active()
-  const span = tracer.startSpan(`couchbase.${operation}`, {
-    childOf,
-    tags: {
+class CouchBasePlugin extends Plugin {
+  static get name () {
+    return 'couchbase'
+  }
+
+  addSubs (func, start, asyncEnd = defaultAsyncEnd) {
+    this.addSub(`apm:couchbase:${func}:start`, start)
+    this.addSub(`apm:couchbase:${func}:end`, this.exit.bind(this))
+    this.addSub(`apm:couchbase:${func}:error`, errorHandler)
+    this.addSub(`apm:couchbase:${func}:async-end`, asyncEnd)
+  }
+
+  startSpan (operation, customTags, store, bucket) {
+    const tags = {
       'db.type': 'couchbase',
       'component': 'couchbase',
-      'service.name': config.service || `${tracer._service}-couchbase`,
-      'resource.name': resource,
-      [Tags.SPAN_KIND]: Kinds.CLIENT
+      'service.name': this.config.service || `${this.tracer._service}-couchbase`,
+      'resource.name': `couchbase.${operation}`,
+      'span.kind': 'client'
     }
-  })
-
-  analyticsSampler.sample(span, config.measured)
-
-  return span
-}
-
-function onRequestFinish (emitter, span) {
-  emitter.once('rows', () => {
-    span.finish()
-  })
-  emitter.once('error', (err) => {
-    span.setTag(Tags.ERROR, err)
-    span.finish()
-  })
-}
-
-function createWrapMaybeInvoke (tracer) {
-  return function wrapMaybeInvoke (_maybeInvoke) {
-    return function maybeInvokeWithTrace (fn, args) {
-      if (!Array.isArray(args)) return _maybeInvoke.apply(this, arguments)
 
-      const scope = tracer.scope()
-      const callbackIndex = args.length - 1
-      const callback = args[callbackIndex]
-
-      if (callback instanceof Function) {
-        args[callbackIndex] = scope.bind(callback)
-      }
-
-      return scope.bind(_maybeInvoke).apply(this, arguments)
+    for (const tag in customTags) {
+      tags[tag] = customTags[tag]
     }
-  }
-}
-
-function createWrapQuery (tracer) {
-  return function wrapQuery (query) {
-    return function queryWithTrace (q, params, callback) {
-      const scope = tracer.scope()
+    const span = this.tracer.startSpan(`couchbase.${operation}`, {
+      childOf: store ? store.span : null,
+      tags
+    })
 
-      callback = arguments[arguments.length - 1]
+    span.setTag('couchbase.bucket.name', bucket.name || bucket._name)
 
-      if (typeof callback === 'function') {
-        arguments[arguments.length - 1] = scope.bind(callback)
-      }
-
-      return scope.bind(query.apply(this, arguments))
-    }
+    analyticsSampler.sample(span, this.config.measured)
+    return span
   }
-}
-
-function createWrapN1qlReq (tracer, config) {
-  return function wrapN1qlReq (_n1qlReq) {
-    return function n1qlReqWithTrace (host, q, adhoc, emitter) {
-      if (!emitter || !emitter.once) return _n1qlReq.apply(this, arguments)
-
-      const scope = tracer.scope()
-      const n1qlQuery = q && q.statement
-      const span = startSpan(tracer, config, 'query', n1qlQuery)
 
-      span.setTag('span.type', 'sql')
+  constructor (...args) {
+    super(...args)
 
-      addBucketTag(span, this)
-      onRequestFinish(emitter, span)
+    this.addSubs('query', ({ resource, bucket }) => {
+      const store = storage.getStore()
+      const span = this.startSpan('query', { 'span.type': 'sql', 'resource.name': resource }, store, bucket)
+      this.enter(span, store)
+    })
 
-      return scope.bind(_n1qlReq, span).apply(this, arguments)
-    }
+    this._addCommandSubs('upsert')
+    this._addCommandSubs('insert')
+    this._addCommandSubs('replace')
+    this._addCommandSubs('append')
+    this._addCommandSubs('prepend')
   }
-}
-
-function createWrapStore (tracer, config, operation) {
-  return function wrapStore (store) {
-    return function storeWithTrace (key, value, options, callback) {
-      const callbackIndex = findCallbackIndex(arguments)
-
-      if (callbackIndex < 0) return store.apply(this, arguments)
-
-      const scope = tracer.scope()
-      const span = startSpan(tracer, config, operation)
-
-      addBucketTag(span, this)
-
-      arguments[callbackIndex] = wrapCallback(span, arguments[callbackIndex])
-
-      return scope.bind(store, span).apply(this, arguments)
-    }
+  _addCommandSubs (name) {
+    this.addSubs(name, ({ bucket }) => {
+      const store = storage.getStore()
+      const span = this.startSpan(name, {}, store, bucket)
+      this.enter(span, store)
+    })
   }
 }
 
-function addBucketTag (span, bucket) {
-  span.setTag('couchbase.bucket.name', bucket.name || bucket._name)
-}
-
-function findCallbackIndex (args) {
-  for (let i = args.length - 1; i >= 2; i--) {
-    if (typeof args[i] === 'function') return i
-  }
-
-  return -1
+function defaultAsyncEnd () {
+  storage.getStore().span.finish()
 }
 
-function wrapCallback (span, callback) {
-  return function (err, result) {
-    span.setTag('error', err)
-    span.finish()
-
-    return callback.apply(this, arguments)
-  }
+function errorHandler (error) {
+  storage.getStore().span.setTag('error', error)
 }
 
-module.exports = [
-  {
-    name: 'couchbase',
-    versions: ['^2.6.5'],
-    file: 'lib/bucket.js',
-    patch (Bucket, tracer, config) {
-      tracer.scope().bind(Bucket.prototype)
-
-      this.wrap(Bucket.prototype, '_maybeInvoke', createWrapMaybeInvoke(tracer, config))
-      this.wrap(Bucket.prototype, 'query', createWrapQuery(tracer))
-      this.wrap(Bucket.prototype, '_n1qlReq', createWrapN1qlReq(tracer, config))
-      this.wrap(Bucket.prototype, 'upsert', createWrapStore(tracer, config, 'upsert'))
-      this.wrap(Bucket.prototype, 'insert', createWrapStore(tracer, config, 'insert'))
-      this.wrap(Bucket.prototype, 'replace', createWrapStore(tracer, config, 'replace'))
-      this.wrap(Bucket.prototype, 'append', createWrapStore(tracer, config, 'append'))
-      this.wrap(Bucket.prototype, 'prepend', createWrapStore(tracer, config, 'prepend'))
-    },
-    unpatch (Bucket, tracer) {
-      tracer.scope().unbind(Bucket.prototype)
-
-      this.unwrap(Bucket.prototype, '_maybeInvoke')
-      this.unwrap(Bucket.prototype, 'query')
-      this.unwrap(Bucket.prototype, '_n1qlReq')
-      this.unwrap(Bucket.prototype, 'upsert')
-      this.unwrap(Bucket.prototype, 'insert')
-      this.unwrap(Bucket.prototype, 'replace')
-      this.unwrap(Bucket.prototype, 'append')
-      this.unwrap(Bucket.prototype, 'prepend')
-    }
-  },
-  {
-    name: 'couchbase',
-    versions: ['^2.6.5'],
-    file: 'lib/cluster.js',
-    patch (Cluster, tracer, config) {
-      this.wrap(Cluster.prototype, '_maybeInvoke', createWrapMaybeInvoke(tracer, config))
-      this.wrap(Cluster.prototype, 'query', createWrapQuery(tracer))
-    },
-    unpatch (Cluster) {
-      this.unwrap(Cluster.prototype, '_maybeInvoke')
-      this.unwrap(Cluster.prototype, 'query')
-    }
-  }
-]
+module.exports = CouchBasePlugin

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

@@ -1,23 +1,29 @@
 'use strict'
 
-const Tags = require('opentracing').Tags
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
-function createWrapRequest (tracer, config) {
-  config = normalizeConfig(config)
-  return function wrapRequest (request) {
-    return function requestWithTrace (params, options, cb) {
-      if (!params) return request.apply(this, arguments)
+class ElasticsearchPlugin extends Plugin {
+  static get name () {
+    return 'elasticsearch'
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:elasticsearch:query:start', ({ params }) => {
+      this.config = normalizeConfig(this.config)
 
-      const lastIndex = arguments.length - 1
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
       const body = getBody(params.body || params.bulkBody)
-      const childOf = tracer.scope().active()
-      const span = tracer.startSpan('elasticsearch.query', {
+      const span = this.tracer.startSpan('elasticsearch.query', {
         childOf,
         tags: {
-          [Tags.SPAN_KIND]: Tags.SPAN_KIND_RPC_CLIENT,
-          [Tags.DB_TYPE]: 'elasticsearch',
-          'service.name': config.service || `${tracer._service}-elasticsearch`,
+          'db.type': 'elasticsearch',
+          'span.kind': 'client',
+          'service.name': this.config.service || `${this.tracer._service}-elasticsearch`,
           'resource.name': `${params.method} ${quantizePath(params.path)}`,
           'span.type': 'elasticsearch',
           'elasticsearch.url': params.path,
@@ -26,57 +32,25 @@ function createWrapRequest (tracer, config) {
           'elasticsearch.params': JSON.stringify(params.querystring || params.query)
         }
       })
+      analyticsSampler.sample(span, this.config.measured)
+      this.enter(span, store)
+    })
 
-      analyticsSampler.sample(span, config.measured)
-
-      cb = arguments[lastIndex]
-
-      if (typeof cb === 'function') {
-        arguments[lastIndex] = wrapCallback(tracer, span, params, config, cb)
-
-        return tracer.scope().activate(span, () => request.apply(this, arguments))
-      } else {
-        const promise = request.apply(this, arguments)
-
-        if (promise && typeof promise.then === 'function') {
-          promise.then(() => finish(span, params, config), e => finish(span, params, config, e))
-        } else {
-          finish(span, params, config)
-        }
-
-        return promise
-      }
-    }
-  }
-}
+    this.addSub('apm:elasticsearch:query:end', () => {
+      this.exit()
+    })
 
-function wrapCallback (tracer, span, params, config, done) {
-  return tracer.scope().bind(function (err) {
-    finish(span, params, config, err)
-    done.apply(null, arguments)
-  })
-}
+    this.addSub('apm:elasticsearch:query:error', err => {
+      const span = storage.getStore().span
+      span.setTag('error', err)
+    })
 
-function finish (span, params, config, err) {
-  if (err) {
-    span.addTags({
-      'error.type': err.name,
-      'error.msg': err.message,
-      'error.stack': err.stack
+    this.addSub('apm:elasticsearch:query:async-end', ({ params }) => {
+      const span = storage.getStore().span
+      this.config.hooks.query(span, params)
+      span.finish()
     })
   }
-
-  config.hooks.query(span, params)
-
-  span.finish()
-}
-
-function quantizePath (path) {
-  return path && path.replace(/[0-9]+/g, '?')
-}
-
-function getBody (body) {
-  return body && JSON.stringify(body)
 }
 
 function normalizeConfig (config) {
@@ -94,27 +68,12 @@ function getHooks (config) {
   return { query }
 }
 
-module.exports = [
-  {
-    name: 'elasticsearch',
-    file: 'src/lib/transport.js',
-    versions: ['>=10'],
-    patch (Transport, tracer, config) {
-      this.wrap(Transport.prototype, 'request', createWrapRequest(tracer, config))
-    },
-    unpatch (Transport) {
-      this.unwrap(Transport.prototype, 'request')
-    }
-  },
-  {
-    name: '@elastic/elasticsearch',
-    file: 'lib/Transport.js',
-    versions: ['>=5.6.16'], // initial version of this module
-    patch (Transport, tracer, config) {
-      this.wrap(Transport.prototype, 'request', createWrapRequest(tracer, config))
-    },
-    unpatch (Transport) {
-      this.unwrap(Transport.prototype, 'request')
-    }
-  }
-]
+function getBody (body) {
+  return body && JSON.stringify(body)
+}
+
+function quantizePath (path) {
+  return path && path.replace(/[0-9]+/g, '?')
+}
+
+module.exports = ElasticsearchPlugin

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

@@ -165,7 +165,28 @@ function getRes (reply) {
 module.exports = [
   {
     name: 'fastify',
-    versions: ['>=1'],
+    versions: ['>=3'],
+    patch (fastify, tracer, config) {
+      // `fastify` is a function so we return a wrapper that will replace its export.
+      const wrapped = this.wrapExport(fastify, createWrapFastify(tracer, config)(fastify))
+
+      wrapped.fastify = wrapped
+      wrapped.default = wrapped
+
+      return wrapped
+    },
+    unpatch (fastify) {
+      const unwrapped = this.unwrapExport(fastify)
+
+      unwrapped.fastify = unwrapped
+      unwrapped.default = unwrapped
+
+      return unwrapped
+    }
+  },
+  {
+    name: 'fastify',
+    versions: ['1 - 2'],
     patch (fastify, tracer, config) {
       // `fastify` is a function so we return a wrapper that will replace its export.
       return this.wrapExport(fastify, createWrapFastify(tracer, config)(fastify))

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

@@ -2,6 +2,8 @@
 
 const { LOG } = require('../../../ext/formats')
 
+const hasOwn = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop)
+
 function chunkProxy (chunk, holder) {
   return new Proxy(chunk, {
     get (target, p, receiver) {
@@ -15,7 +17,8 @@ function chunkProxy (chunk, holder) {
       }
     },
     ownKeys (target) {
-      return ['dd', ...Reflect.ownKeys(target)]
+      const ownKeys = Reflect.ownKeys(target)
+      return hasOwn(target, 'dd') ? ownKeys : ['dd', ...ownKeys]
     },
     getOwnPropertyDescriptor (target, p) {
       return Reflect.getOwnPropertyDescriptor(p === 'dd' ? holder : target, p)

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

@@ -1 +1 @@
-module.exports = '2.1.1'
+module.exports = '2.2.0'

package/packages/dd-trace/src/appsec/index.js

@@ -76,6 +76,10 @@ function incomingHttpEndTranslator (data) {
   }
 
   // TODO: temporary express instrumentation, will use express plugin later
+  if (data.req.body !== undefined && data.req.body !== null) {
+    payload[addresses.HTTP_INCOMING_BODY] = data.req.body
+  }
+
   if (data.req.query && typeof data.req.query === 'object') {
     payload[addresses.HTTP_INCOMING_QUERY] = data.req.query
   }

package/packages/dd-trace/src/tagger.js

@@ -5,32 +5,25 @@ const log = require('./log')
 function add (carrier, keyValuePairs) {
   if (!carrier || !keyValuePairs) return
 
-  if (typeof keyValuePairs === 'string') {
-    return add(
-      carrier,
-      keyValuePairs
-        .split(',')
-        .filter(tag => tag.indexOf(':') !== -1)
-        .reduce((prev, next) => {
-          const tag = next.split(':')
-          const key = tag[0].trim()
-          const value = tag.slice(1).join(':').trim()
-
-          prev[key] = value
-
-          return prev
-        }, {})
-    )
-  }
-
   if (Array.isArray(keyValuePairs)) {
     return keyValuePairs.forEach(tags => add(carrier, tags))
   }
 
   try {
-    Object.keys(keyValuePairs).forEach(key => {
-      carrier[key] = keyValuePairs[key]
-    })
+    if (typeof keyValuePairs === 'string') {
+      const segments = keyValuePairs.split(',')
+      for (const segment of segments) {
+        const separatorIndex = segment.indexOf(':')
+        if (separatorIndex === -1) continue
+
+        const key = segment.slice(0, separatorIndex)
+        const value = segment.slice(separatorIndex + 1)
+
+        carrier[key.trim()] = value.trim()
+      }
+    } else {
+      Object.assign(carrier, keyValuePairs)
+    }
   } catch (e) {
     log.error(e)
   }

package/packages/dd-trace/src/tracer.js

@@ -21,7 +21,7 @@ class DatadogTracer extends Tracer {
   }
 
   trace (name, options, fn) {
-    options = Object.assign({}, {
+    options = Object.assign({
       childOf: this.scope().active()
     }, options)
 

package/NOTICE

@@ -1,4 +0,0 @@
-Datadog dd-trace-js
-Copyright 2016-Present Datadog, Inc.
-
-This product includes software developed at Datadog, Inc. (https://www.datadoghq.com/).

package/scripts/tracer-runner.js

@@ -1,13 +0,0 @@
-'use strict'
-
-const spawnWrap = require('spawn-wrap')
-const path = require('path')
-
-spawnWrap(['--require', path.join(__dirname, '..', 'init.js')])
-
-const { spawn } = require('child_process')
-
-const [command, ...argv] = process.argv.slice(2)
-spawn(command, argv, {
-  stdio: 'inherit'
-})