dd-trace 5.52.0 → 5.54.0

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

@@ -34,6 +34,12 @@ addHook({
       delete this.options._ddEfdNumRetries
       delete this.options._ddIsKnownTestsEnabled
     }
+    if (this.options._ddIsImpactedTestsEnabled) {
+      config.isImpactedTestsEnabled = true
+      config.modifiedTests = this.options._ddModifiedTests
+      delete this.options._ddIsImpactedTestsEnabled
+      delete this.options._ddModifiedTests
+    }
     if (this.options._ddIsTestManagementTestsEnabled) {
       config.isTestManagementTestsEnabled = true
       // TODO: attempt to fix does not work in parallel mode yet

package/packages/datadog-instrumentations/src/mongodb-core.js

@@ -204,7 +204,7 @@ function instrumentPromise (operation, command, ctx, args, server, ns, ops, opti
       errorCh.publish(err)
       finishCh.publish()
 
-      return Promise.reject(err)
+      throw err
     })
   })
 }

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

@@ -1,10 +1,6 @@
 'use strict'
 
-const {
-  channel,
-  addHook,
-  AsyncResource
-} = require('./helpers/instrument')
+const { channel, addHook, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
 addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connection => {
@@ -19,43 +15,38 @@ addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connect
 
     const sql = arguments[0].sql || arguments[0]
     const conf = this.config
-    const payload = { sql, conf }
-
-    const callbackResource = new AsyncResource('bound-anonymous-fn')
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
-    return asyncResource.runInAsyncScope(() => {
-      startCh.publish(payload)
+    const ctx = { sql, conf }
 
+    return startCh.runStores(ctx, () => {
       if (arguments[0].sql) {
-        arguments[0].sql = payload.sql
+        arguments[0].sql = ctx.sql
       } else {
-        arguments[0] = payload.sql
+        arguments[0] = ctx.sql
       }
+
       try {
         const res = query.apply(this, arguments)
 
         if (res._callback) {
-          const cb = callbackResource.bind(res._callback)
-          res._callback = shimmer.wrapFunction(cb, cb => asyncResource.bind(function (error, result) {
+          const cb = res._callback
+          res._callback = shimmer.wrapFunction(cb, cb => function (error, result) {
             if (error) {
-              errorCh.publish(error)
+              ctx.error = error
+              errorCh.publish(ctx)
             }
-            finishCh.publish(result)
+            ctx.result = result
 
-            return cb.apply(this, arguments)
-          }))
-        } else {
-          const cb = asyncResource.bind(function () {
-            finishCh.publish(undefined)
+            return finishCh.runStores(ctx, cb, this, error, result)
           })
-          res.on('end', cb)
+        } else {
+          res.on('end', () => finishCh.publish(ctx))
         }
 
         return res
       } catch (err) {
         err.stack // trigger getting the stack at the original throwing point
-        errorCh.publish(err)
+        ctx.error = err
+        errorCh.publish(ctx)
 
         throw err
       }
@@ -79,22 +70,15 @@ addHook({ name: 'mysql', file: 'lib/Pool.js', versions: ['>=2'] }, Pool => {
       return query.apply(this, arguments)
     }
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
     const sql = arguments[0].sql || arguments[0]
+    const ctx = { sql }
+    const finish = () => finishPoolQueryCh.publish(ctx)
 
-    return asyncResource.runInAsyncScope(() => {
-      startPoolQueryCh.publish({ sql })
-
-      const finish = asyncResource.bind(function () {
-        finishPoolQueryCh.publish()
-      })
-
+    return startPoolQueryCh.runStores(ctx, () => {
       const cb = arguments[arguments.length - 1]
       if (typeof cb === 'function') {
         arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => function () {
-          finish()
-          return cb.apply(this, arguments)
+          return finishPoolQueryCh.runStores(ctx, cb, this, ...arguments)
         })
       }
 

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

@@ -1,10 +1,8 @@
 'use strict'
 
-const {
-  channel,
-  addHook,
-  AsyncResource
-} = require('./helpers/instrument')
+const { errorMonitor } = require('node:events')
+
+const { channel, addHook } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 const satisfies = require('semifies')
 
@@ -13,22 +11,25 @@ function wrapConnection (Connection, version) {
   const finishCh = channel('apm:mysql2:query:finish')
   const errorCh = channel('apm:mysql2:query:error')
   const startOuterQueryCh = channel('datadog:mysql2:outerquery:start')
+  const commandAddCh = channel('apm:mysql2:command:add')
+  const commandStartCh = channel('apm:mysql2:command:start')
+  const commandFinishCh = channel('apm:mysql2:command:finish')
   const shouldEmitEndAfterQueryAbort = satisfies(version, '>=1.3.3')
 
   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')
+    const ctx = {}
 
     // TODO: consider supporting all commands and not just queries
     cmd.execute = isQuery
-      ? wrapExecute(cmd, cmd.execute, asyncResource, this.config)
-      : bindExecute(cmd, cmd.execute, asyncResource)
+      ? wrapExecute(cmd, cmd.execute, ctx, this.config)
+      : bindExecute(cmd.execute, ctx)
 
-    return asyncResource.bind(addCommand, this).apply(this, arguments)
+    return commandAddCh.runStores(ctx, addCommand, this, ...arguments)
   })
 
   shimmer.wrap(Connection.prototype, 'query', query => function (sql, values, cb) {
@@ -103,53 +104,60 @@ function wrapConnection (Connection, version) {
 
   return Connection
 
-  function bindExecute (cmd, execute, asyncResource) {
-    return shimmer.wrapFunction(execute, execute => asyncResource.bind(function executeWithTrace (packet, connection) {
-      if (this.onResult) {
-        this.onResult = asyncResource.bind(this.onResult)
+  function bindExecute (execute, ctx) {
+    return shimmer.wrapFunction(execute, execute => function executeWithTrace (packet, connection) {
+      const onResult = this.onResult
+
+      if (onResult) {
+        this.onResult = function () {
+          return commandFinishCh.runStores(ctx, onResult, this, ...arguments)
+        }
       }
 
-      return execute.apply(this, arguments)
-    }, cmd))
+      return commandStartCh.runStores(ctx, execute, this, ...arguments)
+    })
   }
 
-  function wrapExecute (cmd, execute, asyncResource, config) {
-    const callbackResource = new AsyncResource('bound-anonymous-fn')
+  function wrapExecute (cmd, execute, ctx, config) {
+    return shimmer.wrapFunction(execute, execute => function executeWithTrace (packet, connection) {
+      ctx.sql = cmd.statement ? cmd.statement.query : cmd.sql
+      ctx.conf = config
 
-    return shimmer.wrapFunction(execute, execute => asyncResource.bind(function executeWithTrace (packet, connection) {
-      const sql = cmd.statement ? cmd.statement.query : cmd.sql
-      const payload = { sql, conf: config }
-      startCh.publish(payload)
-
-      if (cmd.statement) {
-        cmd.statement.query = payload.sql
-      } else {
-        cmd.sql = payload.sql
-      }
+      return startCh.runStores(ctx, () => {
+        if (cmd.statement) {
+          cmd.statement.query = ctx.sql
+        } else {
+          cmd.sql = ctx.sql
+        }
 
-      if (this.onResult) {
-        const onResult = callbackResource.bind(this.onResult)
+        if (this.onResult) {
+          const onResult = this.onResult
 
-        this.onResult = shimmer.wrapFunction(onResult, onResult => asyncResource.bind(function (error) {
-          if (error) {
-            errorCh.publish(error)
-          }
-          finishCh.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(() => finishCh.publish(undefined)))
-      }
+          this.onResult = shimmer.wrapFunction(onResult, onResult => function (error) {
+            if (error) {
+              ctx.error = error
+              errorCh.publish(ctx)
+            }
+            finishCh.runStores(ctx, onResult, this, ...arguments)
+          })
+        } else {
+          this.on(errorMonitor, error => {
+            ctx.error = error
+            errorCh.publish(ctx)
+          })
+          this.on('end', () => finishCh.publish(ctx))
+        }
 
-      this.execute = execute
+        this.execute = execute
 
-      try {
-        return execute.apply(this, arguments)
-      } catch (err) {
-        errorCh.publish(err)
-      }
-    }, cmd))
+        try {
+          return execute.apply(this, arguments)
+        } catch (err) {
+          ctx.error = err
+          errorCh.publish(ctx)
+        }
+      })
+    }, cmd)
   }
 }
 function wrapPool (Pool, version) {

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

@@ -1,5 +1,7 @@
 'use strict'
 
+const { errorMonitor } = require('events')
+
 const { channel, addHook } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -85,7 +87,7 @@ function getOptions (args) {
       if (Array.isArray(args[0])) return getOptions(args[0])
       return args[0]
     case 'string':
-      if (isNaN(parseFloat(args[0]))) {
+      if (Number.isNaN(Number.parseFloat(args[0]))) {
         return {
           path: args[0]
         }
@@ -99,7 +101,7 @@ function getOptions (args) {
 }
 
 function setupListeners (socket, protocol, ctx, finishCh, errorCh) {
-  const events = ['connect', 'error', 'close', 'timeout']
+  const events = ['connect', errorMonitor, 'close', 'timeout']
 
   const wrapListener = function (error) {
     if (error) {

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

@@ -70,7 +70,7 @@ function wrapRenderToHTML (renderToHTML) {
 
 function wrapRenderErrorToHTML (renderErrorToHTML) {
   return function (err, req, res, pathname, query) {
-    return instrument(req, res, err, () => renderErrorToHTML.apply(this, arguments))
+    return instrument(req, res, () => renderErrorToHTML.apply(this, arguments), err)
   }
 }
 
@@ -82,7 +82,7 @@ function wrapRenderToResponse (renderToResponse) {
 
 function wrapRenderErrorToResponse (renderErrorToResponse) {
   return function (ctx, err) {
-    return instrument(ctx.req, ctx.res, err, () => renderErrorToResponse.apply(this, arguments))
+    return instrument(ctx.req, ctx.res, () => renderErrorToResponse.apply(this, arguments), err)
   }
 }
 
@@ -108,6 +108,7 @@ function getPagePath (maybePage) {
 
 function getPageFromPath (page, dynamicRoutes = []) {
   for (const dynamicRoute of dynamicRoutes) {
+    // eslint-disable-next-line unicorn/prefer-regexp-test
     if (dynamicRoute.page.startsWith('/api') && dynamicRoute.match(page)) {
       return getPagePath(dynamicRoute.page)
     }
@@ -121,12 +122,7 @@ function getRequestMeta (req, key) {
   return typeof key === 'string' ? meta[key] : meta
 }
 
-function instrument (req, res, error, handler) {
-  if (typeof error === 'function') {
-    handler = error
-    error = null
-  }
-
+function instrument (req, res, handler, error) {
   req = req.originalRequest || req
   res = res.originalResponse || res
 
@@ -216,13 +212,13 @@ addHook({
   name: 'next',
   versions: ['>=11.1'],
   file: 'dist/server/serve-static.js'
-}, serveStatic => shimmer.wrap(serveStatic, 'serveStatic', wrapServeStatic))
+}, serveStatic => shimmer.wrap(serveStatic, 'serveStatic', wrapServeStatic, { replaceGetter: true }))
 
 addHook({
   name: 'next',
   versions: ['>=10.2 <11.1'],
   file: 'dist/next-server/server/serve-static.js'
-}, serveStatic => shimmer.wrap(serveStatic, 'serveStatic', wrapServeStatic))
+}, serveStatic => shimmer.wrap(serveStatic, 'serveStatic', wrapServeStatic, { replaceGetter: true }))
 
 addHook({ name: 'next', versions: ['>=11.1'], file: 'dist/server/next-server.js' }, nextServer => {
   const Server = nextServer.default
@@ -282,8 +278,7 @@ addHook({
   versions: ['>=13'],
   file: 'dist/server/web/spec-extension/request.js'
 }, request => {
-  const nextUrlDescriptor = Object.getOwnPropertyDescriptor(request.NextRequest.prototype, 'nextUrl')
-  shimmer.wrap(nextUrlDescriptor, 'get', function (originalGet) {
+  shimmer.wrap(request.NextRequest.prototype, 'nextUrl', function (originalGet) {
     return function wrappedGet () {
       const nextUrl = originalGet.apply(this, arguments)
       if (queryParsedChannel.hasSubscribers) {
@@ -300,8 +295,6 @@ addHook({
     }
   })
 
-  Object.defineProperty(request.NextRequest.prototype, 'nextUrl', nextUrlDescriptor)
-
   shimmer.massWrap(request.NextRequest.prototype, ['text', 'json'], function (originalMethod) {
     return async function wrappedJson () {
       const body = await originalMethod.apply(this, arguments)

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

@@ -14,7 +14,7 @@ addHook({
       if (JSON.parse(process.env.NYC_CONFIG).all) {
         codeCoverageWrapCh.publish(this)
       }
-    } catch (e) {
+    } catch {
       // ignore errors
     }
 

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

@@ -137,10 +137,7 @@ function addStreamedChunk (content, chunk) {
   for (const choice of chunk.choices) {
     const choiceIdx = choice.index
     const oldChoice = content.choices.find(choice => choice?.index === choiceIdx)
-    if (!oldChoice) {
-      // we don't know which choices arrive in which order
-      content.choices[choiceIdx] = choice
-    } else {
+    if (oldChoice) {
       if (!oldChoice.finish_reason) {
         oldChoice.finish_reason = choice.finish_reason
       }
@@ -177,13 +174,15 @@ function addStreamedChunk (content, chunk) {
 
           if (oldTool) {
             oldTool.function.arguments += newTool.function.arguments
-          } else {
-            return newTool
+            return oldTool
           }
 
-          return oldTool
+          return newTool
         })
       }
+    } else {
+      // we don't know which choices arrive in which order
+      content.choices[choiceIdx] = choice
     }
   }
 }
@@ -193,8 +192,7 @@ function convertBufferstoObjects (chunks = []) {
     .concat(chunks) // combine the buffers
     .toString() // stringify
     .split(/(?=data:)/) // split on "data:"
-    .map(chunk => chunk.split('\n').join('')) // remove newlines
-    .map(chunk => chunk.substring(6)) // remove 'data: ' from the front
+    .map(chunk => chunk.replace(/\n/g, '').slice(6)) // remove newlines and 'data: ' from the front
     .slice(0, -1) // remove the last [DONE] message
     .map(JSON.parse) // parse all of the returned objects
 }
@@ -217,6 +215,10 @@ function wrapStreamIterator (response, options, n, ctx) {
 
             if (chunk) {
               chunks.push(chunk)
+              // TODO(BridgeAR): It likely depends on the options being passed
+              // through if the stream returns buffers or not. By reading that,
+              // we don't have to do the instanceof check anymore, which is
+              // relatively expensive.
               if (chunk instanceof Buffer) {
                 // this operation should be safe
                 // if one chunk is a buffer (versus a plain object), the rest should be as well
@@ -226,21 +228,17 @@ function wrapStreamIterator (response, options, n, ctx) {
 
             if (done) {
               let body = {}
-              chunks = chunks.filter(chunk => chunk != null) // filter null or undefined values
-
-              if (chunks) {
-                if (processChunksAsBuffers) {
-                  chunks = convertBufferstoObjects(chunks)
-                }
+              if (processChunksAsBuffers) {
+                chunks = convertBufferstoObjects(chunks)
+              }
 
-                if (chunks.length) {
-                  // define the initial body having all the content outside of choices from the first chunk
-                  // this will include import data like created, id, model, etc.
-                  body = { ...chunks[0], choices: Array.from({ length: n }) }
-                  // start from the first chunk, and add its choices into the body
-                  for (let i = 0; i < chunks.length; i++) {
-                    addStreamedChunk(body, chunks[i])
-                  }
+              if (chunks.length) {
+                // Define the initial body having all the content outside of choices from the first chunk
+                // this will include import data like created, id, model, etc.
+                body = { ...chunks[0], choices: Array.from({ length: n }) }
+                // Start from the first chunk, and add its choices into the body
+                for (const chunk_ of chunks) {
+                  addStreamedChunk(body, chunk_)
                 }
               }
 

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

@@ -18,7 +18,7 @@ function finish (err) {
   if (err) {
     errorChannel.publish(err)
   }
-  finishChannel.publish(undefined)
+  finishChannel.publish()
 }
 
 addHook({ name: 'oracledb', versions: ['>=5'] }, oracledb => {

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

@@ -45,7 +45,7 @@ function wrapQuery (query) {
     const textProp = Object.getOwnPropertyDescriptor(textPropObj, 'text')
     const stream = typeof textPropObj.read === 'function'
 
-    // Only alter `text` property if safe to do so.
+    // Only alter `text` property if safe to do so. Initially, it's a property, not a getter.
     if (!textProp || textProp.configurable) {
       const originalText = textPropObj.text
 
@@ -77,7 +77,6 @@ function wrapQuery (query) {
       if (abortController.signal.aborted) {
         const error = abortController.signal.reason || new Error('Aborted')
 
-        // eslint-disable-next-line @stylistic/js/max-len
         // Based on: https://github.com/brianc/node-postgres/blob/54eb0fa216aaccd727765641e7d1cf5da2bc483d/packages/pg/lib/client.js#L510
         const reusingQuery = typeof pgQuery.submit === 'function'
         const callback = arguments[arguments.length - 1]
@@ -115,7 +114,7 @@ function wrapQuery (query) {
       const queryQueue = this.queryQueue || this._queryQueue
       const activeQuery = this.activeQuery || this._activeQuery
 
-      const newQuery = queryQueue[queryQueue.length - 1] || activeQuery
+      const newQuery = queryQueue.at(-1) || activeQuery
 
       if (!newQuery) {
         return retval
@@ -129,21 +128,15 @@ function wrapQuery (query) {
         }
       } else if (newQuery.once) {
         newQuery
-          .once('error', finish)
+          .once(errorMonitor, finish)
           .once('end', (res) => finish(null, res))
       } else {
+        // TODO: This code is never reached in our tests.
+        // Internally, pg always uses callbacks or streams, even for promise based queries.
+        // Investigate if this code should just be removed.
         newQuery.then((res) => finish(null, res), finish)
       }
 
-      if (stream) {
-        newQuery.on('end', () => {
-          finish(null, [])
-        })
-        newQuery.on(errorMonitor, (err) => {
-          finish(err)
-        })
-      }
-
       try {
         return retval
       } catch (err) {