dd-trace 0.36.2 → 0.36.6

package/LICENSE-3rdparty.csv

@@ -1,7 +1,7 @@
 Component,Origin,License,Copyright
+require,@datadog/sketches-js,Apache license 2.0,Copyright 2020 Datadog Inc.
 require,@types/node,MIT,Copyright Authors
 require,form-data,MIT,Copyright 2012 Felix Geisendörfer and contributors
-require,hdr-histogram-js,BSD-2-Clause,Copyright 2016 Alexandre Victoor
 require,koalas,MIT,Copyright 2013-2017 Brian Woodward
 require,limiter,MIT,Copyright 2011 John Hurliman
 require,lodash.kebabcase,MIT,Copyright JS Foundation and other contributors
@@ -10,7 +10,6 @@ require,lodash.sortby,MIT,Copyright JS Foundation and other contributors
 require,lodash.uniq,MIT,Copyright JS Foundation and other contributors
 require,methods,MIT,Copyright 2013-2014 TJ Holowaychuk
 require,module-details-from-path,MIT,Copyright 2016 Thomas Watson Steen
-require,multer,MIT,Copyright 2014 Hage Yaapa
 require,nan,MIT,Copyright 2018 NAN contributors
 require,node-gyp-build,MIT,Copyright 2017 Mathias Buus
 require,opentracing,MIT,Copyright 2016 Resonance Labs Inc
@@ -47,6 +46,7 @@ dev,int64-buffer,MIT,Copyright 2015-2016 Yusuke Kawasaki
 dev,jszip,MIT,Copyright 2015-2016 Stuart Knightley and contributors
 dev,mkdirp,MIT,Copyright 2010 James Halliday
 dev,mocha,MIT,Copyright 2011-2018 JS Foundation and contributors https://js.foundation
+dev,multer,MIT,Copyright 2014 Hage Yaapa
 dev,msgpack-lite,MIT,Copyright 2015 Yusuke Kawasaki
 dev,nock,MIT,Copyright 2017 Pedro Teixeira and other contributors
 dev,nyc,ISC,Copyright 2015 Contributors

package/index.d.ts

