dd-trace 5.52.0 → 5.54.0

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

@@ -2,8 +2,7 @@
 
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('./helpers/instrument')
 const kebabCase = require('../../datadog-core/src/utils/src/kebabcase')
 const shimmer = require('../../datadog-shimmer')
@@ -11,17 +10,25 @@ const shimmer = require('../../datadog-shimmer')
 const { NODE_MAJOR, NODE_MINOR } = require('../../../version')
 const MIN_VERSION = ((NODE_MAJOR > 22) || (NODE_MAJOR === 22 && NODE_MINOR >= 2)) ? '>=0.5.3' : '>=0.5.0'
 
-const startCh = channel('apm:amqplib:command:start')
-const finishCh = channel('apm:amqplib:command:finish')
-const errorCh = channel('apm:amqplib:command:error')
+const commandStartCh = channel('apm:amqplib:command:start')
+const commandFinishCh = channel('apm:amqplib:command:finish')
+const commandErrorCh = channel('apm:amqplib:command:error')
 
-let methods = {}
+const consumeStartCh = channel('apm:amqplib:consume:start')
+const consumeFinishCh = channel('apm:amqplib:consume:finish')
+
+const publishStartCh = channel('apm:amqplib:publish:start')
+const publishFinishCh = channel('apm:amqplib:publish:finish')
+const publishErrorCh = channel('apm:amqplib:publish:error')
+
+const methods = {}
 
 addHook({ name: 'amqplib', file: 'lib/defs.js', versions: [MIN_VERSION] }, defs => {
-  methods = Object.keys(defs)
-    .filter(key => Number.isInteger(defs[key]))
-    .filter(key => isCamelCase(key))
-    .reduce((acc, key) => Object.assign(acc, { [defs[key]]: kebabCase(key).replace('-', '.') }), {})
+  for (const [key, value] of Object.entries(defs)) {
+    if (Number.isInteger(value) && isCamelCase(key)) {
+      methods[value] = kebabCase(key).replaceAll('-', '.')
+    }
+  }
   return defs
 })
 
