dd-trace 3.4.0 → 3.6.0

package/index.d.ts

@@ -189,6 +189,31 @@ export declare interface SamplingRule {
   name?: string | RegExp
 }
 
+/**
+ * Span sampling rules to ingest single spans where the enclosing trace is dropped
+ */
+export declare interface SpanSamplingRule {
+  /**
+   * Sampling rate for this rule. Will default to 1.0 (always) if not provided.
+   */
+  sampleRate?: Number
+
+  /**
+   * Maximum number of spans matching a span sampling rule to be allowed per second.
+   */
+  maxPerSecond?: Number
+
+  /**
+   * Service name or pattern on which to apply this rule. The rule will apply to all services if not provided.
+   */
+  service?: string
+
+  /**
+   * Operation name or pattern on which to apply this rule. The rule will apply to all operation names if not provided.
+   */
+  name?: string
+}
+
 /**
  * List of options available to the tracer.
  */
@@ -283,6 +308,12 @@ export declare interface TracerOptions {
    */
   samplingRules?: SamplingRule[]
 
+  /**
+   * Span sampling rules that take effect when the enclosing trace is dropped, to ingest single spans
+   * @default []
+   */
+  spanSamplingRules?: SpanSamplingRule[]
+
   /**
    * Interval in milliseconds at which the tracer will submit traces to the agent.
    * @default 2000
@@ -598,6 +629,7 @@ interface Plugins {
   "mysql2": plugins.mysql2;
   "net": plugins.net;
   "next": plugins.next;
+  "opensearch": plugins.opensearch;
   "oracledb": plugins.oracledb;
   "paperplane": plugins.paperplane;
   "pg": plugins.pg;
@@ -730,7 +762,7 @@ declare namespace plugins {
      * status code as its only parameter and return `true` for success or `false`
      * for errors.
      *
-     * @default code => code < 400
+     * @default code => code < 400 || code >= 500
      */
     validateStatus?: (code: number) => boolean;
 
@@ -764,7 +796,7 @@ declare namespace plugins {
      * status code as its only parameter and return `true` for success or `false`
      * for errors.
      *
-     * @default code => code < 400
+     * @default code => code < 400 || code >= 500
      */
     validateStatus?: (code: number) => boolean;
   }
@@ -1255,6 +1287,12 @@ declare namespace plugins {
     };
   }
 