@@ -886,6 +886,16 @@ declare namespace plugins {
      */
     depth?: number;
 
+    /**
+     * Whether to include the source of the operation within the query as a tag
+     * on every span. This may contain sensitive information and sould only be
+     * enabled if sensitive data is always sent as variables and not in the
+     * query text.
+     *
+     * @default false
+     */
+    source?: boolean;
+
     /**
      * An array of variable names to record. Can also be a callback that returns
      * the key/value pairs to record. For example, using

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "0.36.2",
+  "version": "0.36.6",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -17,7 +17,7 @@
     "bench:e2e": "SERVICES=mongo yarn services && cd benchmark/e2e && node benchmark-run.js --duration=30",
     "type:doc": "cd docs && yarn && yarn build",
     "type:test": "cd docs && yarn && yarn test",
-    "lint": "node scripts/check_licenses.js && eslint .",
+    "lint": "node scripts/check_licenses.js && eslint . && yarn audit --groups dependencies",
     "services": "node ./scripts/install_plugin_modules && node packages/dd-trace/test/setup/services",
     "tdd": "node scripts/tdd.js",
     "test": "SERVICES=* yarn services && mocha --exit --expose-gc 'packages/dd-trace/test/setup/node.js' 'packages/*/test/**/*.spec.js'",
@@ -55,9 +55,9 @@
     "node": ">=8"
   },
   "dependencies": {
+    "@datadog/sketches-js": "^1.0.4",
     "@types/node": "^10.12.18",
     "form-data": "^3.0.0",
-    "hdr-histogram-js": "^2.0.1",
     "koalas": "^1.0.2",
     "limiter": "^1.1.4",
     "lodash.kebabcase": "^4.1.1",
@@ -66,7 +66,6 @@
     "lodash.uniq": "^4.5.0",
     "methods": "^1.1.2",
     "module-details-from-path": "^1.0.3",
-    "multer": "^1.4.2",
     "nan": "^2.12.1",
     "node-gyp-build": "^3.8.0",
     "opentracing": ">=0.12.1",
@@ -105,6 +104,7 @@
     "mocha": "^5.2.0",
     "mocha-junit-reporter": "^2.0.0",
     "mocha-multi-reporters": "^1.5.1",
+    "multer": "^1.4.2",
     "msgpack-lite": "^0.1.26",
     "nock": "^11.3.3",
     "nyc": "^14.1.1",

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

@@ -9,6 +9,8 @@ function createWrapRequest (tracer, config) {
     return function requestWithTrace (params, options, cb) {
       if (!params) return request.apply(this, arguments)
 
+      const lastIndex = arguments.length - 1
+      const body = getBody(params.body || params.bulkBody)
       const childOf = tracer.scope().active()
       const span = tracer.startSpan('elasticsearch.query', {
         childOf,
@@ -20,48 +22,39 @@ function createWrapRequest (tracer, config) {
           'span.type': 'elasticsearch',
           'elasticsearch.url': params.path,
           'elasticsearch.method': params.method,
+          'elasticsearch.body': body,
           'elasticsearch.params': JSON.stringify(params.querystring || params.query)
         }
       })
 
-      if (params.body || params.bulkBody) {
-        span.setTag('elasticsearch.body', JSON.stringify(params.body || params.bulkBody))
-      }
-
       analyticsSampler.sample(span, config.analytics)
 
-      cb = request.length === 2 || typeof options === 'function'
-        ? tracer.scope().bind(options, childOf)
-        : tracer.scope().bind(cb, childOf)
-
-      return tracer.scope().activate(span, () => {
-        if (typeof cb === 'function') {
-          if (request.length === 2) {
-            return request.call(this, params, wrapCallback(tracer, span, params, config, cb))
-          } else {
-            return request.call(this, params, options, wrapCallback(tracer, span, params, config, cb))
-          }
-        } else {
-          const promise = request.apply(this, arguments)
+      cb = arguments[lastIndex]
 
-          if (promise && typeof promise.then === 'function') {
-            promise.then(() => finish(span, params, config), e => finish(span, params, config, e))
-          } else {
-            finish(span, params, config)
-          }
+      if (typeof cb === 'function') {
+        arguments[lastIndex] = wrapCallback(tracer, span, params, config, cb)
 
-          return promise
+        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
+      }
     }
   }
 }
 
 function wrapCallback (tracer, span, params, config, done) {
-  return function (err) {
+  return tracer.scope().bind(function (err) {
     finish(span, params, config, err)
     done.apply(null, arguments)
-  }
+  })
 }
 
 function finish (span, params, config, err) {
@@ -82,6 +75,10 @@ function quantizePath (path) {
   return path && path.replace(/[0-9]+/g, '?')
 }
 
+function getBody (body) {
+  return body && JSON.stringify(body)
+}
+
 function normalizeConfig (config) {
   const hooks = getHooks(config)
 

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

@@ -17,6 +17,7 @@ function createWrapFastify (tracer, config) {
       if (typeof app.addHook === 'function') {
         app.addHook('onRequest', createOnRequest(tracer, config))
         app.addHook('preHandler', preHandler)
+        app.addHook = createWrapAddHook(tracer, config)(app.addHook)
       }
 
       methods.forEach(method => {
@@ -30,6 +31,51 @@ function createWrapFastify (tracer, config) {
   }
 }
 
+function createWrapAddHook (tracer, config) {
+  return function wrapAddHook (addHook) {
+    return function addHookWithTrace (name, fn) {
+      fn = arguments[arguments.length - 1]
+
+      if (typeof fn !== 'function') return addHook.apply(this, arguments)
+
+      arguments[arguments.length - 1] = safeWrap(fn, function (request, reply, done) {
+        const req = getReq(request)
+
+        if (!req) return fn.apply(this, arguments)
+
+        done = arguments[arguments.length - 1]
+
+        try {
+          if (typeof done === 'function') {
+            arguments[arguments.length - 1] = function (err) {
+              web.addError(req, err)
+              return done.apply(this, arguments)
+            }
+
+            return fn.apply(this, arguments)
+          } else {
+            const promise = fn.apply(this, arguments)
+
+            if (promise && typeof promise.catch === 'function') {
+              return promise.catch(err => {
+                web.addError(req, err)
+                throw err
+              })
+            }
+
+            return promise
+          }
+        } catch (e) {
+          web.addError(req, e)
+          throw e
+        }
+      })
+
+      return addHook.apply(this, arguments)
+    }
+  }
+}
+
 function createOnRequest (tracer, config) {
   return function onRequest (request, reply, next) {
     if (typeof next !== 'function') return
@@ -101,6 +147,13 @@ function wrapHandler (handler) {
   }
 }
 
+// TODO: move this to a common util
+function safeWrap (fn, wrapper) {
+  Object.defineProperty(wrapper, 'length', Object.getOwnPropertyDescriptor(fn, 'length'))
+
+  return wrapper
+}
+
 function getReq (request) {
   return request && (request.raw || request.req || request)
 }

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

@@ -60,7 +60,7 @@ function createWrapParse (tracer, config) {
           document._datadog_source = source.body || source
         }
 
-        addDocumentTags(span, document)
+        addDocumentTags(span, document, config)
 
         return document
       } catch (e) {
@@ -82,7 +82,7 @@ function createWrapValidate (tracer, config) {
 
       // skip for schema stitching nested validation
       if (document && document.loc) {
-        addDocumentTags(span, document)
+        addDocumentTags(span, document, config)
       }
 
       try {
@@ -228,7 +228,7 @@ function startExecutionSpan (tracer, config, operation, args) {
   const span = startSpan(tracer, config, 'execute')
 
   addExecutionTags(span, config, operation, args.document, args.operationName)
-  addDocumentTags(span, args.document)
+  addDocumentTags(span, args.document, config)
   addVariableTags(tracer, config, span, args.variableValues)
 
   analyticsSampler.sample(span, config.analytics)
@@ -255,10 +255,10 @@ function addExecutionTags (span, config, operation, document, operationName) {
   span.addTags(tags)
 }
 
-function addDocumentTags (span, document) {
+function addDocumentTags (span, document, config) {
   const tags = {}
 
-  if (document && document._datadog_source) {
+  if (config.source && document && document._datadog_source) {
     tags['graphql.source'] = document._datadog_source
   }
 
@@ -304,7 +304,7 @@ function startResolveSpan (tracer, config, childOf, path, info, contextValue) {
   })
 
   if (fieldNode) {
-    if (document && fieldNode.loc) {
+    if (config.source && document && fieldNode.loc) {
       span.setTag('graphql.source', document.substring(fieldNode.loc.start, fieldNode.loc.end))
     }
 

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

@@ -47,7 +47,7 @@ function createWrapMakeClientConstructor (tracer, config) {
 function wrapPackageDefinition (tracer, config, def) {
   for (const name in def) {
     if (def[name].format) continue
-    if (def[name].service) {
+    if (def[name].service && def[name].prototype) {
       wrapClientConstructor(tracer, config, def[name], def[name].service)
     } else {
       wrapPackageDefinition(tracer, config, def[name])

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

@@ -19,6 +19,13 @@ const {
 } = require('../../dd-trace/src/plugins/util/test')
 const { getFormattedJestTestParameters } = require('./util')
 
+function getVmContext (environment) {
+  if (typeof environment.getVmContext === 'function') {
+    return environment.getVmContext()
+  }
+  return null
+}
+
 function wrapEnvironment (BaseEnvironment) {
   return class DatadogJestEnvironment extends BaseEnvironment {
     constructor (config, context) {
@@ -54,11 +61,15 @@ const isTimeout = (event) => {
 function createHandleTestEvent (tracer, testEnvironmentMetadata, instrumenter) {
   return async function handleTestEventWithTrace (event) {
     if (event.name === 'test_retry') {
-      const context = this.getVmContext()
-      const { currentTestName } = context.expect.getState()
+      let testName = event.test && event.test.name
+      const context = getVmContext(this)
+      if (context) {
+        const { currentTestName } = context.expect.getState()
+        testName = currentTestName
+      }
       // If it's a retry, we restore the original test function so that it is not wrapped again
-      if (this.originalTestFnByTestName[currentTestName]) {
-        event.test.fn = this.originalTestFnByTestName[currentTestName]
+      if (this.originalTestFnByTestName[testName]) {
+        event.test.fn = this.originalTestFnByTestName[testName]
       }
       return
     }
@@ -66,7 +77,7 @@ function createHandleTestEvent (tracer, testEnvironmentMetadata, instrumenter) {
       if (!isTimeout(event)) {
         return
       }
-      const context = this.getVmContext()
+      const context = getVmContext(this)
       if (context) {
         const { currentTestName } = context.expect.getState()
         const testSpan = this.testSpansByTestName[`${currentTestName}_${event.test.invocations}`]
@@ -111,11 +122,13 @@ function createHandleTestEvent (tracer, testEnvironmentMetadata, instrumenter) {
       'x-datadog-sampled': 1
     })
     let testName = event.test.name
-    const context = this.getVmContext()
+    const context = getVmContext(this)
+
     if (context) {
       const { currentTestName } = context.expect.getState()
       testName = currentTestName
     }
+
     const commonSpanTags = {
       [TEST_TYPE]: 'test',
       [TEST_NAME]: testName,
@@ -194,7 +207,7 @@ function createHandleTestEvent (tracer, testEnvironmentMetadata, instrumenter) {
           result = await specFunction()
           // it may have been set already if the test timed out
           let suppressedErrors = []
-          const context = environment.getVmContext()
+          const context = getVmContext(environment)
           if (context) {
             suppressedErrors = context.expect.getState().suppressedErrors
           }

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

@@ -79,8 +79,13 @@ function createWrapRunTest (tracer, testEnvironmentMetadata, sourceRoot) {
               activeSpan.setTag(TEST_STATUS, 'fail')
             }
           } catch (error) {
-            activeSpan.setTag(TEST_STATUS, 'fail')
-            activeSpan.setTag('error', error)
+            // this.skip has been called
+            if (error.constructor.name === 'Pending' && !this.forbidPending) {
+              activeSpan.setTag(TEST_STATUS, 'skip')
+            } else {
+              activeSpan.setTag(TEST_STATUS, 'fail')
+              activeSpan.setTag('error', error)
+            }
             throw error
           } finally {
             finishAllTraceSpans(activeSpan)

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

@@ -1,5 +1,7 @@
 'use strict'
 
+// TODO: either instrument all or none of the render functions
+
 function createWrapHandleRequest (tracer, config) {
   return function wrapHandleRequest (handleRequest) {
     return function handleRequestWithTrace (req, res, pathname, query) {
@@ -28,6 +30,22 @@ function createWrapHandleApiRequest (tracer, config) {
   }
 }
 
+function createWrapRenderToResponse (tracer, config) {
+  return function wrapRenderToResponse (renderToResponse) {
+    return function renderToResponseWithTrace (ctx) {
+      return trace(tracer, config, ctx.req, ctx.res, () => renderToResponse.apply(this, arguments))
+    }
+  }
+}
+
+function createWrapRenderErrorToResponse (tracer, config) {
+  return function wrapRenderErrorToResponse (renderErrorToResponse) {
+    return function renderErrorToResponseWithTrace (ctx) {
+      return trace(tracer, config, ctx.req, ctx.res, () => renderErrorToResponse.apply(this, arguments))
+    }
+  }
+}
+
 function createWrapRenderToHTML (tracer, config) {
   return function wrapRenderToHTML (renderToHTML) {
     return function renderToHTMLWithTrace (req, res, pathname, query, parsedUrl) {
@@ -36,12 +54,26 @@ function createWrapRenderToHTML (tracer, config) {
   }
 }
 
-function createWrapRenderToHTMLWithComponents (tracer, config) {
-  return function wrapHandleRenderToHTMLWithComponents (renderToHTMLWithComponents) {
-    return function renderToHTMLWithComponentsWithTrace (req, res, page) {
-      addPage(req, page)
+function createWrapRenderErrorToHTML (tracer, config) {
+  return function wrapRenderErrorToHTML (renderErrorToHTML) {
+    return function renderErrorToHTMLWithTrace (err, req, res, pathname, query) {
+      return trace(tracer, config, req, res, () => renderErrorToHTML.apply(this, arguments))
+    }
+  }
+}
 
-      return renderToHTMLWithComponents.apply(this, arguments)
+function createWrapFindPageComponents (tracer, config) {
+  return function wrapFindPageComponents (findPageComponents) {
+    return function findPageComponentsWithTrace (pathname, query) {
+      const result = findPageComponents.apply(this, arguments)
+      const span = tracer.scope().active()
+      const req = span && span._nextReq
+
+      if (result) {
+        addPage(req, pathname)
+      }
+
+      return result
     }
   }
 }
@@ -75,6 +107,10 @@ function trace (tracer, config, req, res, handler) {
 
   const promise = scope.activate(span, handler)
 
+  // HACK: Store the request object on the span for findPageComponents.
+  // TODO: Use CLS when it will be available in core.
+  span._nextReq = req
+
   promise.then(() => finish(span, config, req, res), err => {
     span.setTag('error', err)
     finish(span, config, req, res)
@@ -84,6 +120,8 @@ function trace (tracer, config, req, res, handler) {
 }
 
 function addPage (req, page) {
+  if (!req || !req._datadog_next) return
+
   req._datadog_next.span.addTags({
     'resource.name': `${req.method} ${page}`.trim(),
     'next.page': page
@@ -114,7 +152,7 @@ function getHooks (config) {
 module.exports = [
   {
     name: 'next',
-    versions: ['>=9.5'],
+    versions: ['>=9.5 <11.1'],
     file: 'dist/next-server/server/next-server.js',
     patch ({ default: Server }, tracer, config) {
       config = normalizeConfig(config)
@@ -122,13 +160,37 @@ module.exports = [
       this.wrap(Server.prototype, 'handleRequest', createWrapHandleRequest(tracer, config))
       this.wrap(Server.prototype, 'handleApiRequest', createWrapHandleApiRequest(tracer, config))
       this.wrap(Server.prototype, 'renderToHTML', createWrapRenderToHTML(tracer, config))
-      this.wrap(Server.prototype, 'renderToHTMLWithComponents', createWrapRenderToHTMLWithComponents(tracer, config))
+      this.wrap(Server.prototype, 'renderErrorToHTML', createWrapRenderErrorToHTML(tracer, config))
+      this.wrap(Server.prototype, 'findPageComponents', createWrapFindPageComponents(tracer, config))
     },
     unpatch ({ default: Server }) {
       this.unwrap(Server.prototype, 'handleRequest')
       this.unwrap(Server.prototype, 'handleApiRequest')
       this.unwrap(Server.prototype, 'renderToHTML')
-      this.unwrap(Server.prototype, 'renderToHTMLWithComponents')
+      this.unwrap(Server.prototype, 'renderErrorToHTML')
+      this.unwrap(Server.prototype, 'findPageComponents')
+    }
+  },
+
+  {
+    name: 'next',
+    versions: ['>=11.1'],
+    file: 'dist/server/next-server.js',
+    patch ({ default: Server }, tracer, config) {
+      config = normalizeConfig(config)
+
+      this.wrap(Server.prototype, 'handleRequest', createWrapHandleRequest(tracer, config))
+      this.wrap(Server.prototype, 'handleApiRequest', createWrapHandleApiRequest(tracer, config))
+      this.wrap(Server.prototype, 'renderToResponse', createWrapRenderToResponse(tracer, config))
+      this.wrap(Server.prototype, 'renderErrorToResponse', createWrapRenderErrorToResponse(tracer, config))
+      this.wrap(Server.prototype, 'findPageComponents', createWrapFindPageComponents(tracer, config))
+    },
+    unpatch ({ default: Server }) {
+      this.unwrap(Server.prototype, 'handleRequest')
+      this.unwrap(Server.prototype, 'handleApiRequest')
+      this.unwrap(Server.prototype, 'renderToResponse')
+      this.unwrap(Server.prototype, 'renderErrorToResponse')
+      this.unwrap(Server.prototype, 'findPageComponents')
     }
   }
 ]

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

@@ -1 +1 @@
-module.exports = '0.36.2'
+module.exports = '0.36.6'

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

@@ -1,7 +1,8 @@
 'use strict'
 
-const dgram = require('dgram')
 const lookup = require('dns').lookup // cache to avoid instrumentation
+const dgram = require('dgram')
+const isIP = require('net').isIP
 const log = require('./log')
 
 const MAX_BUFFER_SIZE = 1024 // limit from the agent
@@ -11,6 +12,7 @@ class Client {
     options = options || {}
 
     this._host = options.host || 'localhost'
+    this._family = isIP(this._host)
     this._port = options.port || 8125
     this._prefix = options.prefix || ''
     this._tags = options.tags || []
@@ -36,11 +38,14 @@ class Client {
 
     this._queue = []
 
-    lookup(this._host, (err, address, family) => {
-      if (err) return log.error(err)
-
-      queue.forEach(buffer => this._send(address, family, buffer))
-    })
+    if (this._family !== 0) {
+      this._sendAll(queue, this._host, this._family)
+    } else {
+      lookup(this._host, (err, address, family) => {
+        if (err) return log.error(err)
+        this._sendAll(queue, address, family)
+      })
+    }
   }
 
   _send (address, family, buffer) {
@@ -51,6 +56,10 @@ class Client {
     socket.send(buffer, 0, buffer.length, this._port, address)
   }
 
+  _sendAll (queue, address, family) {
+    queue.forEach((buffer) => this._send(address, family, buffer))
+  }
+
   _add (stat, value, type, tags) {
     const message = `${this._prefix + stat}:${value}|${type}`
 

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

@@ -1,15 +1,9 @@
 'use strict'
 
-const hdr = require('hdr-histogram-js')
-
-const highestTrackableValue = 3.6e12 // 1 hour
+const { DDSketch } = require('@datadog/sketches-js')
 
 class Histogram {
   constructor () {
-    this._histogram = hdr.build({
-      highestTrackableValue
-    })
-
     this.reset()
   }
 
@@ -22,7 +16,7 @@ class Histogram {
   get p95 () { return this.percentile(95) }
 
   percentile (percentile) {
-    return this._histogram.getValueAtPercentile(percentile)
+    return this._histogram.getValueAtQuantile(percentile / 100) || 0
   }
 
   record (value) {
@@ -36,7 +30,7 @@ class Histogram {
     this._count++
     this._sum += value
 
-    this._histogram.recordValue(value)
+    this._histogram.accept(value)
   }
 
   reset () {
@@ -45,7 +39,7 @@ class Histogram {
     this._sum = 0
     this._count = 0
 
-    this._histogram.reset()
+    this._histogram = new DDSketch()
   }
 }
 

package/packages/dd-trace/src/plugins/util/web.js

@@ -302,6 +302,7 @@ function addAllowHeaders (req, headers) {
   const allowHeaders = splitHeader(headers['access-control-allow-headers'])
   const requestHeaders = splitHeader(req.headers['access-control-request-headers'])
   const contextHeaders = [
+    'x-datadog-origin',
     'x-datadog-parent-id',
     'x-datadog-sampled',
     'x-datadog-sampling-priority',

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

@@ -6,7 +6,6 @@ const DatadogTracer = require('./tracer')
 const Config = require('./config')
 const Instrumenter = require('./instrumenter')
 const metrics = require('./metrics')
-const profiler = require('./profiler')
 const log = require('./log')
 const { setStartupLogInstrumenter } = require('./startup-log')
 const analyticsSampler = require('./analytics_sampler')
@@ -33,7 +32,15 @@ class Tracer extends BaseTracer {
         log.use(config.logger)
         log.toggle(config.debug, config.logLevel, this)
 
-        profiler.start(config)
+        if (config.hasOwnProperty('profiling') && config.profiling.enabled) {
+          // do not stop tracer initialization if the profiler fails to be imported
+          try {
+            const profiler = require('./profiler')
+            profiler.start(config)
+          } catch (e) {
+            log.error(e)
+          }
+        }
 
         if (config.enabled) {
           if (config.runtimeMetrics) {

package/scripts/prebuilds.js

@@ -50,7 +50,7 @@ function validatePrebuilds () {
           const content = fs.readFileSync(path.join('prebuilds', platform, file))
           const sum = fs.readFileSync(path.join('prebuilds', platform, `${file}.sha1`), 'ascii')
 
-          if (sum !== checksum(content)) {
+          if (sum !== checksum(content, { algorithm: 'sha256' })) {
             throw new Error(`Invalid checksum for "prebuilds/${platform}/${file}".`)
           }
         })
@@ -62,7 +62,7 @@ function validatePrebuilds () {
 
 function createChecksum () {
   const file = path.join(os.tmpdir(), 'prebuilds.tgz')
-  const sum = checksum(fs.readFileSync(file))
+  const sum = checksum(fs.readFileSync(file), { algorithm: 'sha256' })
 
   fs.writeFileSync(`${file}.sha1`, sum)
 }

package/scripts/prepublish.js

@@ -145,7 +145,7 @@ function validatePrebuilds () {
   const content = fs.readFileSync(file)
   const sum = fs.readFileSync(path.join(`${file}.sha1`), 'ascii')
 
-  if (sum !== checksum(content)) {
+  if (sum !== checksum(content, { algorithm: 'sha256' })) {
     throw new Error('Invalid checksum for "prebuilds.tgz".')
   }
 }

package/scripts/version.js

@@ -33,12 +33,12 @@ exec(`git checkout ${currentBranch}`)
 function bump (newVersion) {
   pkg.version = newVersion
 
-  exec(`git checkout -b v${newVersion}`)
+  exec(`git checkout -b v${newVersion}-bump`)
   write('package.json', JSON.stringify(pkg, null, 2) + '\n')
   write('packages/dd-trace/lib/version.js', `module.exports = '${newVersion}'\n`)
   add('package.json')
   add('packages/dd-trace/lib/version.js')
-  exec(`git commit -m v"${newVersion}"`)
+  exec(`git commit -m "v${newVersion}"`)
   exec(`git push -u origin HEAD`)
 }
 

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/).