dd-trace 5.51.0 → 5.52.0

package/LICENSE-3rdparty.csv

@@ -38,15 +38,10 @@ dev,@eslint/eslintrc,MIT,Copyright OpenJS Foundation and other contributors, <ww
 dev,@eslint/js,MIT,Copyright OpenJS Foundation and other contributors, <www.openjsf.org>
 dev,@msgpack/msgpack,ISC,Copyright 2019 The MessagePack Community
 dev,@stylistic/eslint-plugin-js,MIT,Copyright OpenJS Foundation and other contributors, <www.openjsf.org>
-dev,autocannon,MIT,Copyright 2016 Matteo Collina
 dev,axios,MIT,Copyright 2014-present Matt Zabriskie
 dev,benchmark,MIT,Copyright 2010-2016 Mathias Bynens Robert Kieffer John-David Dalton
 dev,body-parser,MIT,Copyright 2014 Jonathan Ong 2014-2015 Douglas Christopher Wilson
 dev,chai,MIT,Copyright 2017 Chai.js Assertion Library
-dev,chalk,MIT,Copyright Sindre Sorhus
-dev,checksum,MIT,Copyright Daniel D. Shaw
-dev,cli-table3,MIT,Copyright 2014 James Talmage
-dev,dotenv,BSD-2-Clause,Copyright 2015 Scott Motte
 dev,eslint,MIT,Copyright JS Foundation and other contributors https://js.foundation
 dev,eslint-config-standard,MIT,Copyright Feross Aboukhadijeh
 dev,eslint-plugin-import,MIT,Copyright 2015 Ben Mosher
@@ -60,7 +55,6 @@ dev,glob,ISC,Copyright Isaac Z. Schlueter and Contributors
 dev,globals,MIT,Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
 dev,graphql,MIT,Copyright 2015 Facebook Inc.
 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,nock,MIT,Copyright 2017 Pedro Teixeira and other contributors

package/index.d.ts

@@ -138,6 +138,22 @@ interface Tracer extends opentracing.Tracer {
    * LLM Observability SDK
    */
   llmobs: tracer.llmobs.LLMObs;
+
+  /**
+   * @experimental
+   * Provide same functionality as OpenTelemetry Baggage:
+   * https://opentelemetry.io/docs/concepts/signals/baggage/
+   *
+   * Since the equivalent of OTel Context is implicit in dd-trace-js,
+   * these APIs act on the currently active baggage
+   *
+   * Work with storage('baggage'), therefore do not follow the same continuity as other APIs
+   */
+  setBaggageItem (key: string, value: string): Record<string, string>;
+  getBaggageItem (key: string): string | undefined;
+  getAllBaggageItems (): Record<string, string>;
+  removeBaggageItem (key: string): Record<string, string>;
+  removeAllBaggageItems (): Record<string, string>;
 }
 
 // left out of the namespace, so it
@@ -154,6 +170,7 @@ interface Plugins {
   "bunyan": tracer.plugins.bunyan;
   "cassandra-driver": tracer.plugins.cassandra_driver;
   "child_process": tracer.plugins.child_process;
+  "confluentinc-kafka-javascript": tracer.plugins.confluentinc_kafka_javascript;
   "connect": tracer.plugins.connect;
   "couchbase": tracer.plugins.couchbase;
   "cucumber": tracer.plugins.cucumber;
@@ -717,7 +734,18 @@ declare namespace tracer {
          */
         maxDepth?: number,
       }
-    };
+    }
+
+    /**
+     * Configuration for Code Origin for Spans.
+     */
+    codeOriginForSpans?: {
+      /**
+       * Whether to enable Code Origin for Spans.
+       * @default true
+       */
+      enabled?: boolean
+    }
 
     /**
      * Configuration of the IAST. Can be a boolean as an alias to `iast.enabled`.
@@ -1333,6 +1361,12 @@ declare namespace tracer {
      * [child_process](https://nodejs.org/api/child_process.html) module.
      */
     interface child_process extends Instrumentation {}