+  /**
+   * This plugin automatically instruments the
+   * [opensearch](https://github.com/opensearch-project/opensearch-js) module.
+   */
+  interface opensearch extends elasticsearch {}
+
   /**
    * This plugin automatically instruments the
    * [oracledb](https://github.com/oracle/node-oracledb) module.

package/package.json

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

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

@@ -142,5 +142,3 @@ addHook({
 
   return Runtime
 })
-
-module.exports = { pickleHook, testCaseHook }

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

@@ -7,76 +7,80 @@ const {
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
-const startCh = channel('apm:elasticsearch:query:start')
-const finishCh = channel('apm:elasticsearch:query:finish')
-const errorCh = channel('apm:elasticsearch:query:error')
-
 addHook({ name: '@elastic/transport', file: 'lib/Transport.js', versions: ['>=8'] }, (exports) => {
-  shimmer.wrap(exports.default.prototype, 'request', wrapRequest)
+  shimmer.wrap(exports.default.prototype, 'request', createWrapRequest('elasticsearch'))
   return exports
 })
 
 addHook({ name: '@elastic/elasticsearch', file: 'lib/Transport.js', versions: ['>=5.6.16 <8', '>=8'] }, Transport => {
-  shimmer.wrap(Transport.prototype, 'request', wrapRequest)
+  shimmer.wrap(Transport.prototype, 'request', createWrapRequest('elasticsearch'))
   return Transport
 })
 
 addHook({ name: 'elasticsearch', file: 'src/lib/transport.js', versions: ['>=10'] }, Transport => {
-  shimmer.wrap(Transport.prototype, 'request', wrapRequest)
+  shimmer.wrap(Transport.prototype, 'request', createWrapRequest('elasticsearch'))
   return Transport
 })
 
-function wrapRequest (request) {
-  return function (params, options, cb) {
-    if (!startCh.hasSubscribers) {
-      return request.apply(this, arguments)
-    }
+function createWrapRequest (name) {
+  const startCh = channel(`apm:${name}:query:start`)
+  const finishCh = channel(`apm:${name}:query:finish`)
+  const errorCh = channel(`apm:${name}:query:error`)
 
-    if (!params) return request.apply(this, arguments)
+  return function wrapRequest (request) {
+    return function (params, options, cb) {
+      if (!startCh.hasSubscribers) {
+        return request.apply(this, arguments)
+      }
 
-    const parentResource = new AsyncResource('bound-anonymous-fn')
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
+      if (!params) return request.apply(this, arguments)
 
-    return asyncResource.runInAsyncScope(() => {
-      startCh.publish({ params })
+      const parentResource = new AsyncResource('bound-anonymous-fn')
+      const asyncResource = new AsyncResource('bound-anonymous-fn')
 
-      try {
-        const lastIndex = arguments.length - 1
-        cb = arguments[lastIndex]
+      return asyncResource.runInAsyncScope(() => {
+        startCh.publish({ params })
 
-        if (typeof cb === 'function') {
-          cb = parentResource.bind(cb)
+        try {
+          const lastIndex = arguments.length - 1
+          cb = arguments[lastIndex]
 
-          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') {
-            const onResolve = asyncResource.bind(() => finish(params))
-            const onReject = asyncResource.bind(e => finish(params, e))
+          if (typeof cb === 'function') {
+            cb = parentResource.bind(cb)
 
-            promise.then(onResolve, onReject)
+            arguments[lastIndex] = asyncResource.bind(function (error) {
+              finish(params, error)
+              return cb.apply(null, arguments)
+            })
+            return request.apply(this, arguments)
           } else {
-            finish(params)
+            const promise = request.apply(this, arguments)
+            if (promise && typeof promise.then === 'function') {
+              const onResolve = asyncResource.bind(() => finish(params))
+              const onReject = asyncResource.bind(e => finish(params, e))
+
+              promise.then(onResolve, onReject)
+            } else {
+              finish(params)
+            }
+            return promise
           }
-          return promise
-        }
-      } catch (err) {
-        err.stack // trigger getting the stack at the original throwing point
-        errorCh.publish(err)
+        } catch (err) {
+          err.stack // trigger getting the stack at the original throwing point
+          errorCh.publish(err)
 
-        throw err
-      }
-    })
+          throw err
+        }
+      })
+    }
   }
-}
 
-function finish (params, error) {
-  if (error) {
-    errorCh.publish(error)
+  function finish (params, error) {
+    if (error) {
+      errorCh.publish(error)
+    }
+    finishCh.publish({ params })
   }
-  finishCh.publish({ params })
 }
+
+module.exports = { createWrapRequest }

package/packages/datadog-instrumentations/src/google-cloud-pubsub.js

@@ -65,7 +65,7 @@ addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'] }, (obj) => {
       try {
         return emit.apply(this, arguments)
       } catch (err) {
-        receiveErrorCh.publish({ err, message })
+        receiveErrorCh.publish(err)
         throw err
       }
     })

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

@@ -10,6 +10,7 @@ module.exports = {
   '@jest/core': () => require('../jest'),
   '@koa/router': () => require('../koa'),
   '@node-redis/client': () => require('../redis'),
+  '@opensearch-project/opensearch': () => require('../opensearch'),
   '@redis/client': () => require('../redis'),
   'amqp10': () => require('../amqp10'),
   'amqplib': () => require('../amqplib'),

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

@@ -8,82 +8,56 @@ const startCh = channel('apm:mariadb:query:start')
 const finishCh = channel('apm:mariadb:query:finish')
 const errorCh = channel('apm:mariadb:query:error')
 
-function wrapConnectionAddCommand (addCommand) {
-  return function (cmd) {
-    if (!startCh.hasSubscribers) return addCommand.apply(this, arguments)
+function wrapCommandStart (start) {
+  return function () {
+    if (!startCh.hasSubscribers) return start.apply(this, arguments)
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-    const name = cmd && cmd.constructor && cmd.constructor.name
-    const isCommand = typeof cmd.start === 'function'
-    const isQuery = isCommand && (name === 'Execute' || name === 'Query')
-
-    // TODO: consider supporting all commands and not just queries
-    cmd.start = isQuery
-      ? wrapStart(cmd, cmd.start, asyncResource, this.opts)
-      : bindStart(cmd, cmd.start, asyncResource)
-
-    return asyncResource.bind(addCommand, this).apply(this, arguments)
-  }
-}
+    const callbackResource = new AsyncResource('bound-anonymous-fn')
 
-function bindStart (cmd, start, asyncResource) {
-  return asyncResource.bind(function (packet, connection) {
-    if (this.resolve) {
-      this.resolve = asyncResource.bind(this.resolve)
-    }
+    const resolve = callbackResource.bind(this.resolve)
+    const reject = callbackResource.bind(this.reject)
 
-    if (this.reject) {
-      this.reject = asyncResource.bind(this.reject)
-    }
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
 
-    return start.apply(this, arguments)
-  }, cmd)
+    shimmer.wrap(this, 'resolve', function wrapResolve () {
+      return function () {
+        asyncResource.runInAsyncScope(() => {
+          finishCh.publish()
+        })
+
+        return resolve.apply(this, arguments)
+      }
+    })
+
+    shimmer.wrap(this, 'reject', function wrapReject () {
+      return function (error) {
+        asyncResource.runInAsyncScope(() => {
+          errorCh.publish(error)
+          finishCh.publish()
+        })
+
+        return reject.apply(this, arguments)
+      }
+    })
+
+    return asyncResource.runInAsyncScope(() => {
+      startCh.publish({ sql: this.sql, conf: this.opts })
+      return start.apply(this, arguments)
+    })
+  }
 }
 
-function wrapStart (cmd, start, asyncResource, config) {
-  const callbackResource = new AsyncResource('bound-anonymous-fn')
+const name = 'mariadb'
+const versions = ['>=2.0.3']
 
-  return asyncResource.bind(function (packet, connection) {
-    if (!this.resolve || !this.reject) return start.apply(this, arguments)
+addHook({ name, file: 'lib/cmd/query.js', versions }, (Query) => {
+  shimmer.wrap(Query.prototype, 'start', wrapCommandStart)
 
-    const sql = cmd.statement ? cmd.statement.query : cmd.sql
+  return Query
+})
 
-    startCh.publish({ sql, conf: config })
+addHook({ name, file: 'lib/cmd/execute.js', versions }, (Query) => {
+  shimmer.wrap(Query.prototype, 'start', wrapCommandStart)
 
-    const resolve = callbackResource.bind(this.resolve)
-    const reject = callbackResource.bind(this.reject)
-
-    this.resolve = asyncResource.bind(function () {
-      finishCh.publish(undefined)
-      resolve.apply(this, arguments)
-    }, 'bound-anonymous-fn', this)
-
-    this.reject = asyncResource.bind(function (error) {
-      errorCh.publish(error)
-      finishCh.publish(undefined)
-      reject.apply(this, arguments)
-    }, 'bound-anonymous-fn', this)
-
-    this.start = start
-
-    try {
-      return start.apply(this, arguments)
-    } catch (err) {
-      errorCh.publish(err)
-    }
-  }, cmd)
-}
-
-addHook(
-  {
-    name: 'mariadb',
-    file: 'lib/connection.js',
-    versions: ['>=3']
-  },
-  (Connection) => {
-    shimmer.wrap(Connection.prototype, 'addCommandEnable', wrapConnectionAddCommand)
-    shimmer.wrap(Connection.prototype, 'addCommandEnablePipeline', wrapConnectionAddCommand)
-
-    return Connection
-  }
-)
+  return Query
+})

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

@@ -7,8 +7,8 @@ const skipCh = channel('ci:mocha:test:skip')
 const testFinishCh = channel('ci:mocha:test:finish')
 const parameterizedTestCh = channel('ci:mocha:test:parameterize')
 
-const testRunStartCh = channel('ci:mocha:run:start')
-const testRunFinishCh = channel('ci:mocha:run:finish')
+const testSessionStartCh = channel('ci:mocha:session:start')
+const testSessionFinishCh = channel('ci:mocha:session:finish')
 
 const testSuiteStartCh = channel('ci:mocha:test-suite:start')
 const testSuiteFinishCh = channel('ci:mocha:test-suite:finish')
@@ -92,13 +92,13 @@ function mochaHook (Runner) {
         status = 'fail'
       }
       testFileToSuiteAr.clear()
-      testRunFinishCh.publish(status)
+      testSessionFinishCh.publish(status)
     }))
 
     this.once('start', testRunAsyncResource.bind(function () {
       const processArgv = process.argv.slice(2).join(' ')
       const command = `mocha ${processArgv}`
-      testRunStartCh.publish(command)
+      testSessionStartCh.publish(command)
     }))
 
     this.on('suite', function (suite) {
@@ -245,13 +245,6 @@ function mochaHook (Runner) {
     return run.apply(this, arguments)
   })
 
-  shimmer.wrap(Runner.prototype, 'runTests', runTests => function () {
-    if (!testRunFinishCh.hasSubscribers) {
-      return runTests.apply(this, arguments)
-    }
-    return runTests.apply(this, arguments)
-  })
-
   return Runner
 }
 
@@ -285,6 +278,9 @@ addHook({
   file: 'lib/runnable.js'
 }, (Runnable) => {
   shimmer.wrap(Runnable.prototype, 'run', run => function () {
+    if (!testStartCh.hasSubscribers) {
+      return run.apply(this, arguments)
+    }
     const isBeforeEach = this.parent._beforeEach.includes(this)
     const isAfterEach = this.parent._afterEach.includes(this)
 
@@ -300,13 +296,15 @@ addHook({
       const test = isTestHook ? this.ctx.currentTest : this
       const asyncResource = getTestAsyncResource(test)
 
-      // we bind the test fn to the correct async resource
-      const newFn = asyncResource.bind(this.fn)
+      if (asyncResource) {
+        // we bind the test fn to the correct async resource
+        const newFn = asyncResource.bind(this.fn)
 
-      // we store the original function, not to lose it
-      originalFns.set(newFn, this.fn)
+        // we store the original function, not to lose it
+        originalFns.set(newFn, this.fn)
 
-      this.fn = newFn
+        this.fn = newFn
+      }
     }
 
     return run.apply(this, arguments)
@@ -318,5 +316,3 @@ addHook({
   name: 'mocha-each',
   versions: ['>=2.0.1']
 }, mochaEachHook)
-
-module.exports = { mochaHook, mochaEachHook }

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

@@ -0,0 +1,10 @@
+'use strict'
+
+const { addHook } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+const { createWrapRequest } = require('./elasticsearch')
+
+addHook({ name: '@opensearch-project/opensearch', file: 'lib/Transport.js', versions: ['1.1.0'] }, Transport => {
+  shimmer.wrap(Transport.prototype, 'request', createWrapRequest('opensearch'))
+  return Transport
+})

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

@@ -40,9 +40,10 @@ function wrapQuery (query) {
     const statement = pgQuery.text
     const callbackResource = new AsyncResource('bound-anonymous-fn')
     const asyncResource = new AsyncResource('bound-anonymous-fn')
+    const processId = this.processID
 
     return asyncResource.runInAsyncScope(() => {
-      startCh.publish({ params: this.connectionParameters, statement })
+      startCh.publish({ params: this.connectionParameters, statement, processId })
 
       const finish = asyncResource.bind(function (error) {
         if (error) {

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

@@ -54,6 +54,7 @@ function wrapFn (fn) {
       errorChannel.publish({ req, error })
       nextChannel.publish({ req })
       exitChannel.publish({ req })
+      throw error
     }
   }
 }

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

@@ -11,17 +11,22 @@ const circularBufferConstructor = Symbol('circularBufferConstructor')
 const inFlightDeliveries = Symbol('inFlightDeliveries')
 
 const patched = new WeakSet()
-const dispatchCh = channel('apm:rhea:dispatch')
-const errorCh = channel('apm:rhea:error')
-const finishCh = channel('apm:rhea:finish')
 
-const encodeCh = channel('apm:rhea:encode')
+const startSendCh = channel('apm:rhea:send:start')
+const encodeSendCh = channel('apm:rhea:send:encode')
+const errorSendCh = channel('apm:rhea:send:error')
+const finishSendCh = channel('apm:rhea:send:finish')
+
+const startReceiveCh = channel('apm:rhea:receive:start')
+const dispatchReceiveCh = channel('apm:rhea:receive:dispatch')
+const errorReceiveCh = channel('apm:rhea:receive:error')
+const finishReceiveCh = channel('apm:rhea:receive:finish')
 
 const contexts = new WeakMap()
 
 addHook({ name: 'rhea', versions: ['>=1'] }, rhea => {
   shimmer.wrap(rhea.message, 'encode', encode => function (msg) {
-    encodeCh.publish(msg)
+    encodeSendCh.publish(msg)
     return encode.apply(this, arguments)
   })
 
@@ -29,9 +34,6 @@ addHook({ name: 'rhea', versions: ['>=1'] }, rhea => {
 })
 
 addHook({ name: 'rhea', versions: ['>=1'], file: 'lib/link.js' }, obj => {
-  const startSendCh = channel('apm:rhea:send:start')
-  const startReceiveCh = channel('apm:rhea:receive:start')
-
   const Sender = obj.Sender
   const Receiver = obj.Receiver
   shimmer.wrap(Sender.prototype, 'send', send => function (msg, tag, format) {
@@ -58,7 +60,7 @@ addHook({ name: 'rhea', versions: ['>=1'], file: 'lib/link.js' }, obj => {
       try {
         return delivery
       } catch (err) {
-        errorCh.publish(err)
+        errorSendCh.publish(err)
 
         throw err
       }
@@ -87,7 +89,7 @@ addHook({ name: 'rhea', versions: ['>=1'], file: 'lib/link.js' }, obj => {
         try {
           return dispatch.apply(this, arguments)
         } catch (err) {
-          errorCh.publish(err)
+          errorReceiveCh.publish(err)
 
           throw err
         }
@@ -111,8 +113,9 @@ addHook({ name: 'rhea', versions: ['>=1'], file: 'lib/connection.js' }, Connecti
           if (!asyncResource) return
 
           asyncResource.runInAsyncScope(() => {
-            errorCh.publish(error)
-            finish(delivery, null)
+            errorReceiveCh.publish(error)
+            beforeFinish(delivery, null)
+            finishReceiveCh.publish()
           })
         })
       }
@@ -148,7 +151,7 @@ function wrapDeliveryUpdate (obj, update) {
     const cb = asyncResource.bind(update)
     return AsyncResource.bind(function wrappedUpdate (settled, stateData) {
       const state = getStateFromData(stateData)
-      dispatchCh.publish({ state })
+      dispatchReceiveCh.publish({ state })
       return cb.apply(this, arguments)
     })
   }
@@ -184,7 +187,8 @@ function patchCircularBuffer (proto, Session) {
                 const state = remoteState && remoteState.constructor
                   ? entry.remote_state.constructor.composite_type : undefined
                 asyncResource.runInAsyncScope(() => {
-                  return finish(entry, state)
+                  beforeFinish(entry, state)
+                  finishSendCh.publish()
                 })
               }
 
@@ -212,13 +216,12 @@ function addToInFlightDeliveries (connection, delivery) {
   deliveries.add(delivery)
 }
 
-function finish (delivery, state) {
+function beforeFinish (delivery, state) {
   const obj = contexts.get(delivery)
   if (obj) {
     if (state) {
-      dispatchCh.publish({ state })
+      dispatchReceiveCh.publish({ state })
     }
-    finishCh.publish(undefined)
     if (obj.connection && obj.connection[inFlightDeliveries]) {
       obj.connection[inFlightDeliveries].delete(delivery)
     }

package/packages/datadog-plugin-amqp10/src/consumer.js

@@ -0,0 +1,32 @@
+'use strict'
+
+const ConsumerPlugin = require('../../dd-trace/src/plugins/consumer')
+const { getAddress, getShortName } = require('./util')
+
+class Amqp10ConsumerPlugin extends ConsumerPlugin {
+  static get name () { return 'amqp10' }
+  static get system () { return 'amqp' }
+
+  start ({ link }) {
+    const source = getShortName(link)
+    const address = getAddress(link)
+
+    this.startSpan('amqp.receive', {
+      service: this.config.service || `${this.tracer._service}-amqp`,
+      resource: ['receive', source].filter(v => v).join(' '),
+      type: 'worker',
+      kind: 'consumer',
+      meta: {
+        'amqp.link.source.address': source,
+        'amqp.link.role': 'receiver',
+        'amqp.link.name': link.name,
+        'amqp.link.handle': link.handle,
+        'amqp.connection.host': address.host,
+        'amqp.connection.port': address.port,
+        'amqp.connection.user': address.user
+      }
+    })
+  }
+}
+
+module.exports = Amqp10ConsumerPlugin