dd-trace 2.0.0-beta.0 → 2.1.1

package/MIGRATING.md

@@ -0,0 +1,65 @@
+# Migrating
+
+This guide describes the steps to upgrade dd-trace from a major version to the
+next. If you are having any issues related to migrating, please feel free to
+open an issue or contact our [support](https://www.datadoghq.com/support/) team.
+
+## 1.0 to 2.0
+
+### Configuration
+
+The following configuraton options are no longer available programmatically and
+must be configured using these environment variables:
+
+* `enabled` -> `DD_TRACE_ENABLED=true|false`
+* `debug` -> `DD_TRACE_DEBUG=true|false`
+
+If environment variables were already used for these options, no action is
+needed.
+
+The following configuration options were completely removed and will no longer
+have any effect:
+
+* `scope`
+
+Startup logs are now disabled by default and can be enabled if needed with
+`DD_TRACE_STARTUP_LOGS=true`.
+
+### Removed APIs
+
+The original scope manager has been replaced several years ago and has now been
+removed. Any code referencing `tracer.scopeManager()` should be removed or
+replaced with `tracer.scope()` which is documented
+[here](https://datadoghq.dev/dd-trace-js/#scope-manager).
+
+### Nested objects as tags
+
+Support for nested objects as tags as been removed. When adding an object as a
+tag value, only properties that exist on that object directly will be added as
+tags. If nested properties are also needed, these should be added by hand.
+
+For example:
+
+```js
+const obj = {
+  a: 'foo',
+  b: {
+    c: 'bar'
+  }
+}
+
+// 1.0
+span.setTag('test', obj) // add test.a and test.b.c
+
+// 2.0
+span.setTag('test', obj) // add test.a
+span.setTag('test.b', obj.b) // add test.b.c
+```
+
+Arrays are no longer supported and must be converted to string manually.
+
+### Outgoing request filtering
+
+Outgoing request filtering is no longer supported and is now only available for
+incoming requests. This means that the `blocklist` and `allowlist` options on
+the `http` integration no longer have any effect.

package/NOTICE

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "2.0.0-beta.0",
+  "version": "2.1.1",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -61,7 +61,7 @@
     "node": ">=12"
   },
   "dependencies": {
-    "@datadog/native-appsec": "^0.8.0",
+    "@datadog/native-appsec": "^0.8.1",
     "@datadog/native-metrics": "^1.1.0",
     "@datadog/pprof": "^0.3.0",
     "@datadog/sketches-js": "^1.0.4",

package/packages/datadog-instrumentations/index.js

@@ -3,6 +3,7 @@
 require('./src/dns')
 require('./src/memcached')
 require('./src/mysql')
+require('./src/mysql2')
 require('./src/bluebird')
 require('./src/when')
 require('./src/promise')

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const { channel, addHook, bind } = require('./helpers/instrument')
+const { channel, addHook, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
 const rrtypes = {
@@ -53,7 +53,7 @@ function wrap (prefix, fn, expectedArgs, rrtype) {
   const errorCh = channel(prefix + ':error')
 
   const wrapped = function () {
-    const cb = bind(arguments[arguments.length - 1])
+    const cb = AsyncResource.bind(arguments[arguments.length - 1])
     if (
       !startCh.hasSubscribers ||
       arguments.length < expectedArgs ||

package/packages/datadog-instrumentations/src/helpers/instrument.js

@@ -90,32 +90,31 @@ function getBasedir (id) {
 }
 
 if (semver.satisfies(process.versions.node, '>=16.0.0')) {
-  exports.bind = AsyncResource.bind
-  exports.bindAsyncResource = AsyncResource.prototype.bind
+  exports.AsyncResource = AsyncResource
 } else {
-  exports.bindAsyncResource = function bindAsyncResource (fn, thisArg) {
-    thisArg = thisArg || this
-    const ret = this.runInAsyncScope.bind(this, fn, thisArg)
-    Object.defineProperties(ret, {
-      'length': {
-        configurable: true,
-        enumerable: false,
-        value: fn.length,
-        writable: false
-      },
-      'asyncResource': {
-        configurable: true,
-        enumerable: true,
-        value: this,
-        writable: true
-      }
-    })
-    return ret
-  }
+  exports.AsyncResource = class extends AsyncResource {
+    static bind (fn, type, thisArg) {
+      type = type || fn.name
+      return (new exports.AsyncResource(type || 'bound-anonymous-fn')).bind(fn, thisArg)
+    }
 
-  exports.bind = function bind (fn, type, thisArg) {
-    type = type || fn.name
-    const ar = new AsyncResource(type || 'bound-anonymous-fn')
-    return exports.bindAsyncResource.call(ar, fn, thisArg)
+    bind (fn, thisArg = this) {
+      const ret = this.runInAsyncScope.bind(this, fn, thisArg)
+      Object.defineProperties(ret, {
+        'length': {
+          configurable: true,
+          enumerable: false,
+          value: fn.length,
+          writable: false
+        },
+        'asyncResource': {
+          configurable: true,
+          enumerable: true,
+          value: this,
+          writable: true
+        }
+      })
+      return ret
+    }
   }
 }

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

@@ -1,11 +1,9 @@
 'use strict'
 
-const { AsyncResource } = require('async_hooks')
 const {
   channel,
   addHook,
-  bind,
-  bindAsyncResource
+  AsyncResource
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -27,9 +25,9 @@ addHook({ name: 'memcached', versions: ['>=2.2'] }, Memcached => {
 
     const wrappedQueryCompiler = function () {
       const query = queryCompiler.apply(this, arguments)
-      const callback = bindAsyncResource.call(asyncResource, query.callback)
+      const callback = asyncResource.bind(query.callback)
 
-      query.callback = bind(function (err) {
+      query.callback = AsyncResource.bind(function (err) {
         if (err) {
           errorCh.publish(err)
         }

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

@@ -1,11 +1,9 @@
 'use strict'
 
-const { AsyncResource } = require('async_hooks')
 const {
   channel,
   addHook,
-  bind,
-  bindAsyncResource
+  AsyncResource
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -22,16 +20,16 @@ addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connect
     }
 
     const sql = arguments[0].sql ? arguments[0].sql : arguments[0]
-    const startArgs = [sql, this.config]
+    const conf = this.config
 
-    startCh.publish(startArgs)
+    startCh.publish({ sql, conf })
 
     try {
       const res = query.apply(this, arguments)
 
       if (res._callback) {
-        const cb = bindAsyncResource.call(asyncResource, res._callback)
-        res._callback = bind(function (error, result) {
+        const cb = asyncResource.bind(res._callback)
+        res._callback = AsyncResource.bind(function (error, result) {
           if (error) {
             errorCh.publish(error)
           }
@@ -40,7 +38,7 @@ addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connect
           return cb.apply(this, arguments)
         })
       } else {
-        const cb = bind(function () {
+        const cb = AsyncResource.bind(function () {
           asyncEndCh.publish(undefined)
         })
         res.on('end', cb)
@@ -62,7 +60,7 @@ addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connect
 
 addHook({ name: 'mysql', file: 'lib/Pool.js', versions: ['>=2'] }, Pool => {
   shimmer.wrap(Pool.prototype, 'getConnection', getConnection => function (cb) {
-    arguments[0] = bind(cb)
+    arguments[0] = AsyncResource.bind(cb)
     return getConnection.apply(this, arguments)
   })
   return Pool

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

@@ -0,0 +1,76 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+addHook({ name: 'mysql2', file: 'lib/connection.js', versions: ['>=1'] }, Connection => {
+  const startCh = channel('apm:mysql2:query:start')
+  const asyncEndCh = channel('apm:mysql2:query:async-end')
+  const endCh = channel('apm:mysql2:query:end')
+  const errorCh = channel('apm:mysql2:query:error')
+
+  shimmer.wrap(Connection.prototype, 'addCommand', addCommand => function (cmd) {
+    if (!startCh.hasSubscribers) return addCommand.apply(this, arguments)
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    const name = cmd && cmd.constructor && cmd.constructor.name
+    const isCommand = typeof cmd.execute === 'function'
+    const isQuery = isCommand && (name === 'Execute' || name === 'Query')
+
+    // TODO: consider supporting all commands and not just queries
+    cmd.execute = isQuery
+      ? wrapExecute(cmd, cmd.execute, asyncResource, this.config)
+      : bindExecute(cmd, cmd.execute, asyncResource)
+
+    return asyncResource.bind(addCommand, this).apply(this, arguments)
+  })
+
+  return Connection
+
+  function bindExecute (cmd, execute, asyncResource) {
+    return asyncResource.bind(function executeWithTrace (packet, connection) {
+      if (this.onResult) {
+        this.onResult = asyncResource.bind(this.onResult)
+      }
+
+      return execute.apply(this, arguments)
+    }, cmd)
+  }
+
+  function wrapExecute (cmd, execute, asyncResource, config) {
+    return asyncResource.bind(function executeWithTrace (packet, connection) {
+      const sql = cmd.statement ? cmd.statement.query : cmd.sql
+
+      startCh.publish({ sql, conf: config })
+
+      if (this.onResult) {
+        const onResult = asyncResource.bind(this.onResult)
+
+        this.onResult = AsyncResource.bind(function (error) {
+          if (error) {
+            errorCh.publish(error)
+          }
+          asyncEndCh.publish(undefined)
+          onResult.apply(this, arguments)
+        }, 'bound-anonymous-fn', this)
+      } else {
+        this.on('error', AsyncResource.bind(error => errorCh.publish(error)))
+        this.on('end', AsyncResource.bind(() => asyncEndCh.publish(undefined)))
+      }
+
+      this.execute = execute
+
+      try {
+        return execute.apply(this, arguments)
+      } catch (err) {
+        errorCh.publish(err)
+      } finally {
+        endCh.publish(undefined)
+      }
+    }, cmd)
+  }
+})

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

@@ -6,8 +6,16 @@ const shimmer = require('../../datadog-shimmer')
 
 addHook({
   name: 'q',
-  versions: ['>=1']
+  versions: ['1']
 }, Q => {
   shimmer.wrap(Q.makePromise.prototype, 'then', wrapThen)
   return Q
 })
+
+addHook({
+  name: 'q',
+  versions: ['>=2']
+}, Q => {
+  shimmer.wrap(Q.Promise.prototype, 'then', wrapThen)
+  return Q
+})

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

@@ -10,7 +10,8 @@ const services = {
   s3: getService(require('./services/s3')),
   redshift: getService(require('./services/redshift')),
   sns: getService(require('./services/sns')),
-  sqs: getService(require('./services/sqs'))
+  sqs: getService(require('./services/sqs')),
+  eventbridge: getService(require('./services/eventbridge'))
 }
 
 function getService (Service) {
@@ -78,8 +79,8 @@ const helpers = {
   requestInject (span, request, serviceName, tracer) {
     if (!span) return
 
-    const inject = services[serviceName] && services[serviceName].requestInject
-    if (inject) inject(span, request, tracer)
+    const service = services[serviceName] && services[serviceName]
+    if (service && service.requestInject) service.requestInject(span, request, tracer)
   },
 
   wrapCb (cb, serviceName, tags, request, tracer, childOf) {

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

@@ -0,0 +1,48 @@
+'use strict'
+const log = require('../../../dd-trace/src/log')
+class EventBridge {
+  generateTags (params, operation, response) {
+    if (!params || !params.source) return {}
+
+    return {
+      'resource.name': `${operation} ${params.source}`,
+      'aws.eventbridge.source': params.source
+    }
+  }
+
+  /**
+   * 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) {
+    const operation = request.operation
+    if (operation === 'putEvents' &&
+      request.params &&
+      request.params.Entries &&
+      request.params.Entries.length > 0 &&
+      request.params.Entries[0].Detail) {
+      try {
+        const details = JSON.parse(request.params.Entries[0].Detail)
+        details._datadog = {}
+        tracer.inject(span, 'text_map', details._datadog)
+        const finalData = JSON.stringify(details)
+        const byteSize = Buffer.byteLength(finalData)
+        if (byteSize >= (1024 * 256)) {
+          log.info('Payload size too large to pass context')
+          return
+        }
+        request.params.Entries[0].Detail = finalData
+      } catch (e) {
+        log.error(e)
+      }
+    }
+  }
+}
+module.exports = EventBridge

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

@@ -1,15 +1,65 @@
 'use strict'
-
+const log = require('../../../dd-trace/src/log')
 class Kinesis {
   generateTags (params, operation, response) {
-    const tags = {}
-
-    if (!params || !params.StreamName) return tags
+    if (!params || !params.StreamName) return {}
 
-    return Object.assign(tags, {
+    return {
       'resource.name': `${operation} ${params.StreamName}`,
       'aws.kinesis.stream_name': params.StreamName
-    })
+    }
+  }
+
+  // AWS-SDK will b64 kinesis payloads
+  // or will accept an already b64 encoded payload
+  // This method handles both
+  _tryParse (body) {
+    try {
+      return JSON.parse(body)
+    } catch (e) {
+      log.info('Not JSON string. Trying Base64 encoded JSON string')
+    }
+    try {
+      return JSON.parse(Buffer.from(body, 'base64').toString('ascii'), true)
+    } catch (e) {
+      return null
+    }
+  }
+
+  requestInject (span, request, tracer) {
+    const operation = request.operation
+    if (operation === 'putRecord' || operation === 'putRecords') {
+      if (!request.params) {
+        return
+      }
+
+      const traceData = {}
+      tracer.inject(span, 'text_map', traceData)
+      let injectPath
+      if (request.params.Records && request.params.Records.length > 0) {
+        injectPath = request.params.Records[0]
+      } else if (request.params.Data) {
+        injectPath = request.params
+      } else {
+        log.error('No valid payload passed, unable to pass trace context')
+        return
+      }
+      const parsedData = this._tryParse(injectPath.Data)
+      if (parsedData) {
+        parsedData._datadog = traceData
+        const finalData = JSON.stringify(parsedData)
+        const byteSize = Buffer.byteLength(finalData, 'ascii')
+        // Kinesis max payload size is 1MB
+        // So we must ensure adding DD context won't go over that (512b is an estimate)
+        if (byteSize >= 1048576) {
+          log.info('Payload size too large to pass context')
+          return
+        }
+        injectPath.Data = finalData
+      } else {
+        log.error('Unable to parse payload, unable to pass trace context')
+      }
+    }
   }
 }
 

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

@@ -1,21 +1,48 @@
 'use strict'
+const log = require('../../../dd-trace/src/log')
 
 class Sns {
   generateTags (params, operation, response) {
-    const tags = {}
+    if (!params) return {}
 
-    if (!params) return tags
+    if (!params.TopicArn && !(response.data && response.data.TopicArn)) return {}
 
-    if (!params.TopicArn && !(response.data && response.data.TopicArn)) return tags
-
-    return Object.assign(tags, {
+    return {
       'resource.name': `${operation} ${params.TopicArn || response.data.TopicArn}`,
       'aws.sns.topic_arn': params.TopicArn || response.data.TopicArn
-    })
+    }
 
     // TODO: should arn be sanitized or quantized in some way here,
     // for example if it contains a phone number?
   }
+
+  requestInject (span, request, tracer) {
+    const operation = request.operation
+    if (operation === 'publish' || operation === 'publishBatch') {
+      if (!request.params) {
+        request.params = {}
+      }
+      let injectPath
+      if (request.params.PublishBatchRequestEntries && request.params.PublishBatchRequestEntries.length > 0) {
+        injectPath = request.params.PublishBatchRequestEntries[0]
+      } else if (request.params.Message) {
+        injectPath = request.params
+      }
+      if (!injectPath.MessageAttributes) {
+        injectPath.MessageAttributes = {}
+      }
+      if (Object.keys(injectPath.MessageAttributes).length >= 10) { // SNS quota
+        log.info('Message attributes full, skipping trace context injection')
+        return
+      }
+      const ddInfo = {}
+      tracer.inject(span, 'text_map', ddInfo)
+      injectPath.MessageAttributes._datadog = {
+        DataType: 'String',
+        StringValue: JSON.stringify(ddInfo)
+      }
+    }
+  }
 }
 
 module.exports = Sns

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

@@ -12,7 +12,7 @@ class MySQLPlugin extends Plugin {
   constructor (...args) {
     super(...args)
 
-    this.addSub('apm:mysql:query:start', ([sql, conf]) => {
+    this.addSub(`apm:${this.constructor.name}:query:start`, ({ sql, conf }) => {
       const store = storage.getStore()
       const childOf = store ? store.span : store
       const span = this.tracer.startSpan('mysql.query', {
@@ -37,18 +37,18 @@ class MySQLPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub('apm:mysql:query:end', () => {
+    this.addSub(`apm:${this.constructor.name}:query:end`, () => {
       this.exit()
     })
 
-    this.addSub('apm:mysql:query:error', err => {
+    this.addSub(`apm:${this.constructor.name}:query:error`, err => {
       if (err) {
         const span = storage.getStore().span
         span.setTag('error', err)
       }
     })
 
-    this.addSub('apm:mysql:query:async-end', () => {
+    this.addSub(`apm:${this.constructor.name}:query:async-end`, () => {
       const span = storage.getStore().span
       span.finish()
     })

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

@@ -1,94 +1,11 @@
 'use strict'
 
-const Tags = require('opentracing').Tags
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
+const MySQLPlugin = require('../../datadog-plugin-mysql/src')
 
-function createWrapAddCommand (tracer, config) {
-  return function wrapAddCommand (addCommand) {
-    return function addCommandWithTrace (cmd) {
-      const name = cmd && cmd.constructor && cmd.constructor.name
-      const isCommand = typeof cmd.execute === 'function'
-      const isSupported = name === 'Execute' || name === 'Query'
-
-      if (isCommand && isSupported) {
-        cmd.execute = wrapExecute(tracer, config, cmd.execute)
-      }
-
-      return addCommand.apply(this, arguments)
-    }
+class MySQL2Plugin extends MySQLPlugin {
+  static get name () {
+    return 'mysql2'
   }
 }
 
-function wrapExecute (tracer, config, execute) {
-  const scope = tracer.scope()
-  const childOf = scope.active()
-
-  return function executeWithTrace (packet, connection) {
-    const connectionConfig = (connection && connection.config) || {}
-    const sql = this.statement ? this.statement.query : this.sql
-    const span = tracer.startSpan('mysql.query', {
-      childOf,
-      tags: {
-        [Tags.SPAN_KIND]: Tags.SPAN_KIND_RPC_CLIENT,
-        'service.name': config.service || `${tracer._service}-mysql`,
-        'resource.name': sql,
-        'span.type': 'sql',
-        'span.kind': 'client',
-        'db.type': 'mysql',
-        'db.user': connectionConfig.user,
-        'db.name': connectionConfig.database,
-        'out.host': connectionConfig.host,
-        'out.port': connectionConfig.port
-      }
-    })
-
-    analyticsSampler.sample(span, config.measured)
-
-    if (typeof this.onResult === 'function') {
-      this.onResult = wrapCallback(tracer, span, childOf, this.onResult)
-    } else {
-      this.on('error', error => span.addTags({ error }))
-      this.on('end', () => span.finish())
-    }
-
-    this.execute = execute
-
-    return scope.bind(execute, span).apply(this, arguments)
-  }
-}
-
-function wrapCallback (tracer, span, parent, done) {
-  return tracer.scope().bind((...args) => {
-    const [ error ] = args
-    span.addTags({ error })
-
-    span.finish()
-
-    done(...args)
-  }, parent)
-}
-
-module.exports = [
-  {
-    name: 'mysql2',
-    file: 'lib/connection.js',
-    versions: ['>=1'],
-    patch (Connection, tracer, config) {
-      this.wrap(Connection.prototype, 'addCommand', createWrapAddCommand(tracer, config))
-    },
-    unpatch (Connection) {
-      this.unwrap(Connection.prototype, 'addCommand')
-    }
-  },
-  {
-    name: 'mysql2',
-    file: 'lib/commands/command.js',
-    versions: ['>=1'],
-    patch (Command, tracer, config) {
-      tracer.scope().bind(Command.prototype)
-    },
-    unpatch (Command, tracer) {
-      tracer.scope().unbind(Command.prototype)
-    }
-  }
-]
+module.exports = MySQL2Plugin