+  
+    /**
+     * This plugin automatically instruments the
+     * [confluentinc-kafka-javascript](https://github.com/confluentinc/confluent-kafka-js) module.
+     */
+    interface confluentinc_kafka_javascript extends Instrumentation {}
 
     /**
      * This plugin automatically instruments the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.51.0",
+  "version": "5.52.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -85,9 +85,9 @@
   "dependencies": {
     "@datadog/libdatadog": "^0.5.1",
     "@datadog/native-appsec": "8.5.2",
-    "@datadog/native-iast-taint-tracking": "3.3.1",
+    "@datadog/native-iast-taint-tracking": "4.0.0",
     "@datadog/native-metrics": "^3.1.1",
-    "@datadog/pprof": "5.7.1",
+    "@datadog/pprof": "5.8.0",
     "@datadog/sketches-js": "^2.1.0",
     "@datadog/wasm-js-rewriter": "4.0.1",
     "@isaacs/ttlcache": "^1.4.1",
@@ -124,15 +124,10 @@
     "@msgpack/msgpack": "^3.0.0-beta3",
     "@stylistic/eslint-plugin-js": "^3.0.1",
     "@types/node": "^16.0.0",
-    "autocannon": "^4.5.2",
     "axios": "^1.8.2",
     "benchmark": "^2.1.4",
     "body-parser": "^1.20.3",
     "chai": "^4.3.7",
-    "chalk": "^5.3.0",
-    "checksum": "^1.0.0",
-    "cli-table3": "^0.6.3",
-    "dotenv": "16.3.1",
     "eslint": "^9.19.0",
     "eslint-config-standard": "^17.1.0",
     "eslint-plugin-import": "^2.31.0",
@@ -146,7 +141,6 @@
     "globals": "^15.10.0",
     "graphql": "0.13.2",
     "jszip": "^3.5.0",
-    "mkdirp": "^3.0.1",
     "mocha": "^10",
     "multer": "^1.4.5-lts.1",
     "nock": "^11.3.3",

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

@@ -0,0 +1,391 @@
+'use strict'
+
+const {
+  addHook,
+  channel,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+// Create channels for Confluent Kafka JavaScript
+const channels = {
+  producerStart: channel('apm:@confluentinc/kafka-javascript:produce:start'),
+  producerFinish: channel('apm:@confluentinc/kafka-javascript:produce:finish'),
+  producerError: channel('apm:@confluentinc/kafka-javascript:produce:error'),
+  producerCommit: channel('apm:@confluentinc/kafka-javascript:produce:commit'),
+  consumerStart: channel('apm:@confluentinc/kafka-javascript:consume:start'),
+  consumerFinish: channel('apm:@confluentinc/kafka-javascript:consume:finish'),
+  consumerError: channel('apm:@confluentinc/kafka-javascript:consume:error'),
+  consumerCommit: channel('apm:@confluentinc/kafka-javascript:consume:commit'),
+
+  // batch operations
+  batchConsumerStart: channel('apm:@confluentinc/kafka-javascript:consume-batch:start'),
+  batchConsumerFinish: channel('apm:@confluentinc/kafka-javascript:consume-batch:finish'),
+  batchConsumerError: channel('apm:@confluentinc/kafka-javascript:consume-batch:error'),
+  batchConsumerCommit: channel('apm:@confluentinc/kafka-javascript:consume-batch:commit')
+}
+
+// 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)
+
+  // Then hook KafkaJS if it exists
+  if (module.KafkaJS) {
+    instrumentKafkaJS(module.KafkaJS)
+  }
+
+  return module
+})
+
+function instrumentBaseModule (module) {
+  // Helper function to wrap producer classes
+  function wrapProducerClass (ProducerClass, className) {
+    return shimmer.wrap(module, className, function wrapProducer (Original) {
+      return function wrappedProducer () {
+        const producer = new Original(...arguments)
+
+        // 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) {
+              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 result = produce.apply(this, arguments)
+
+                  channels.producerCommit.publish(undefined)
+                  channels.producerFinish.publish(undefined)
+                  return result
+                } catch (error) {
+                  channels.producerError.publish(error)
+                  channels.producerFinish.publish(undefined)
+                  throw error
+                }
+              })
+            }
+          })
+        }
+
+        return producer
+      }
+    })
+  }
+
+  // Helper function to wrap consumer classes
+  function wrapConsumerClass (ConsumerClass, className) {
+    return shimmer.wrap(module, className, function wrapConsumer (Original) {
+      return function wrappedConsumer () {
+        const consumer = new Original(...arguments)
+        const groupId = this.groupId || (arguments[0]?.['group.id'])
+
+        // Wrap the consume method
+        if (typeof consumer?.consume === 'function') {
+          shimmer.wrap(consumer, 'consume', function wrapConsume (consume) {
+            return function wrappedConsume (numMessages, callback) {
+              if (!channels.consumerStart.hasSubscribers) {
+                return consume.apply(this, arguments)
+              }
+
+              if (!callback && typeof numMessages === 'function') {
+                callback = numMessages
+              }
+
+              // 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
+                      })
+                      updateLatestOffset(message?.topic, message?.partition, message?.offset, groupId)
+                    })
+                  }
+
+                  if (err) {
+                    channels.consumerError.publish(err)
+                  }
+
+                  try {
+                    const result = callback.apply(this, arguments)
+                    channels.consumerFinish.publish(undefined)
+                    return result
+                  } catch (error) {
+                    channels.consumerError.publish(error)
+                    channels.consumerFinish.publish(undefined)
+                    throw error
+                  }
+                })
+              }
+
+              // If no callback is provided, just pass through
+              return consume.apply(this, arguments)
+            }
+          })
+
+          // Wrap the commit method for handling offset commits
+          if (consumer && typeof consumer.commit === 'function') {
+            shimmer.wrap(consumer, 'commit', wrapCommit)
+          }
+        }
+
+        return consumer
+      }
+    })
+  }
+
+  // Wrap Producer and KafkaProducer classes if they exist
+  if (typeof module.Producer === 'function') {
+    wrapProducerClass(module.Producer, 'Producer')
+  }
+  if (typeof module.KafkaProducer === 'function') {
+    wrapProducerClass(module.KafkaProducer, 'KafkaProducer')
+  }
+
+  // Wrap Consumer and KafkaConsumer classes if they exist
+  if (typeof module.Consumer === 'function') {
+    wrapConsumerClass(module.Consumer, 'Consumer')
+  }
+  if (typeof module.KafkaConsumer === 'function') {
+    wrapConsumerClass(module.KafkaConsumer, 'KafkaConsumer')
+  }
+}
+
+function instrumentKafkaJS (kafkaJS) {
+  // Hook the Kafka class if it exists
+  if (typeof kafkaJS?.Kafka === 'function') {
+    shimmer.wrap(kafkaJS, 'Kafka', function wrapKafka (OriginalKafka) {
+      return function KafkaWrapper (options) {
+        const kafka = new OriginalKafka(options)
+        const kafkaJSOptions = options?.kafkaJS || options
+        const brokers = kafkaJSOptions?.brokers ? kafkaJSOptions.brokers.join(',') : ''
+
+        // Store brokers for later use
+        kafka._ddBrokers = brokers
+
+        // Wrap the producer method if it exists
+        if (typeof kafka?.producer === 'function') {
+          shimmer.wrap(kafka, 'producer', function wrapProducerMethod (producerMethod) {
+            return function wrappedProducerMethod () {
+              const producer = producerMethod.apply(this, arguments)
+
+              if (!brokers && arguments?.[0]?.['bootstrap.servers']) {
+                kafka._ddBrokers = arguments[0]['bootstrap.servers']
+              }
+
+              // Wrap the send method of the producer
+              if (producer && typeof producer.send === 'function') {
+                shimmer.wrap(producer, 'send', function wrapSend (send) {
+                  return function wrappedSend (payload) {
+                    if (!channels.producerStart.hasSubscribers) {
+                      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 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)
+                            }
+                            channels.producerFinish.publish(undefined)
+                          })
+                        )
+
+                        return result
+                      } catch (e) {
+                        channels.producerError.publish(e)
+                        channels.producerFinish.publish(undefined)
+                        throw e
+                      }
+                    })
+                  }
+                })
+              }
+
+              return producer
+            }
+          })
+        }
+
+        // Wrap the consumer method if it exists
+        if (typeof kafka?.consumer === 'function') {
+          shimmer.wrap(kafka, 'consumer', function wrapConsumerMethod (consumerMethod) {
+            return function wrappedConsumerMethod (config) {
+              const consumer = consumerMethod.apply(this, arguments)
+              const groupId = getGroupId(config)
+
+              // Wrap the run method for handling message consumption
+              if (typeof consumer?.run === 'function') {
+                shimmer.wrap(consumer, 'run', function wrapRun (run) {
+                  return function wrappedRun (options) {
+                    if (!channels.consumerStart.hasSubscribers) {
+                      return run.apply(this, arguments)
+                    }
+
+                    const eachMessage = options?.eachMessage
+                    const eachBatch = options?.eachBatch
+                    if (eachMessage) {
+                      options.eachMessage = wrapKafkaCallback(
+                        eachMessage,
+                        {
+                          startCh: channels.consumerStart,
+                          commitCh: channels.consumerCommit,
+                          finishCh: channels.consumerFinish,
+                          errorCh: channels.consumerError
+                        },
+                        (payload) => {
+                          return {
+                            topic: payload?.topic,
+                            partition: payload?.partition,
+                            offset: payload?.message?.offset,
+                            message: payload?.message,
+                            groupId
+                          }
+                        })
+                    } else if (eachBatch) {
+                      options.eachBatch = wrapKafkaCallback(
+                        eachBatch,
+                        {
+                          startCh: channels.batchConsumerStart,
+                          commitCh: channels.batchConsumerCommit,
+                          finishCh: channels.batchConsumerFinish,
+                          errorCh: channels.batchConsumerError
+                        },
+                        (payload) => {
+                          const { batch } = payload
+                          return {
+                            topic: batch?.topic,
+                            partition: batch?.partition,
+                            offset: batch?.messages[batch?.messages?.length - 1]?.offset,
+                            messages: batch?.messages,
+                            groupId
+                          }
+                        }
+                      )
+                    }
+
+                    return run.apply(this, arguments)
+                  }
+                })
+              }
+
+              // Wrap the commit method for handling offset commits
+              if (typeof consumer?.commitOffsets === 'function') {
+                shimmer.wrap(consumer, 'commitOffsets', wrapCommit)
+              }
+
+              return consumer
+            }
+          })
+        }
+
+        return kafka
+      }
+    })
+  }
+}
+
+function wrapCommit (commit) {
+  return function wrappedCommit (options) {
+    if (!channels.consumerCommit.hasSubscribers) {
+      return commit.apply(this, arguments)
+    }
+
+    const result = commit.apply(this, arguments)
+    channels.consumerCommit.publish(getLatestOffsets())
+    latestConsumerOffsets.clear()
+    return result
+  }
+}
+
+function wrapKafkaCallback (callback, { startCh, commitCh, finishCh, errorCh }, getPayload) {
+  return function wrappedKafkaCallback (payload) {
+    const commitPayload = getPayload(payload)
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    return asyncResource.runInAsyncScope(() => {
+      startCh.publish(commitPayload)
+
+      updateLatestOffset(commitPayload?.topic, commitPayload?.partition, commitPayload?.offset, commitPayload?.groupId)
+
+      try {
+        const result = callback.apply(this, arguments)
+
+        if (result && typeof result.then === 'function') {
+          return result
+            .then(asyncResource.bind(res => {
+              finishCh.publish(undefined)
+              return res
+            }))
+            .catch(asyncResource.bind(err => {
+              errorCh.publish(err)
+              finishCh.publish(undefined)
+              throw err
+            }))
+        } else {
+          finishCh.publish(undefined)
+          return result
+        }
+      } catch (error) {
+        errorCh.publish(error)
+        finishCh.publish(undefined)
+        throw error
+      }
+    })
+  }
+}
+
+function getGroupId (config) {
+  if (!config) return ''
+  if (config.kafkaJS?.groupId) return config.kafkaJS.groupId
+  if (config?.groupId) return config.groupId
+  if (config['group.id']) return config['group.id']
+  return ''
+}
+
+function updateLatestOffset (topic, partition, offset, groupId) {
+  const key = `${topic}:${partition}`
+  latestConsumerOffsets.set(key, {
+    topic,
+    partition,
+    offset,
+    groupId
+  })
+}
+
+function getLatestOffsets () {
+  return Array.from(latestConsumerOffsets.values())
+}

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

@@ -309,6 +309,7 @@ function wrapRun (pl, isLatestVersion) {
         let isAttemptToFixRetry = false
         let hasFailedAllRetries = false
         let hasPassedAllRetries = false
+        let hasFailedAttemptToFix = false
         let isDisabled = false
         let isQuarantined = false
 
@@ -330,6 +331,7 @@ function wrapRun (pl, isLatestVersion) {
               }, { pass: 0, fail: 0 })
               hasFailedAllRetries = fail === testManagementAttemptToFixRetries + 1
               hasPassedAllRetries = pass === testManagementAttemptToFixRetries + 1
+              hasFailedAttemptToFix = fail > 0
             }
           }
         }
@@ -360,6 +362,7 @@ function wrapRun (pl, isLatestVersion) {
             isAttemptToFixRetry,
             hasFailedAllRetries,
             hasPassedAllRetries,
+            hasFailedAttemptToFix,
             isDisabled,
             isQuarantined
           })

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const { channel, addHook, AsyncResource } = require('./helpers/instrument')
+const { channel, addHook } = 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 = AsyncResource.bind(arguments[arguments.length - 1])
+    const cb = arguments[arguments.length - 1]
     if (
       !startCh.hasSubscribers ||
       arguments.length < expectedArgs ||
@@ -62,30 +62,32 @@ function wrap (prefix, fn, expectedArgs, rrtype) {
       return fn.apply(this, arguments)
     }
 
-    const startArgs = Array.from(arguments)
-    startArgs.pop() // gets rid of the callback
+    const args = Array.from(arguments)
+    args.pop() // gets rid of the callback
     if (rrtype) {
-      startArgs.push(rrtype)
+      args.push(rrtype)
     }
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-    return asyncResource.runInAsyncScope(() => {
-      startCh.publish(startArgs)
+    const ctx = { args }
 
-      arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => asyncResource.bind(function (error, result) {
+    return startCh.runStores(ctx, () => {
+      arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => function (error, result, ...args) {
         if (error) {
-          errorCh.publish(error)
+          ctx.error = error
+          errorCh.publish(ctx)
         }
-        finishCh.publish(result)
-        cb.apply(this, arguments)
-      }))
+
+        ctx.result = result
+        finishCh.runStores(ctx, cb, this, error, result, ...args)
+      })
 
       try {
         return fn.apply(this, arguments)
       // TODO deal with promise versions when we support `dns/promises`
       } catch (error) {
         error.stack // trigger getting the stack at the original throwing point
-        errorCh.publish(error)
+        ctx.error = error
+        errorCh.publish(ctx)
 
         throw error
       }