dd-trace 5.53.0 → 5.55.0

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

@@ -2,11 +2,7 @@
 
 const { errorMonitor } = require('node:events')
 
-const {
-  channel,
-  addHook,
-  AsyncResource
-} = require('./helpers/instrument')
+const { channel, addHook } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 const satisfies = require('semifies')
 
@@ -15,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) {
@@ -105,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')
-
-    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)
+  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
 
-      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(errorMonitor, 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

@@ -87,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]
         }

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

@@ -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)
     }

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

@@ -1,5 +1,6 @@
 const { addHook, channel } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
+const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
 
 const codeCoverageWrapCh = channel('ci:nyc:wrap')
 
@@ -11,10 +12,10 @@ addHook({
   shimmer.wrap(nycPackage.prototype, 'wrap', wrap => function () {
     // Only relevant if the config `all` is set to true
     try {
-      if (JSON.parse(process.env.NYC_CONFIG).all) {
+      if (JSON.parse(getEnvironmentVariable('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,24 +174,25 @@ 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
     }
   }
 }
 
-function convertBufferstoObjects (chunks = []) {
+function convertBufferstoObjects (chunks) {
   return Buffer
     .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.replaceAll('\n', '').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/otel-sdk-trace.js

@@ -3,10 +3,11 @@
 const { addHook } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 const tracer = require('../../dd-trace')
+const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
 
-const otelSdkEnabled = process.env.DD_TRACE_OTEL_ENABLED ||
-process.env.OTEL_SDK_DISABLED
-  ? !process.env.OTEL_SDK_DISABLED
+const otelSdkEnabled = getEnvironmentVariable('DD_TRACE_OTEL_ENABLED') ||
+getEnvironmentVariable('OTEL_SDK_DISABLED')
+  ? !getEnvironmentVariable('OTEL_SDK_DISABLED')
   : undefined
 
 if (otelSdkEnabled) {

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

@@ -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
@@ -179,9 +178,8 @@ function wrapPoolQuery (query) {
           cb(error)
 
           return
-        } else {
-          return Promise.reject(error)
         }
+        return Promise.reject(error)
       }
 
       if (typeof cb === 'function') {
@@ -193,7 +191,7 @@ function wrapPoolQuery (query) {
 
       const retval = query.apply(this, arguments)
 
-      if (retval && retval.then) {
+      if (retval?.then) {
         retval.then(() => {
           finish()
         }).catch(() => {