dd-trace 5.61.1 → 5.63.0

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

@@ -148,63 +148,66 @@ function wrapCommand (command, operation, name) {
   return wrapped
 }
 
-function instrument (operation, command, ctx, args, server, ns, ops, options = {}) {
+function instrument (operation, command, instance, args, server, ns, ops, options = {}) {
   const name = options.name || (ops && Object.keys(ops)[0])
   const index = args.length - 1
-  let callback = args[index]
+  const callback = args[index]
 
-  if (typeof callback !== 'function') return command.apply(ctx, args)
+  if (typeof callback !== 'function') return command.apply(instance, args)
 
   const serverInfo = server && server.s && server.s.options
-  const callbackResource = new AsyncResource('bound-anonymous-fn')
-  const asyncResource = new AsyncResource('bound-anonymous-fn')
 
-  callback = callbackResource.bind(callback)
-
-  return asyncResource.runInAsyncScope(() => {
-    startCh.publish({ ns, ops, options: serverInfo, name })
-
-    args[index] = shimmer.wrapFunction(callback, callback => asyncResource.bind(function (err, res) {
+  const ctx = {
+    ns,
+    ops,
+    options: serverInfo,
+    name
+  }
+  return startCh.runStores(ctx, () => {
+    args[index] = shimmer.wrapFunction(callback, callback => function (err, res) {
       if (err) {
-        errorCh.publish(err)
+        ctx.error = err
+        errorCh.publish(ctx)
       }
 
-      finishCh.publish()
-
-      if (callback) {
-        return callback.apply(this, arguments)
-      }
-    }))
+      return finishCh.runStores(ctx, callback, this, ...arguments)
+    })
 
     try {
-      return command.apply(ctx, args)
+      return command.apply(instance, args)
     } catch (err) {
-      errorCh.publish(err)
+      ctx.error = err
+      errorCh.publish(ctx)
 
       throw err
     }
   })
 }
 
-function instrumentPromise (operation, command, ctx, args, server, ns, ops, options = {}) {
+function instrumentPromise (operation, command, instance, args, server, ns, ops, options = {}) {
   const name = options.name || (ops && Object.keys(ops)[0])
 
   const serverInfo = server && server.s && server.s.options
-  const asyncResource = new AsyncResource('bound-anonymous-fn')
 
-  return asyncResource.runInAsyncScope(() => {
-    startCh.publish({ ns, ops, options: serverInfo, name })
+  const ctx = {
+    ns,
+    ops,
+    options: serverInfo,
+    name
+  }
 
-    const promise = command.apply(ctx, args)
+  return startCh.runStores(ctx, () => {
+    const promise = command.apply(instance, args)
 
-    return promise.then(function (res) {
-      finishCh.publish()
-      return res
+    promise.then(function (res) {
+      ctx.result = res
+      finishCh.publish(ctx)
     }, function (err) {
-      errorCh.publish(err)
-      finishCh.publish()
-
-      throw err
+      ctx.error = err
+      errorCh.publish(ctx)
+      finishCh.publish(ctx)
     })
+
+    return promise
   })
 }

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

@@ -4,8 +4,7 @@ require('./mongodb-core')
 
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -41,19 +40,16 @@ addHook({ name: 'mongodb', versions: ['>=3.3 <5', '5', '>=6'] }, mongodb => {
           return method.apply(this, arguments)
         }
 
-        const asyncResource = new AsyncResource('bound-anonymous-fn')
-
-        return asyncResource.runInAsyncScope(() => {
-          const filters = [arguments[0]]
-          if (useTwoArguments) {
-            filters.push(arguments[1])
-          }
+        const ctx = {
+          filters: [arguments[0]],
+          methodName
+        }
 
-          startCh.publish({
-            filters,
-            methodName
-          })
+        if (useTwoArguments) {
+          ctx.filters.push(arguments[1])
+        }
 
+        return startCh.runStores(ctx, () => {
           return method.apply(this, arguments)
         })
       }

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

@@ -2,19 +2,24 @@
 
 const { addHook, channel } = require('./helpers/instrument')
 const { wrapThen } = require('./helpers/promise')
-const { AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
+const startCh = channel('datadog:mongoose:model:filter:start')
+const finishCh = channel('datadog:mongoose:model:filter:finish')
+// this channel is for wrapping the callback of exec methods and handling store context
+const execStartCh = channel('apm:mongoose:exec:start')
+const execFinishCh = channel('apm:mongoose:exec:finish')
+
 function wrapAddQueue (addQueue) {
-  return function addQueueWithTrace (name) {
-    if (typeof name === 'function') {
-      arguments[0] = AsyncResource.bind(name)
-    } else if (typeof this[name] === 'function') {
-      arguments[0] = AsyncResource.bind((...args) => this[name](...args))
-    }
+  const ctx = {}
 
-    return addQueue.apply(this, arguments)
-  }
+  return execStartCh.runStores(ctx, () => {
+    return function addQueueWithTrace (name) {
+      return execFinishCh.runStores(ctx, () => {
+        return addQueue.apply(this, arguments)
+      })
+    }
+  })
 }
 
 addHook({
@@ -31,9 +36,6 @@ addHook({
   return mongoose
 })
 
-const startCh = channel('datadog:mongoose:model:filter:start')
-const finishCh = channel('datadog:mongoose:model:filter:finish')
-
 const collectionMethodsWithFilter = [
   'count',
   'countDocuments',
@@ -68,27 +70,21 @@ addHook({
           return method.apply(this, arguments)
         }
 
-        const asyncResource = new AsyncResource('bound-anonymous-fn')
-
         const filters = [arguments[0]]
         if (useTwoArguments) {
           filters.push(arguments[1])
         }
 
-        const finish = asyncResource.bind(function () {
-          finishCh.publish()
-        })
-
         let callbackWrapped = false
 
-        const wrapCallbackIfExist = (args) => {
+        const wrapCallbackIfExist = (args, ctx) => {
           const lastArgumentIndex = args.length - 1
 
           if (typeof args[lastArgumentIndex] === 'function') {
             // is a callback, wrap it to execute finish()
             shimmer.wrap(args, lastArgumentIndex, originalCb => {
               return function () {
-                finish()
+                finishCh.publish(ctx)
 
                 return originalCb.apply(this, arguments)
               }
@@ -98,13 +94,13 @@ addHook({
           }
         }
 
-        wrapCallbackIfExist(arguments)
+        const ctx = {
+          filters,
+          methodName
+        }
 
-        return asyncResource.runInAsyncScope(() => {
-          startCh.publish({
-            filters,
-            methodName
-          })
+        return startCh.runStores(ctx, () => {
+          wrapCallbackIfExist(arguments, ctx)
 
           const res = method.apply(this, arguments)
 
@@ -113,7 +109,7 @@ addHook({
             shimmer.wrap(res, 'exec', originalExec => {
               return function wrappedExec () {
                 if (!callbackWrapped) {
-                  wrapCallbackIfExist(arguments)
+                  wrapCallbackIfExist(arguments, ctx)
                 }
 
                 const execResult = originalExec.apply(this, arguments)
@@ -129,7 +125,7 @@ addHook({
                     const reject = arguments[1]
 
                     arguments[0] = shimmer.wrapFunction(resolve, resolve => function wrappedResolve () {
-                      finish()
+                      finishCh.publish(ctx)
 
                       if (resolve) {
                         return resolve.apply(this, arguments)
@@ -137,7 +133,7 @@ addHook({
                     })
 
                     arguments[1] = shimmer.wrapFunction(reject, reject => function wrappedReject () {
-                      finish()
+                      finishCh.publish(ctx)
 
                       if (reject) {
                         return reject.apply(this, arguments)

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

@@ -162,14 +162,16 @@ function instrument (req, res, handler, error) {
 
       // promise should only reject when propagateError is true:
       // https://github.com/vercel/next.js/blob/cee656238a/packages/next/server/api-utils/node.ts#L547
-      return promise.then(
+      promise.then(
         result => finish(ctx, result),
         err => finish(ctx, null, err)
       )
+      return promise
     } catch (e) {
       // this will probably never happen as the handler caller is an async function:
       // https://github.com/vercel/next.js/blob/cee656238a/packages/next/server/api-utils/node.ts#L420
-      return finish(ctx, null, e)
+      finish(ctx, null, e)
+      throw e
     }
   })
 }
@@ -198,12 +200,6 @@ function finish (ctx, result, err) {
   }
 
   finishChannel.publish(ctx)
-
-  if (err) {
-    throw err
-  }
-
-  return result
 }
 
 // also wrapped in dist/server/future/route-handlers/app-route-route-handler.js

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

@@ -151,7 +151,6 @@ addHook({ name: 'openai', file: 'dist/api.js', versions: ['>=3.0.0 <4'] }, expor
         methodName,
         args: arguments,
         basePath: this.basePath,
-        apiKey: this.configuration.apiKey
       }
 
       return ch.tracePromise(fn, ctx, this, ...arguments)
@@ -224,7 +223,6 @@ for (const extension of extensions) {
             methodName: `${baseResource}.${methodName}`,
             args: arguments,
             basePath: client.baseURL,
-            apiKey: client.apiKey
           }
 
           return ch.start.runStores(ctx, () => {

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

@@ -2,8 +2,7 @@
 
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -14,11 +13,11 @@ const startChannel = channel('apm:oracledb:query:start')
 const errorChannel = channel('apm:oracledb:query:error')
 const finishChannel = channel('apm:oracledb:query:finish')
 
-function finish (err) {
-  if (err) {
-    errorChannel.publish(err)
+function finish (ctx) {
+  if (ctx.error) {
+    errorChannel.publish(ctx)
   }
-  finishChannel.publish()
+  finishChannel.publish(ctx)
 }
 
 addHook({ name: 'oracledb', versions: ['>=5'] }, oracledb => {
@@ -30,49 +29,55 @@ addHook({ name: 'oracledb', versions: ['>=5'] }, oracledb => {
 
       if (arguments.length && typeof arguments[arguments.length - 1] === 'function') {
         const cb = arguments[arguments.length - 1]
-        const outerAr = new AsyncResource('apm:oracledb:outer-scope')
         arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => function wrappedCb (err, result) {
-          finish(err)
-          return outerAr.runInAsyncScope(() => cb.apply(this, arguments))
+          if (err) {
+            ctx.error = err
+            errorChannel.publish(ctx)
+          }
+          return finishChannel.runStores(ctx, () => {
+            return cb.apply(this, arguments)
+          })
         })
       }
 
-      return new AsyncResource('apm:oracledb:inner-scope').runInAsyncScope(() => {
-        // The connAttrs are used to pass through the argument to the potential
-        // serviceName method a user might have passed through as well as parsing
-        // the connection string in v5.
-        const connAttrs = connectionAttributes.get(this)
+      // The connAttrs are used to pass through the argument to the potential
+      // serviceName method a user might have passed through as well as parsing
+      // the connection string in v5.
+      const connAttrs = connectionAttributes.get(this)
 
-        const details = typeof this.hostName === 'string' ? this : this._impl
+      const details = typeof this.hostName === 'string' ? this : this._impl
 
-        let hostname
-        let port
-        let dbInstance
+      let hostname
+      let port
+      let dbInstance
 
-        if (details) {
-          dbInstance = details.serviceName
-          hostname = details.hostName ?? details.nscon?.ntAdapter?.hostName
-          port = String(details.port ?? details.nscon?.ntAdapter?.port ?? '')
-        }
+      if (details) {
+        dbInstance = details.serviceName
+        hostname = details.hostName ?? details.nscon?.ntAdapter?.hostName
+        port = String(details.port ?? details.nscon?.ntAdapter?.port ?? '')
+      }
 
-        startChannel.publish({
-          query: dbQuery,
-          connAttrs,
-          dbInstance,
-          port,
-          hostname,
-        })
+      const ctx = {
+        dbInstance,
+        port,
+        hostname,
+        query: dbQuery,
+        connAttrs
+      }
+
+      return startChannel.runStores(ctx, () => {
         try {
           let result = execute.apply(this, arguments)
 
           if (typeof result?.then === 'function') {
             result = result.then(
               x => {
-                finish()
+                finish(ctx)
                 return x
               },
               e => {
-                finish(e)
+                ctx.error = e
+                finish(ctx)
                 throw e
               }
             )
@@ -80,7 +85,8 @@ addHook({ name: 'oracledb', versions: ['>=5'] }, oracledb => {
 
           return result
         } catch (err) {
-          errorChannel.publish(err)
+          ctx.error = err
+          finish(ctx)
           throw err
         }
       })

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

@@ -2,8 +2,7 @@
 
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -33,8 +32,6 @@ function wrapQuery (query) {
       return query.apply(this, arguments)
     }
 
-    const callbackResource = new AsyncResource('bound-anonymous-fn')
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
     const processId = this.processID
 
     const pgQuery = arguments[0] !== null && typeof arguments[0] === 'object'
@@ -46,8 +43,9 @@ function wrapQuery (query) {
     const stream = typeof textPropObj.read === 'function'
 
     // Only alter `text` property if safe to do so. Initially, it's a property, not a getter.
+    let originalText
     if (!textProp || textProp.configurable) {
-      const originalText = textPropObj.text
+      originalText = textPropObj.text
 
       Object.defineProperty(textPropObj, 'text', {
         get () {
@@ -55,25 +53,24 @@ function wrapQuery (query) {
         }
       })
     }
-
-    return asyncResource.runInAsyncScope(() => {
-      const abortController = new AbortController()
-
-      startCh.publish({
-        params: this.connectionParameters,
-        query: textPropObj,
-        processId,
-        abortController,
-        stream
-      })
-
-      const finish = asyncResource.bind(function (error, res) {
-        if (error) {
-          errorCh.publish(error)
-        }
-        finishCh.publish({ result: res?.rows })
-      })
-
+    const abortController = new AbortController()
+    const ctx = {
+      params: this.connectionParameters,
+      query: textPropObj,
+      originalText,
+      processId,
+      abortController,
+      stream
+    }
+    const finish = (error, res) => {
+      if (error) {
+        ctx.error = error
+        errorCh.publish(ctx)
+      }
+      ctx.result = res?.rows
+      return finishCh.publish(ctx)
+    }
+    return startCh.runStores(ctx, () => {
       if (abortController.signal.aborted) {
         const error = abortController.signal.reason || new Error('Aborted')
 
@@ -121,10 +118,10 @@ function wrapQuery (query) {
       }
 
       if (newQuery.callback) {
-        const originalCallback = callbackResource.bind(newQuery.callback)
-        newQuery.callback = function (err, res) {
-          finish(err, res)
-          return originalCallback.apply(this, arguments)
+        const originalCallback = newQuery.callback
+        newQuery.callback = function (err, ...args) {
+          finish(err, ...args)
+          return finishCh.runStores(ctx, originalCallback, this, err, ...args)
         }
       } else if (newQuery.once) {
         newQuery
@@ -139,40 +136,33 @@ function wrapQuery (query) {
 
       try {
         return retval
-      } catch (err) {
-        errorCh.publish(err)
+      } catch (error) {
+        ctx.error = error
+        errorCh.publish(ctx)
       }
     })
   }
 }
-
+const finish = (ctx) => {
+  finishPoolQueryCh.publish(ctx)
+}
 function wrapPoolQuery (query) {
   return function () {
     if (!startPoolQueryCh.hasSubscribers) {
       return query.apply(this, arguments)
     }
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
     const pgQuery = arguments[0] !== null && typeof arguments[0] === 'object' ? arguments[0] : { text: arguments[0] }
+    const abortController = new AbortController()
 
-    return asyncResource.runInAsyncScope(() => {
-      const abortController = new AbortController()
-
-      startPoolQueryCh.publish({
-        query: pgQuery,
-        abortController
-      })
-
-      const finish = asyncResource.bind(function () {
-        finishPoolQueryCh.publish()
-      })
+    const ctx = { query: pgQuery, abortController }
 
+    return startPoolQueryCh.runStores(ctx, () => {
       const cb = arguments[arguments.length - 1]
 
       if (abortController.signal.aborted) {
         const error = abortController.signal.reason || new Error('Aborted')
-        finish()
+        finish(ctx)
 
         if (typeof cb === 'function') {
           cb(error)
@@ -184,7 +174,7 @@ function wrapPoolQuery (query) {
 
       if (typeof cb === 'function') {
         arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => function () {
-          finish()
+          finish(ctx)
           return cb.apply(this, arguments)
         })
       }
@@ -193,9 +183,9 @@ function wrapPoolQuery (query) {
 
       if (retval?.then) {
         retval.then(() => {
-          finish()
+          finish(ctx)
         }).catch(() => {
-          finish()
+          finish(ctx)
         })
       }
 

package/packages/datadog-plugin-aerospike/src/index.js

@@ -6,16 +6,12 @@ const DatabasePlugin = require('../../dd-trace/src/plugins/database')
 const AEROSPIKE_PEER_SERVICE = 'aerospike.namespace'
 
 class AerospikePlugin extends DatabasePlugin {
-  static get id () { return 'aerospike' }
-  static get operation () { return 'command' }
-  static get system () { return 'aerospike' }
-  static get prefix () {
-    return 'tracing:apm:aerospike:command'
-  }
+  static id = 'aerospike'
+  static operation = 'command'
+  static system = 'aerospike'
+  static prefix = 'tracing:apm:aerospike:command'
 
-  static get peerServicePrecursors () {
-    return [AEROSPIKE_PEER_SERVICE]
-  }
+  static peerServicePrecursors = [AEROSPIKE_PEER_SERVICE]
 
   bindStart (ctx) {
     const { commandName, commandArgs } = ctx
@@ -68,8 +64,12 @@ class AerospikePlugin extends DatabasePlugin {
 function getMeta (resourceName, commandArgs) {
   let meta = {}
   if (resourceName.includes('Index')) {
-    const [ns, set, bin, index] = commandArgs
-    meta = getMetaForIndex(ns, set, bin, index)
+    const [ns, set, bin, exp, index] = commandArgs
+
+    // The `ext` argument was added to IndexCreate in 6.3.0
+    meta = commandArgs.length > 8
+      ? getMetaForIndex(ns, set, bin, index)
+      : getMetaForIndex(ns, set, bin, exp)
   } else if (resourceName === 'Query') {
     const { ns, set } = commandArgs[2]
     meta = getMetaForQuery({ ns, set })

package/packages/datadog-plugin-ai/src/index.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const VercelAILLMObsPlugin = require('../../dd-trace/src/llmobs/plugins/ai')
+const VercelAITracingPlugin = require('./tracing')
+
+class VercelAIPlugin extends CompositePlugin {
+  static get id () { return 'ai' }
+  static get plugins () {
+    return {
+      llmobs: VercelAILLMObsPlugin,
+      tracing: VercelAITracingPlugin
+    }
+  }
+}
+
+module.exports = VercelAIPlugin

package/packages/datadog-plugin-ai/src/tracing.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+const { getModelProvider } = require('./utils')
+
+class VercelAITracingPlugin extends TracingPlugin {
+  static id = 'ai'
+  static prefix = 'tracing:dd-trace:vercel-ai'
+
+  bindStart (ctx) {
+    const attributes = ctx.attributes
+
+    const model = attributes['ai.model.id']
+    const modelProvider = getModelProvider(attributes)
+
+    this.startSpan(ctx.name, {
+      meta: {
+        'resource.name': ctx.name,
+        'ai.request.model': model,
+        'ai.request.model_provider': modelProvider
+      }
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  asyncEnd (ctx) {
+    const span = ctx.currentStore?.span
+    span?.finish()
+  }
+}
+
+module.exports = VercelAITracingPlugin