@@ -31,24 +38,29 @@ addHook({ name: 'amqplib', file: 'lib/channel_model.js', versions: [MIN_VERSION]
       if (message === null) {
         return message
       }
-      startCh.publish({ method: 'basic.get', message, fields: message.fields, queue })
-      // finish right away
-      finishCh.publish()
+      const ctx = { method: 'basic.get', message, fields: message.fields, queue }
+      consumeStartCh.runStores(ctx, () => {
+        // finish right away
+        consumeFinishCh.publish(ctx)
+      })
       return message
     })
   })
   shimmer.wrap(x.Channel.prototype, 'consume', consume => function (queue, callback, options) {
-    if (!startCh.hasSubscribers) {
+    if (!consumeStartCh.hasSubscribers) {
       return consume.apply(this, arguments)
     }
     arguments[1] = (message, ...args) => {
       if (message === null) {
         return callback(message, ...args)
       }
-      startCh.publish({ method: 'basic.deliver', message, fields: message.fields, queue })
-      const result = callback(message, ...args)
-      finishCh.publish()
-      return result
+      const ctx = { method: 'basic.deliver', message, fields: message.fields, queue }
+      return consumeStartCh.runStores(ctx, () => {
+        // finish right away
+        const result = callback(message, ...args)
+        consumeFinishCh.publish(ctx)
+        return result
+      })
     }
     return consume.apply(this, arguments)
   })
@@ -57,32 +69,36 @@ addHook({ name: 'amqplib', file: 'lib/channel_model.js', versions: [MIN_VERSION]
 
 addHook({ name: 'amqplib', file: 'lib/callback_model.js', versions: [MIN_VERSION] }, channel => {
   shimmer.wrap(channel.Channel.prototype, 'get', getMessage => function (queue, options, callback) {
-    if (!startCh.hasSubscribers) {
+    if (!commandStartCh.hasSubscribers) {
       return getMessage.apply(this, arguments)
     }
     arguments[2] = (error, message, ...args) => {
       if (error !== null || message === null) {
         return callback(error, message, ...args)
       }
-      startCh.publish({ method: 'basic.get', message, fields: message.fields, queue })
-      const result = callback(error, message, ...args)
-      finishCh.publish()
-      return result
+      const ctx = { method: 'basic.get', message, fields: message.fields, queue }
+      return consumeStartCh.runStores(ctx, () => {
+        const result = callback(error, message, ...args)
+        consumeFinishCh.publish(ctx)
+        return result
+      })
     }
     return getMessage.apply(this, arguments)
   })
   shimmer.wrap(channel.Channel.prototype, 'consume', consume => function (queue, callback) {
-    if (!startCh.hasSubscribers) {
+    if (!consumeStartCh.hasSubscribers) {
       return consume.apply(this, arguments)
     }
     arguments[1] = (message, ...args) => {
       if (message === null) {
         return callback(message, ...args)
       }
-      startCh.publish({ method: 'basic.deliver', message, fields: message.fields, queue })
-      const result = callback(message, ...args)
-      finishCh.publish()
-      return result
+      const ctx = { method: 'basic.deliver', message, fields: message.fields, queue }
+      return consumeStartCh.runStores(ctx, () => {
+        const result = callback(message, ...args)
+        consumeFinishCh.publish(ctx)
+        return result
+      })
     }
     return consume.apply(this, arguments)
   })
@@ -91,32 +107,36 @@ addHook({ name: 'amqplib', file: 'lib/callback_model.js', versions: [MIN_VERSION
 
 addHook({ name: 'amqplib', file: 'lib/channel.js', versions: [MIN_VERSION] }, channel => {
   shimmer.wrap(channel.Channel.prototype, 'sendImmediately', sendImmediately => function (method, fields) {
-    return instrument(sendImmediately, this, arguments, methods[method], fields)
+    return instrument(
+      sendImmediately, this, arguments, methods[method], fields, null, commandStartCh, commandFinishCh, commandErrorCh
+    )
   })
 
   shimmer.wrap(channel.Channel.prototype, 'sendMessage', sendMessage => function (fields) {
-    return instrument(sendMessage, this, arguments, 'basic.publish', fields, arguments[2])
+    return instrument(
+      sendMessage, this, arguments, 'basic.publish', fields, arguments[2],
+      publishStartCh, publishFinishCh, publishErrorCh
+    )
   })
   return channel
 })
 
-function instrument (send, channel, args, method, fields, message) {
+function instrument (send, channel, args, method, fields, message, startCh, finishCh, errorCh) {
   if (!startCh.hasSubscribers || method === 'basic.get') {
     return send.apply(channel, args)
   }
 
-  const asyncResource = new AsyncResource('bound-anonymous-fn')
-  return asyncResource.runInAsyncScope(() => {
-    startCh.publish({ channel, method, fields, message })
-
+  const ctx = { channel, method, fields, message }
+  return startCh.runStores(ctx, () => {
     try {
       return send.apply(channel, args)
     } catch (err) {
-      errorCh.publish(err)
+      ctx.error = err
+      errorCh.publish(ctx)
 
       throw err
     } finally {
-      finishCh.publish()
+      finishCh.publish(ctx)
     }
   })
 }

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

@@ -42,7 +42,7 @@ function wrapRecordExceptions (recordExceptions) {
     // this is mimicking apollo-gateways internal instrumentation
     // TODO: should we consider a mechanism to report all exceptions? since this method aggregates all exceptions
     // where as a span can only have one exception set on it at a time
-    generalErrorCh.publish({ error: errors[errors.length - 1] })
+    generalErrorCh.publish({ error: errors.at(-1) })
     return recordExceptions.apply(this, args)
   }
 }
@@ -50,7 +50,7 @@ function wrapRecordExceptions (recordExceptions) {
 function wrapStartActiveSpan (startActiveSpan) {
   return function (...args) {
     const firstArg = args[0]
-    const cb = args[args.length - 1]
+    const cb = args.at(-1)
     if (typeof firstArg !== 'string' || typeof cb !== 'function') return startActiveSpan.apply(this, args)
 
     const method = CHANNELS[firstArg]

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

@@ -54,7 +54,7 @@ function wrapDeserialize (deserialize, channelSuffix) {
 
 function wrapSmithySend (send) {
   return function (command, ...args) {
-    const cb = args[args.length - 1]
+    const cb = args.at(-1)
     const innerAr = new AsyncResource('apm:aws:request:inner')
     const outerAr = new AsyncResource('apm:aws:request:outer')
     const serviceIdentifier = this.config.serviceId.toLowerCase()

package/packages/datadog-instrumentations/src/cassandra-driver.js

@@ -73,6 +73,10 @@ addHook({ name: 'cassandra-driver', versions: ['>=4.4'] }, cassandra => {
   return cassandra
 })
 
+const isValid = (args) => {
+  return args.length === 4 || typeof args[3] === 'function'
+}
+
 addHook({ name: 'cassandra-driver', versions: ['3 - 4.3'] }, cassandra => {
   shimmer.wrap(cassandra.Client.prototype, '_innerExecute', _innerExecute =>
     function (query, params, execOptions, callback) {
@@ -81,9 +85,6 @@ addHook({ name: 'cassandra-driver', versions: ['3 - 4.3'] }, cassandra => {
       }
       const callbackResource = new AsyncResource('bound-anonymous-fn')
       const asyncResource = new AsyncResource('bound-anonymous-fn')
-      const isValid = (args) => {
-        return args.length === 4 || typeof args[3] === 'function'
-      }
 
       if (!isValid(arguments)) {
         return _innerExecute.apply(this, arguments)
@@ -176,7 +177,7 @@ function finish (finishCh, errorCh, error) {
   if (error) {
     errorCh.publish(error)
   }
-  finishCh.publish(undefined)
+  finishCh.publish()
 }
 
 function wrapCallback (finishCh, errorCh, asyncResource, callback) {

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

@@ -1,5 +1,6 @@
 'use strict'
 
+const { errorMonitor } = require('events')
 const util = require('util')
 
 const {
@@ -227,13 +228,12 @@ function wrapChildProcessAsyncMethod (ChildProcess, shell = false) {
         if (childProcess) {
           let errorExecuted = false
 
-          childProcess.on('error', (e) => {
+          childProcess.on(errorMonitor, (e) => {
             errorExecuted = true
             childProcessChannel.error.publish(e)
           })
 
-          childProcess.on('close', (code) => {
-            code = code || 0
+          childProcess.on('close', (code = 0) => {
             if (!errorExecuted && code !== 0) {
               childProcessChannel.error.publish()
             }

package/packages/datadog-instrumentations/src/confluentinc-kafka-javascript.js

@@ -2,11 +2,12 @@
 
 const {
   addHook,
-  channel,
-  AsyncResource
+  channel
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
+const log = require('../../dd-trace/src/log')
+
 // Create channels for Confluent Kafka JavaScript
 const channels = {
   producerStart: channel('apm:@confluentinc/kafka-javascript:produce:start'),
@@ -25,10 +26,11 @@ const channels = {
   batchConsumerCommit: channel('apm:@confluentinc/kafka-javascript:consume-batch:commit')
 }
 
+const disabledHeaderWeakSet = new WeakSet()
+
 // we need to store the offset per partition per topic for the consumer to track offsets for DSM
 const latestConsumerOffsets = new Map()
 
-// Customize the instrumentation for Confluent Kafka JavaScript
 addHook({ name: '@confluentinc/kafka-javascript', versions: ['>=1.0.0'] }, (module) => {
   // Hook native module classes first
   instrumentBaseModule(module)
@@ -51,30 +53,32 @@ function instrumentBaseModule (module) {
         // Hook the produce method
         if (typeof producer?.produce === 'function') {
           shimmer.wrap(producer, 'produce', function wrapProduce (produce) {
-            return function wrappedProduce (topic, partition, message, key, timestamp, opaque) {
+            return function wrappedProduce (topic, partition, message, key, timestamp, opaque, headers) {
               if (!channels.producerStart.hasSubscribers) {
                 return produce.apply(this, arguments)
               }
 
               const brokers = this.globalConfig?.['bootstrap.servers']
 
-              const asyncResource = new AsyncResource('bound-anonymous-fn')
-              return asyncResource.runInAsyncScope(() => {
-                try {
-                  channels.producerStart.publish({
-                    topic,
-                    messages: [{ key, value: message }],
-                    bootstrapServers: brokers
-                  })
+              const ctx = {
+                topic,
+                messages: [{ key, value: message }],
+                bootstrapServers: brokers
+              }
 
-                  const result = produce.apply(this, arguments)
+              return channels.producerStart.runStores(ctx, () => {
+                try {
+                  const headers = convertHeaders(ctx.messages[0].headers)
+                  const result = produce.apply(this, [topic, partition, message, key, timestamp, opaque, headers])
 
-                  channels.producerCommit.publish(undefined)
-                  channels.producerFinish.publish(undefined)
+                  ctx.result = result
+                  channels.producerCommit.publish(ctx)
+                  channels.producerFinish.publish(ctx)
                   return result
                 } catch (error) {
-                  channels.producerError.publish(error)
-                  channels.producerFinish.publish(undefined)
+                  ctx.error = error
+                  channels.producerError.publish(ctx)
+                  channels.producerFinish.publish(ctx)
                   throw error
                 }
               })
@@ -106,32 +110,39 @@ function instrumentBaseModule (module) {
                 callback = numMessages
               }
 
+              const ctx = {
+                groupId
+              }
               // Handle callback-based consumption
               if (typeof callback === 'function') {
                 return consume.call(this, numMessages, function wrappedCallback (err, messages) {
                   if (messages && messages.length > 0) {
                     messages.forEach(message => {
-                      channels.consumerStart.publish({
-                        topic: message?.topic,
-                        partition: message?.partition,
-                        message,
-                        groupId
-                      })
+                      ctx.topic = message?.topic
+                      ctx.partition = message?.partition
+                      ctx.message = message
+
+                      // TODO: We should be using publish here instead of runStores but we need bindStart to be called
+                      channels.consumerStart.runStores(ctx, () => {})
                       updateLatestOffset(message?.topic, message?.partition, message?.offset, groupId)
                     })
                   }
 
                   if (err) {
-                    channels.consumerError.publish(err)
+                    ctx.error = err
+                    channels.consumerError.publish(ctx)
                   }
 
                   try {
                     const result = callback.apply(this, arguments)
-                    channels.consumerFinish.publish(undefined)
+                    if (messages && messages.length > 0) {
+                      channels.consumerFinish.publish(ctx)
+                    }
                     return result
                   } catch (error) {
-                    channels.consumerError.publish(error)
-                    channels.consumerFinish.publish(undefined)
+                    ctx.error = error
+                    channels.consumerError.publish(ctx)
+                    channels.consumerFinish.publish(ctx)
                     throw error
                   }
                 })
@@ -200,34 +211,44 @@ function instrumentKafkaJS (kafkaJS) {
                       return send.apply(this, arguments)
                     }
 
-                    const asyncResource = new AsyncResource('bound-anonymous-fn')
-                    return asyncResource.runInAsyncScope(() => {
-                      try {
-                        channels.producerStart.publish({
-                          topic: payload?.topic,
-                          messages: payload?.messages || [],
-                          bootstrapServers: kafka._ddBrokers
-                        })
+                    const ctx = {
+                      topic: payload?.topic,
+                      messages: payload?.messages || [],
+                      bootstrapServers: kafka._ddBrokers,
+                      disableHeaderInjection: disabledHeaderWeakSet.has(producer)
+                    }
 
+                    return channels.producerStart.runStores(ctx, () => {
+                      try {
                         const result = send.apply(this, arguments)
 
-                        result.then(
-                          asyncResource.bind(res => {
-                            channels.producerCommit.publish(res)
-                            channels.producerFinish.publish(undefined)
-                          }),
-                          asyncResource.bind(err => {
-                            if (err) {
-                              channels.producerError.publish(err)
+                        result.then((res) => {
+                          ctx.result = res
+                          channels.producerCommit.publish(ctx)
+                          channels.producerFinish.publish(ctx)
+                        }, (err) => {
+                          if (err) {
+                            // Fixes bug where we would inject message headers for kafka brokers
+                            // that don't support headers (version <0.11). On the error, we disable
+                            // header injection. Tnfortunately the error name / type is not more specific.
+                            // This approach is implemented by other tracers as well.
+                            if (err.name === 'KafkaJSError' && err.type === 'ERR_UNKNOWN') {
+                              disabledHeaderWeakSet.add(producer)
+                              log.error('Kafka Broker responded with UNKNOWN_SERVER_ERROR (-1). ' +
+                                'Please look at broker logs for more information. ' +
+                                'Tracer message header injection for Kafka is disabled.')
                             }
-                            channels.producerFinish.publish(undefined)
-                          })
-                        )
+                            ctx.error = err
+                            channels.producerError.publish(ctx)
+                          }
+                          channels.producerFinish.publish(ctx)
+                        })
 
                         return result
                       } catch (e) {
-                        channels.producerError.publish(e)
-                        channels.producerFinish.publish(undefined)
+                        ctx.error = e
+                        channels.producerError.publish(ctx)
+                        channels.producerFinish.publish(ctx)
                         throw e
                       }
                     })
@@ -335,10 +356,11 @@ function wrapKafkaCallback (callback, { startCh, commitCh, finishCh, errorCh },
   return function wrappedKafkaCallback (payload) {
     const commitPayload = getPayload(payload)
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-    return asyncResource.runInAsyncScope(() => {
-      startCh.publish(commitPayload)
+    const ctx = {
+      extractedArgs: commitPayload
+    }
 
+    return startCh.runStores(ctx, () => {
       updateLatestOffset(commitPayload?.topic, commitPayload?.partition, commitPayload?.offset, commitPayload?.groupId)
 
       try {
@@ -346,22 +368,25 @@ function wrapKafkaCallback (callback, { startCh, commitCh, finishCh, errorCh },
 
         if (result && typeof result.then === 'function') {
           return result
-            .then(asyncResource.bind(res => {
-              finishCh.publish(undefined)
+            .then((res) => {
+              ctx.result = res
+              finishCh.publish(ctx)
               return res
-            }))
-            .catch(asyncResource.bind(err => {
-              errorCh.publish(err)
-              finishCh.publish(undefined)
+            })
+            .catch((err) => {
+              ctx.error = err
+              errorCh.publish(ctx)
+              finishCh.publish(ctx)
               throw err
-            }))
+            })
         } else {
-          finishCh.publish(undefined)
+          finishCh.publish(ctx)
           return result
         }
       } catch (error) {
-        errorCh.publish(error)
-        finishCh.publish(undefined)
+        ctx.error = error
+        errorCh.publish(ctx)
+        finishCh.publish(ctx)
         throw error
       }
     })
@@ -387,5 +412,10 @@ function updateLatestOffset (topic, partition, offset, groupId) {
 }
 
 function getLatestOffsets () {
-  return Array.from(latestConsumerOffsets.values())
+  return [...latestConsumerOffsets.values()]
+}
+
+function convertHeaders (headers) {
+  // convert headers from object to array of objects with 1 key and value per array entry
+  return Object.entries(headers).map(([key, value]) => ({ [key.toString()]: value.toString() }))
 }

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

@@ -1,5 +1,6 @@
 'use strict'
 
+const { errorMonitor } = require('events')
 const {
   channel,
   addHook,
@@ -31,7 +32,7 @@ function wrapMaybeInvoke (_maybeInvoke) {
     const callbackIndex = args.length - 1
     const callback = args[callbackIndex]
 
-    if (callback instanceof Function) {
+    if (typeof callback === 'function') {
       args[callbackIndex] = AsyncResource.bind(callback)
     }
 
@@ -183,12 +184,12 @@ addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^2.6.12'] }, Buc
       startCh.publish({ resource: n1qlQuery, bucket: { name: this.name || this._name }, seedNodes: this._dd_hosts })
 
       emitter.once('rows', asyncResource.bind(() => {
-        finishCh.publish(undefined)
+        finishCh.publish()
       }))
 
-      emitter.once('error', asyncResource.bind((error) => {
+      emitter.once(errorMonitor, asyncResource.bind((error) => {
         errorCh.publish(error)
-        finishCh.publish(undefined)
+        finishCh.publish()
       }))
 
       try {