dd-trace 5.86.0 → 5.88.0

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

@@ -6,6 +6,22 @@ const shimmer = require('../../datadog-shimmer')
 const satisfies = require('../../../vendor/dist/semifies')
 const { channel, addHook } = require('./helpers/instrument')
 
+/** @type {WeakMap<object, Function>} */
+const wrappedOnResult = new WeakMap()
+
+/**
+ * @param {unknown} sql
+ * @returns {string|undefined}
+ */
+function resolveSqlString (sql) {
+  return typeof sql === 'string' ? sql : /** @type {{ sql?: string }} */ (sql)?.sql
+}
+
+/**
+ * @param {Function} Connection
+ * @param {string} version
+ * @returns {Function}
+ */
 function wrapConnection (Connection, version) {
   const startCh = channel('apm:mysql2:query:start')
   const finishCh = channel('apm:mysql2:query:finish')
@@ -19,15 +35,27 @@ function wrapConnection (Connection, version) {
   shimmer.wrap(Connection.prototype, 'addCommand', addCommand => function (cmd) {
     if (!startCh.hasSubscribers) return addCommand.apply(this, arguments)
 
-    const name = cmd && cmd.constructor && cmd.constructor.name
-    const isCommand = typeof cmd.execute === 'function'
-    const isQuery = isCommand && (name === 'Execute' || name === 'Query')
+    const command = /** @type {{ execute?: Function, constructor?: { name?: string } }} */ (cmd)
+    if (typeof command.execute !== 'function') return addCommand.apply(this, arguments)
+
+    const name = command.constructor?.name
+    const isQuery = name === 'Execute' || name === 'Query'
     const ctx = {}
 
-    // TODO: consider supporting all commands and not just queries
-    cmd.execute = isQuery
-      ? wrapExecute(cmd, cmd.execute, ctx, this.config)
-      : bindExecute(cmd.execute, ctx)
+    if (isQuery) {
+      command.execute = wrapExecute(command, command.execute, ctx, this.config)
+
+      return commandAddCh.runStores(ctx, addCommand, this, ...arguments)
+    }
+
+    wrapCommandOnResult(command, ctx)
+
+    command.execute = shimmer.wrapFunction(
+      command.execute,
+      execute => function executeWithTrace (_packet_, _connection_) {
+        return commandStartCh.runStores(ctx, execute, this, ...arguments)
+      }
+    )
 
     return commandAddCh.runStores(ctx, addCommand, this, ...arguments)
   })
@@ -35,12 +63,11 @@ function wrapConnection (Connection, version) {
   shimmer.wrap(Connection.prototype, 'query', query => function (sql, values, cb) {
     if (!startOuterQueryCh.hasSubscribers) return query.apply(this, arguments)
 
-    if (sql !== null && typeof sql === 'object') sql = sql.sql
-
-    if (!sql) return query.apply(this, arguments)
+    const resolvedSql = resolveSqlString(sql)
+    if (resolvedSql === undefined) return query.apply(this, arguments)
 
     const abortController = new AbortController()
-    startOuterQueryCh.publish({ sql, abortController })
+    startOuterQueryCh.publish({ sql: resolvedSql, abortController })
 
     if (abortController.signal.aborted) {
       const addCommand = this.addCommand
@@ -56,7 +83,7 @@ function wrapConnection (Connection, version) {
       cb = queryCommand.onResult
 
       process.nextTick(() => {
-        if (cb) {
+        if (typeof cb === 'function') {
           cb(abortController.signal.reason)
         } else {
           queryCommand.emit('error', abortController.signal.reason)
@@ -76,12 +103,11 @@ function wrapConnection (Connection, version) {
   shimmer.wrap(Connection.prototype, 'execute', execute => function (sql, values, cb) {
     if (!startOuterQueryCh.hasSubscribers) return execute.apply(this, arguments)
 
-    if (sql !== null && typeof sql === 'object') sql = sql.sql
-
-    if (!sql) return execute.apply(this, arguments)
+    const resolvedSql = resolveSqlString(sql)
+    if (resolvedSql === undefined) return execute.apply(this, arguments)
 
     const abortController = new AbortController()
-    startOuterQueryCh.publish({ sql, abortController })
+    startOuterQueryCh.publish({ sql: resolvedSql, abortController })
 
     if (abortController.signal.aborted) {
       const addCommand = this.addCommand
@@ -94,7 +120,9 @@ function wrapConnection (Connection, version) {
         this.addCommand = addCommand
       }
 
-      result?.onResult(abortController.signal.reason)
+      if (typeof result?.onResult === 'function') {
+        result.onResult(abortController.signal.reason)
+      }
 
       return result
     }
@@ -104,33 +132,48 @@ function wrapConnection (Connection, version) {
 
   return Connection
 
-  function bindExecute (execute, ctx) {
-    return shimmer.wrapFunction(execute, execute => function executeWithTrace (packet, connection) {
-      const onResult = this.onResult
+  /**
+   * @param {object} cmd
+   * @param {object} ctx
+   * @returns {void}
+   */
+  function wrapCommandOnResult (cmd, ctx) {
+    const onResult = cmd?.onResult
+    if (typeof onResult !== 'function') return
 
-      if (onResult) {
-        this.onResult = function () {
-          return commandFinishCh.runStores(ctx, onResult, this, ...arguments)
-        }
-      }
+    const cached = wrappedOnResult.get(cmd)
 
-      return commandStartCh.runStores(ctx, execute, this, ...arguments)
-    })
+    if (cached === onResult) return
+
+    const wrapped = function () {
+      return commandFinishCh.runStores(ctx, onResult, this, ...arguments)
+    }
+
+    wrappedOnResult.set(cmd, wrapped)
+    cmd.onResult = wrapped
   }
 
+  /**
+   * @param {object} cmd
+   * @param {Function} execute
+   * @param {object} ctx
+   * @param {object} config
+   * @returns {Function}
+   */
   function wrapExecute (cmd, execute, ctx, config) {
     return shimmer.wrapFunction(execute, execute => function executeWithTrace (packet, connection) {
-      ctx.sql = cmd.statement ? cmd.statement.query : cmd.sql
+      const command = /** @type {{ statement?: { query?: unknown }, sql?: unknown }} */ (cmd)
+      ctx.sql = command.statement ? command.statement.query : command.sql
       ctx.conf = config
 
       return startCh.runStores(ctx, () => {
-        if (cmd.statement) {
-          cmd.statement.query = ctx.sql
+        if (command.statement) {
+          command.statement.query = ctx.sql
         } else {
-          cmd.sql = ctx.sql
+          command.sql = ctx.sql
         }
 
-        if (this.onResult) {
+        if (typeof this.onResult === 'function') {
           const onResult = this.onResult
 
           this.onResult = shimmer.wrapFunction(onResult, onResult => function (error) {
@@ -141,11 +184,14 @@ function wrapConnection (Connection, version) {
             finishCh.runStores(ctx, onResult, this, ...arguments)
           })
         } else {
-          this.once(errorMonitor, error => {
-            ctx.error = error
-            errorCh.publish(ctx)
-          })
-          this.once('end', () => finishCh.publish(ctx))
+          const command = /** @type {{ once?: Function }} */ (this)
+          if (typeof command.once === 'function') {
+            command.once(errorMonitor, error => {
+              ctx.error = error
+              errorCh.publish(ctx)
+            })
+            command.once('end', () => finishCh.publish(ctx))
+          }
         }
 
         this.execute = execute
@@ -157,9 +203,14 @@ function wrapConnection (Connection, version) {
           errorCh.publish(ctx)
         }
       })
-    }, cmd)
+    })
   }
 }
+/**
+ * @param {Function} Pool
+ * @param {string} version
+ * @returns {Function}
+ */
 function wrapPool (Pool, version) {
   const startOuterQueryCh = channel('datadog:mysql2:outerquery:start')
   const shouldEmitEndAfterQueryAbort = satisfies(version, '>=1.3.3')
@@ -167,12 +218,11 @@ function wrapPool (Pool, version) {
   shimmer.wrap(Pool.prototype, 'query', query => function (sql, values, cb) {
     if (!startOuterQueryCh.hasSubscribers) return query.apply(this, arguments)
 
-    if (sql !== null && typeof sql === 'object') sql = sql.sql
-
-    if (!sql) return query.apply(this, arguments)
+    const resolvedSql = resolveSqlString(sql)
+    if (resolvedSql === undefined) return query.apply(this, arguments)
 
     const abortController = new AbortController()
-    startOuterQueryCh.publish({ sql, abortController })
+    startOuterQueryCh.publish({ sql: resolvedSql, abortController })
 
     if (abortController.signal.aborted) {
       const getConnection = this.getConnection
@@ -206,21 +256,22 @@ function wrapPool (Pool, version) {
   shimmer.wrap(Pool.prototype, 'execute', execute => function (sql, values, cb) {
     if (!startOuterQueryCh.hasSubscribers) return execute.apply(this, arguments)
 
-    if (sql !== null && typeof sql === 'object') sql = sql.sql
-
-    if (!sql) return execute.apply(this, arguments)
+    const resolvedSql = resolveSqlString(sql)
+    if (resolvedSql === undefined) return execute.apply(this, arguments)
 
     const abortController = new AbortController()
-    startOuterQueryCh.publish({ sql, abortController })
+    startOuterQueryCh.publish({ sql: resolvedSql, abortController })
 
     if (abortController.signal.aborted) {
       if (typeof values === 'function') {
         cb = values
       }
 
-      process.nextTick(() => {
-        cb(abortController.signal.reason)
-      })
+      if (typeof cb === 'function') {
+        process.nextTick(() => {
+          /** @type {Function} */ (cb)(abortController.signal.reason)
+        })
+      }
       return
     }
 
@@ -230,6 +281,10 @@ function wrapPool (Pool, version) {
   return Pool
 }
 
+/**
+ * @param {Function} PoolCluster
+ * @returns {Function}
+ */
 function wrapPoolCluster (PoolCluster) {
   const startOuterQueryCh = channel('datadog:mysql2:outerquery:start')
   const wrappedPoolNamespaces = new WeakSet()
@@ -239,12 +294,11 @@ function wrapPoolCluster (PoolCluster) {
 
     if (startOuterQueryCh.hasSubscribers && !wrappedPoolNamespaces.has(poolNamespace)) {
       shimmer.wrap(poolNamespace, 'query', query => function (sql, values, cb) {
-        if (sql !== null && typeof sql === 'object') sql = sql.sql
-
-        if (!sql) return query.apply(this, arguments)
+        const resolvedSql = resolveSqlString(sql)
+        if (resolvedSql === undefined) return query.apply(this, arguments)
 
         const abortController = new AbortController()
-        startOuterQueryCh.publish({ sql, abortController })
+        startOuterQueryCh.publish({ sql: resolvedSql, abortController })
 
         if (abortController.signal.aborted) {
           const getConnection = this.getConnection
@@ -274,21 +328,22 @@ function wrapPoolCluster (PoolCluster) {
       })
 
       shimmer.wrap(poolNamespace, 'execute', execute => function (sql, values, cb) {
-        if (sql !== null && typeof sql === 'object') sql = sql.sql
-
-        if (!sql) return execute.apply(this, arguments)
+        const resolvedSql = resolveSqlString(sql)
+        if (resolvedSql === undefined) return execute.apply(this, arguments)
 
         const abortController = new AbortController()
-        startOuterQueryCh.publish({ sql, abortController })
+        startOuterQueryCh.publish({ sql: resolvedSql, abortController })
 
         if (abortController.signal.aborted) {
           if (typeof values === 'function') {
             cb = values
           }
 
-          process.nextTick(() => {
-            cb(abortController.signal.reason)
-          })
+          if (typeof cb === 'function') {
+            process.nextTick(() => {
+              /** @type {Function} */ (cb)(abortController.signal.reason)
+            })
+          }
 
           return
         }
@@ -305,9 +360,21 @@ function wrapPoolCluster (PoolCluster) {
   return PoolCluster
 }
 
-addHook({ name: 'mysql2', file: 'lib/base/connection.js', versions: ['>=3.11.5'] }, wrapConnection)
-addHook({ name: 'mysql2', file: 'lib/connection.js', versions: ['1 - 3.11.4'] }, wrapConnection)
-addHook({ name: 'mysql2', file: 'lib/pool.js', versions: ['1 - 3.11.4'] }, wrapPool)
+addHook(
+  { name: 'mysql2', file: 'lib/base/connection.js', versions: ['>=3.11.5'] },
+  /** @type {(moduleExports: unknown, version: string) => unknown} */ (wrapConnection)
+)
+addHook(
+  { name: 'mysql2', file: 'lib/connection.js', versions: ['1 - 3.11.4'] },
+  /** @type {(moduleExports: unknown, version: string) => unknown} */ (wrapConnection)
+)
+addHook(
+  { name: 'mysql2', file: 'lib/pool.js', versions: ['1 - 3.11.4'] },
+  /** @type {(moduleExports: unknown, version: string) => unknown} */ (wrapPool)
+)
 
 // PoolNamespace.prototype.query does not exist in mysql2<2.3.0
-addHook({ name: 'mysql2', file: 'lib/pool_cluster.js', versions: ['2.3.0 - 3.11.4'] }, wrapPoolCluster)
+addHook(
+  { name: 'mysql2', file: 'lib/pool_cluster.js', versions: ['2.3.0 - 3.11.4'] },
+  /** @type {(moduleExports: unknown, version: string) => unknown} */ (wrapPoolCluster)
+)

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

@@ -41,7 +41,7 @@ const testSuiteToTestStatuses = new Map()
 const testSuiteToErrors = new Map()
 const testsToTestStatuses = new Map()
 
-const RUM_FLUSH_WAIT_TIME = Number(getValueFromEnvSources('DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS')) || 1000
+const RUM_FLUSH_WAIT_TIME = Number(getValueFromEnvSources('DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS')) || 500
 
 let applyRepeatEachIndex = null
 
@@ -396,6 +396,14 @@ function testEndHandler ({
     }
   }
 
+  // Check if all EFD retries failed
+  if (testStatuses.length === earlyFlakeDetectionNumRetries + 1 &&
+    (test._ddIsNew || test._ddIsModified) &&
+    test._ddIsEfdRetry &&
+    testStatuses.every(status => status === 'fail')) {
+    test._ddHasFailedAllRetries = true
+  }
+
   // this handles tests that do not go through the worker process (because they're skipped)
   if (shouldCreateTestSpan) {
     const testResult = results.at(-1)

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

@@ -0,0 +1,92 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { channel, addHook } = require('./helpers/instrument')
+
+const checkoutSessionCreateFinishCh = channel('datadog:stripe:checkoutSession:create:finish')
+const paymentIntentCreateFinishCh = channel('datadog:stripe:paymentIntent:create:finish')
+const constructEventFinishCh = channel('datadog:stripe:constructEvent:finish')
+
+function wrapSessionCreate (create) {
+  return function wrappedSessionCreate () {
+    const promise = create.apply(this, arguments)
+
+    if (!checkoutSessionCreateFinishCh.hasSubscribers) return promise
+
+    return promise.then((result) => {
+      checkoutSessionCreateFinishCh.publish(result)
+      return result
+    })
+  }
+}
+
+function wrapPaymentIntentCreate (create) {
+  return function wrappedPaymentIntentCreate () {
+    const promise = create.apply(this, arguments)
+
+    if (!paymentIntentCreateFinishCh.hasSubscribers) return promise
+
+    return promise.then((result) => {
+      paymentIntentCreateFinishCh.publish(result)
+      return result
+    })
+  }
+}
+
+function wrapConstructEvent (constructEvent) {
+  return function wrappedConstructEvent () {
+    const result = constructEvent.apply(this, arguments)
+
+    // no need to check for hasSubscribers,
+    // if it's false, the publish function will be noop
+    constructEventFinishCh.publish(result)
+
+    return result
+  }
+}
+
+function wrapConstructEventAsync (constructEventAsync) {
+  return function wrappedConstructEventAsync () {
+    const promise = constructEventAsync.apply(this, arguments)
+
+    if (!constructEventFinishCh.hasSubscribers) return promise
+
+    return promise.then((result) => {
+      constructEventFinishCh.publish(result)
+      return result
+    })
+  }
+}
+
+function wrapStripe (Stripe) {
+  return function wrappedStripe () {
+    let stripe = Stripe.apply(this, arguments)
+
+    // to support both with and without "new" operator syntax
+    if (this instanceof Stripe) {
+      stripe = this
+    }
+
+    if (typeof stripe.checkout?.sessions?.create === 'function') {
+      shimmer.wrap(stripe.checkout.sessions, 'create', wrapSessionCreate)
+    }
+    if (typeof stripe.paymentIntents?.create === 'function') {
+      shimmer.wrap(stripe.paymentIntents, 'create', wrapPaymentIntentCreate)
+    }
+    if (typeof stripe.webhooks?.constructEvent === 'function') {
+      shimmer.wrap(stripe.webhooks, 'constructEvent', wrapConstructEvent)
+    }
+    if (typeof stripe.webhooks?.constructEventAsync === 'function') {
+      shimmer.wrap(stripe.webhooks, 'constructEventAsync', wrapConstructEventAsync)
+    }
+
+    return stripe
+  }
+}
+
+addHook({
+  name: 'stripe',
+  versions: ['9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '>=20.0.0'],
+}, Stripe => {
+  return shimmer.wrapFunction(Stripe, wrapStripe)
+})

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

@@ -1036,6 +1036,17 @@ addHook({
             }
           }
 
+          // Check if all EFD retries failed
+          const providedContext = getProvidedContext()
+          if (providedContext.isEarlyFlakeDetectionEnabled && (newTasks.has(task) || modifiedTasks.has(task))) {
+            const statuses = taskToStatuses.get(task)
+            // statuses only includes repetitions (not the initial run), so we check against numRepeats (not +1)
+            if (statuses && statuses.length === providedContext.numRepeats &&
+              statuses.every(status => status === 'fail')) {
+              hasFailedAllRetries = true
+            }
+          }
+
           if (testCtx) {
             const isRetry = task.result?.retryCount > 0
             // `duration` is the duration of all the retries, so it can't be used if there are retries

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

@@ -9,6 +9,19 @@ class AmqplibConsumerPlugin extends ConsumerPlugin {
   static id = 'amqplib'
   static operation = 'consume'
 
+  start (ctx) {
+    if (!this.config.dsmEnabled) return
+    const { fields = {}, message, queue } = ctx
+    if (!message?.properties?.headers) return
+
+    const { span } = ctx.currentStore
+    const queueName = queue || fields.queue || fields.routingKey
+    const payloadSize = getAmqpMessageSize({ headers: message.properties.headers, content: message.content })
+    this.tracer.decodeDataStreamsContext(message.properties.headers)
+    this.tracer
+      .setCheckpoint(['direction:in', `topic:${queueName}`, 'type:rabbitmq'], span, payloadSize)
+  }
+
   bindStart (ctx) {
     const { method, fields = {}, message, queue } = ctx
 
@@ -17,7 +30,7 @@ class AmqplibConsumerPlugin extends ConsumerPlugin {
     const childOf = extract(this.tracer, message)
 
     const queueName = queue || fields.queue || fields.routingKey
-    const span = this.startSpan({
+    this.startSpan({
       childOf,
       resource: getResourceName(method, fields),
       type: 'worker',
@@ -31,15 +44,6 @@ class AmqplibConsumerPlugin extends ConsumerPlugin {
       },
     }, ctx)
 
-    if (
-      this.config.dsmEnabled && message?.properties?.headers
-    ) {
-      const payloadSize = getAmqpMessageSize({ headers: message.properties.headers, content: message.content })
-      this.tracer.decodeDataStreamsContext(message.properties.headers)
-      this.tracer
-        .setCheckpoint(['direction:in', `topic:${queueName}`, 'type:rabbitmq'], span, payloadSize)
-    }
-
     return ctx.currentStore
   }
 }

package/packages/datadog-plugin-amqplib/src/producer.js

@@ -10,8 +10,30 @@ class AmqplibProducerPlugin extends ProducerPlugin {
   static id = 'amqplib'
   static operation = 'publish'
 
+  start (ctx) {
+    if (!this.config.dsmEnabled) return
+    const { fields, message } = ctx
+    const { span } = ctx.currentStore
+
+    const hasRoutingKey = fields.routingKey != null
+    const payloadSize = getAmqpMessageSize({ content: message, headers: fields.headers })
+
+    // there are two ways to send messages in RabbitMQ:
+    // 1. using an exchange and a routing key in which DSM connects via the exchange
+    // 2. using an unnamed exchange and a routing key in which DSM connects via the topic
+    const exchangeOrTopicTag = hasRoutingKey && !fields.exchange
+      ? `topic:${fields.routingKey}`
+      : `exchange:${fields.exchange}`
+
+    const dataStreamsContext = this.tracer.setCheckpoint(
+      ['direction:out', exchangeOrTopicTag, `has_routing_key:${hasRoutingKey}`, 'type:rabbitmq'],
+      span, payloadSize
+    )
+    DsmPathwayCodec.encode(dataStreamsContext, fields.headers)
+  }
+
   bindStart (ctx) {
-    const { channel = {}, method, fields, message } = ctx
+    const { channel = {}, method, fields } = ctx
 
     if (method !== 'basic.publish') return
 
@@ -34,24 +56,6 @@ class AmqplibProducerPlugin extends ProducerPlugin {
 
     this.tracer.inject(span, TEXT_MAP, fields.headers)
 
-    if (this.config.dsmEnabled) {
-      const hasRoutingKey = fields.routingKey != null
-      const payloadSize = getAmqpMessageSize({ content: message, headers: fields.headers })
-
-      // there are two ways to send messages in RabbitMQ:
-      // 1. using an exchange and a routing key in which DSM connects via the exchange
-      // 2. using an unnamed exchange and a routing key in which DSM connects via the topic
-      const exchangeOrTopicTag = hasRoutingKey && !fields.exchange
-        ? `topic:${fields.routingKey}`
-        : `exchange:${fields.exchange}`
-
-      const dataStreamsContext = this.tracer
-        .setCheckpoint(
-          ['direction:out', exchangeOrTopicTag, `has_routing_key:${hasRoutingKey}`, 'type:rabbitmq']
-          , span, payloadSize)
-      DsmPathwayCodec.encode(dataStreamsContext, fields.headers)
-    }
-
     return ctx.currentStore
   }
 }