dd-trace 5.55.0 → 5.57.0

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

@@ -2,8 +2,7 @@
 
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -17,35 +16,29 @@ addHook({ name: 'memcached', versions: ['>=2.2'] }, Memcached => {
       return command.apply(this, arguments)
     }
 
-    const callbackResource = new AsyncResource('bound-anonymous-fn')
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
     const client = this
 
-    const wrappedQueryCompiler = asyncResource.bind(function () {
+    const wrappedQueryCompiler = function () {
       const query = queryCompiler.apply(this, arguments)
-      const callback = callbackResource.bind(query.callback)
-
-      query.callback = shimmer.wrapFunction(callback, callback => asyncResource.bind(function (err) {
-        if (err) {
-          errorCh.publish(err)
-        }
-        finishCh.publish()
-
-        return callback.apply(this, arguments)
-      }))
-      startCh.publish({ client, server, query })
 
+      const ctx = { client, server, query }
+      startCh.runStores(ctx, () => {
+        query.callback = shimmer.wrapFunction(query.callback, callback => function (err) {
+          if (err) {
+            ctx.error = err
+            errorCh.publish(ctx)
+          }
+          finishCh.publish(ctx)
+
+          return finishCh.runStores(ctx, callback, this, ...arguments)
+        })
+      })
       return query
-    })
-
-    return asyncResource.runInAsyncScope(() => {
-      arguments[0] = wrappedQueryCompiler
+    }
 
-      const result = command.apply(this, arguments)
+    arguments[0] = wrappedQueryCompiler
 
-      return result
-    })
+    return command.apply(this, arguments)
   })
 
   return Memcached

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

@@ -201,9 +201,10 @@ function getOnEndHandler (isParallel) {
   }
 }
 
-function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
+function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFinishRequest) {
   const ctx = {
-    isParallel
+    isParallel,
+    frameworkVersion
   }
 
   const onReceivedSkippableSuites = ({ err, skippableSuites, itrCorrelationId: responseItrCorrelationId }) => {
@@ -343,7 +344,7 @@ addHook({
   name: 'mocha',
   versions: ['>=5.2.0'],
   file: 'lib/mocha.js'
-}, (Mocha) => {
+}, (Mocha, frameworkVersion) => {
   shimmer.wrap(Mocha.prototype, 'run', run => function () {
     // Workers do not need to request any data, just run the tests
     if (!testFinishCh.hasSubscribers || getEnvironmentVariable('MOCHA_WORKER_ID') || this.options.parallel) {
@@ -363,7 +364,7 @@ addHook({
       }
     })
 
-    getExecutionConfiguration(runner, false, () => {
+    getExecutionConfiguration(runner, false, frameworkVersion, () => {
       if (config.isKnownTestsEnabled) {
         const testSuites = this.files.map(file => getTestSuitePath(file, process.cwd()))
         const isFaulty = getIsFaultyEarlyFlakeDetection(
@@ -521,7 +522,7 @@ addHook({
       if (ctx) {
         testSuiteFinishCh.publish({ status, ...ctx.currentStore }, () => {})
       } else {
-        log.warn(() => `No ctx found for suite ${suite.file}`)
+        log.warn('No ctx found for suite', suite.file)
       }
     })
 
@@ -616,7 +617,7 @@ addHook({
     this.once('start', getOnStartHandler(true, frameworkVersion))
     this.once('end', getOnEndHandler(true))
 
-    getExecutionConfiguration(this, true, () => {
+    getExecutionConfiguration(this, true, frameworkVersion, () => {
       if (config.isKnownTestsEnabled) {
         const testSuites = files.map(file => getTestSuitePath(file, process.cwd()))
         const isFaulty = getIsFaultyEarlyFlakeDetection(

package/packages/datadog-instrumentations/src/moleculer/client.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 startChannel = channel('apm:moleculer:call:start')
@@ -9,29 +9,28 @@ const errorChannel = channel('apm:moleculer:call:error')
 
 function wrapCall (call) {
   return function (actionName, params, opts) {
-    const callResource = new AsyncResource('bound-anonymous-fn')
-
     opts = arguments[2] = opts || {}
     opts.meta = opts.meta || {}
 
     arguments.length = Math.max(3, arguments.length)
 
-    return callResource.runInAsyncScope(() => {
-      startChannel.publish({ actionName, params, opts })
-
+    const ctx = { actionName, params, opts }
+    return startChannel.runStores(ctx, () => {
       const promise = call.apply(this, arguments)
       const broker = this
-      const ctx = promise.ctx
+      ctx.promiseCtx = promise.ctx
+      ctx.broker = broker
 
       return promise
         .then(
           result => {
-            finishChannel.publish({ broker, ctx })
+            finishChannel.publish(ctx)
             return result
           },
           error => {
-            errorChannel.publish(error)
-            finishChannel.publish({ broker, ctx })
+            ctx.error = error
+            errorChannel.publish(ctx)
+            finishChannel.publish(ctx)
             throw error
           }
         )

package/packages/datadog-instrumentations/src/moleculer/server.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 startChannel = channel('apm:moleculer:action:start')
@@ -24,27 +24,26 @@ function createMiddleware () {
     localAction (next, action) {
       const broker = this
 
-      return shimmer.wrapFunction(next, next => function datadogMiddleware (ctx) {
-        const actionResource = new AsyncResource('bound-anonymous-fn')
-
-        return actionResource.runInAsyncScope(() => {
-          startChannel.publish({ action, ctx, broker })
-
+      return shimmer.wrapFunction(next, next => function datadogMiddleware (middlewareCtx) {
+        const ctx = { action, middlewareCtx, broker }
+        return startChannel.runStores(ctx, () => {
           try {
-            return next(ctx).then(
+            return next(middlewareCtx).then(
               result => {
-                finishChannel.publish()
+                finishChannel.publish(ctx)
                 return result
               },
               error => {
-                errorChannel.publish(error)
-                finishChannel.publish()
+                ctx.error = error
+                errorChannel.publish(ctx)
+                finishChannel.publish(ctx)
                 throw error
               }
             )
           } catch (e) {
-            errorChannel.publish(e)
-            finishChannel.publish()
+            ctx.error = e
+            errorChannel.publish(ctx)
+            finishChannel.publish(ctx)
           }
         })
       })

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

@@ -31,7 +31,21 @@ const V4_PACKAGE_SHIMS = [
     file: 'resources/files',
     targetClass: 'Files',
     baseResource: 'files',
-    methods: ['create', 'del', 'list', 'retrieve']
+    methods: ['create', 'list', 'retrieve'],
+  },
+  {
+    file: 'resources/files',
+    targetClass: 'Files',
+    baseResource: 'files',
+    methods: ['del'],
+    versions: ['>=4.0.0 <5.0.0']
+  },
+  {
+    file: 'resources/files',
+    targetClass: 'Files',
+    baseResource: 'files',
+    methods: ['delete'],
+    versions: ['>=5']
   },
   {
     file: 'resources/files',
@@ -78,7 +92,21 @@ const V4_PACKAGE_SHIMS = [
     file: 'resources/models',
     targetClass: 'Models',
     baseResource: 'models',
-    methods: ['del', 'list', 'retrieve']
+    methods: ['list', 'retrieve']
+  },
+  {
+    file: 'resources/models',
+    targetClass: 'Models',
+    baseResource: 'models',
+    methods: ['del'],
+    versions: ['>=4 <5']
+  },
+  {
+    file: 'resources/models',
+    targetClass: 'Models',
+    baseResource: 'models',
+    methods: ['delete'],
+    versions: ['>=5']
   },
   {
     file: 'resources/moderations',

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

@@ -516,7 +516,10 @@ function runnerHook (runnerExport, playwrightVersion) {
     testSessionStartCh.publish({ command, frameworkVersion: playwrightVersion, rootDir })
 
     try {
-      const { err, libraryConfig } = await getChannelPromise(libraryConfigurationCh)
+      const { err, libraryConfig } = await getChannelPromise(
+        libraryConfigurationCh,
+        { frameworkVersion: playwrightVersion }
+      )
       if (!err) {
         isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
         isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled

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

@@ -0,0 +1,116 @@
+'use strict'
+
+const {
+  channel,
+  addHook
+} = require('./helpers/instrument')
+
+const prismaEngineStart = channel('apm:prisma:engine:start')
+const tracingChannel = require('dc-polyfill').tracingChannel
+const clientCH = tracingChannel('apm:prisma:client')
+
+const allowedClientSpanOperations = new Set([
+  'operation',
+  'serialize',
+  'transaction'
+])
+
+class TracingHelper {
+  dbConfig = null
+  isEnabled () {
+    return true
+  }
+
+  // needs a sampled tracecontext to generate engine spans
+  getTraceParent (context) {
+    return '00-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-bbbbbbbbbbbbbbbb-01' // valid sampled traceparent
+  }
+
+  dispatchEngineSpans (spans) {
+    for (const span of spans) {
+      if (span.parentId === null) {
+        prismaEngineStart.publish({ engineSpan: span, allEngineSpans: spans, dbConfig: this.dbConfig })
+      }
+    }
+  }
+
+  getActiveContext () {}
+
+  runInChildSpan (options, callback) {
+    if (typeof options === 'string') {
+      options = {
+        name: options
+      }
+    }
+
+    if (allowedClientSpanOperations.has(options.name)) {
+      const ctx = {
+        resourceName: options.name,
+        attributes: options.attributes || {}
+      }
+
+      if (options.name !== 'serialize') {
+        return clientCH.tracePromise(callback, ctx, this, ...arguments)
+      }
+
+      return clientCH.traceSync(callback, ctx, this, ...arguments)
+    }
+    return callback()
+  }
+
+  setDbString (dbConfig) {
+    this.dbConfig = dbConfig
+  }
+}
+
+addHook({ name: '@prisma/client', versions: ['>=6.1.0'] }, (prisma, version) => {
+  const tracingHelper = new TracingHelper()
+
+  /*
+    * This is a custom PrismaClient that extends the original PrismaClient
+    * This allows us to grab additional information from the PrismaClient such as DB connection strings
+  */
+  class PrismaClient extends prisma.PrismaClient {
+    constructor (...args) {
+      super(...args)
+
+      const datasources = this._engine?.config.inlineDatasources?.db.url?.value
+      if (datasources) {
+        const result = parseDBString(datasources)
+        tracingHelper.setDbString(result)
+      }
+    }
+  }
+
+  prisma.PrismaClient = PrismaClient
+  /*
+    * This is taking advantage of the built in tracing support from Prisma.
+    * The below variable is setting a global tracing helper that Prisma uses
+    * to enable OpenTelemetry.
+  */
+  // https://github.com/prisma/prisma/blob/478293bbfce91e41ceff02f2a0b03bb8acbca03e/packages/instrumentation/src/PrismaInstrumentation.ts#L42
+  const versions = version.split('.')
+  if (versions[0] === '6' && versions[1] < 4) {
+    global.PRISMA_INSTRUMENTATION = {
+      helper: tracingHelper
+    }
+  } else {
+    global[`V${versions[0]}_PRISMA_INSTRUMENTATION`] = {
+      helper: tracingHelper
+    }
+  }
+
+  return prisma
+})
+
+function parseDBString (dbString) {
+  const url = new URL(dbString)
+  const dbConfig = {
+    user: url.username,
+    password: url.password,
+    host: url.hostname,
+    port: url.port,
+    database: url.pathname.slice(1) // Remove leading slash
+  }
+  return dbConfig
+}

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

@@ -2,8 +2,7 @@
 
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -22,15 +21,11 @@ function wrapAddCommand (addCommand) {
     const name = command[0]
     const args = command.slice(1)
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-    return asyncResource.runInAsyncScope(() => {
-      start(this, name, args, this._url)
-
+    const ctx = getStartCtx(this, name, args, this._url)
+    return startCh.runStores(ctx, () => {
       const res = addCommand.apply(this, arguments)
-      const onResolve = asyncResource.bind(() => finish(finishCh, errorCh))
-      const onReject = asyncResource.bind(err => finish(finishCh, errorCh, err))
 
-      res.then(onResolve, onReject)
+      res.then(() => finish(finishCh, errorCh, ctx), err => finish(finishCh, errorCh, ctx, err))
 
       return res
     })
@@ -39,8 +34,8 @@ function wrapAddCommand (addCommand) {
 
 function wrapCommandQueueClass (cls) {
   const ret = class RedisCommandQueue extends cls {
-    constructor () {
-      super(arguments)
+    constructor (...args) {
+      super(...args)
       if (createClientUrl) {
         try {
           const parsed = new URL(createClientUrl)
@@ -94,14 +89,9 @@ addHook({ name: 'redis', versions: ['>=2.6 <4'] }, redis => {
 
     if (!options.callback) return internalSendCommand.apply(this, arguments)
 
-    const callbackResource = new AsyncResource('bound-anonymous-fn')
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-    const cb = callbackResource.bind(options.callback)
-
-    return asyncResource.runInAsyncScope(() => {
-      start(this, options.command, options.args)
-
-      options.callback = asyncResource.bind(wrapCallback(finishCh, errorCh, cb))
+    const ctx = getStartCtx(this, options.command, options.args)
+    return startCh.runStores(ctx, () => {
+      options.callback = wrapCallback(finishCh, errorCh, ctx, options.callback)
 
       try {
         return internalSendCommand.apply(this, arguments)
@@ -121,26 +111,21 @@ addHook({ name: 'redis', versions: ['>=0.12 <2.6'] }, redis => {
       return sendCommand.apply(this, arguments)
     }
 
-    const callbackResource = new AsyncResource('bound-anonymous-fn')
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
-    return asyncResource.runInAsyncScope(() => {
-      start(this, command, args)
-
+    const ctx = getStartCtx(this, command, args)
+    return startCh.runStores(ctx, () => {
       if (typeof callback === 'function') {
-        const cb = callbackResource.bind(callback)
-        arguments[2] = asyncResource.bind(wrapCallback(finishCh, errorCh, cb))
+        arguments[2] = wrapCallback(finishCh, errorCh, ctx, callback)
       } else if (Array.isArray(args) && typeof args.at(-1) === 'function') {
-        const cb = callbackResource.bind(args.at(-1))
-        args[args.length - 1] = asyncResource.bind(wrapCallback(finishCh, errorCh, cb))
+        args[args.length - 1] = wrapCallback(finishCh, errorCh, ctx, args.at(-1))
       } else {
-        arguments[2] = asyncResource.bind(wrapCallback(finishCh, errorCh))
+        arguments[2] = wrapCallback(finishCh, errorCh, ctx)
       }
 
       try {
         return sendCommand.apply(this, arguments)
       } catch (err) {
-        errorCh.publish(err)
+        ctx.error = err
+        errorCh.publish(ctx)
 
         throw err
       }
@@ -149,24 +134,28 @@ addHook({ name: 'redis', versions: ['>=0.12 <2.6'] }, redis => {
   return redis
 })
 
-function start (client, command, args, url = {}) {
-  const db = client.selected_db
-  const connectionOptions = client.connection_options || client.connection_option || client.connectionOption || url
-  startCh.publish({ db, command, args, connectionOptions })
+function getStartCtx (client, command, args, url = {}) {
+  return {
+    db: client.selected_db,
+    command,
+    args,
+    connectionOptions: client.connection_options || client.connection_option || client.connectionOption || url
+  }
 }
 
-function wrapCallback (finishCh, errorCh, callback) {
+function wrapCallback (finishCh, errorCh, ctx, callback) {
   return shimmer.wrapFunction(callback, callback => function (err) {
-    finish(finishCh, errorCh, err)
-    if (callback) {
-      return callback.apply(this, arguments)
-    }
+    return finish(finishCh, errorCh, ctx, err, callback, this, arguments)
   })
 }
 
-function finish (finishCh, errorCh, error) {
+function finish (finishCh, errorCh, ctx, error, callback, thisArg, args) {
   if (error) {
-    errorCh.publish(error)
+    ctx.error = error
+    errorCh.publish(ctx)
+  }
+  if (callback) {
+    return finishCh.runStores(ctx, callback, thisArg, ...args)
   }
-  finishCh.publish()
+  finishCh.publish(ctx)
 }

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

@@ -106,7 +106,7 @@ function createWrapRouterMethod (name) {
   }
 
   function extractMatchers (fn) {
-    const arg = Array.isArray(fn) ? fn : [fn]
+    const arg = Array.isArray(fn) ? fn.flat(Infinity) : [fn]
 
     if (typeof arg[0] === 'function') {
       return []

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

@@ -2,8 +2,7 @@
 
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -37,30 +36,25 @@ addHook({ name: 'sharedb', versions: ['>=1'], file: 'lib/agent.js' }, Agent => {
   const errorCh = channel('apm:sharedb:request:error')
 
   shimmer.wrap(Agent.prototype, '_handleMessage', origHandleMessageFn => function (request, callback) {
-    const callbackResource = new AsyncResource('bound-anonymous-fn')
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
     const action = request.a
     const actionName = getReadableActionName(action)
 
-    return asyncResource.runInAsyncScope(() => {
-      startCh.publish({ actionName, request })
-
-      callback = callbackResource.bind(callback)
-
-      arguments[1] = shimmer.wrapFunction(callback, callback => asyncResource.bind(function (error, res) {
+    const ctx = { actionName, request }
+    return startCh.runStores(ctx, () => {
+      arguments[1] = shimmer.wrapFunction(callback, callback => function (error, res) {
         if (error) {
+          ctx.error = error
           errorCh.publish(error)
         }
-        finishCh.publish({ request, res })
-
-        return callback.apply(this, arguments)
-      }))
+        ctx.res = res
+        return finishCh.runStores(ctx, callback, this, ...arguments)
+      })
 
       try {
         return origHandleMessageFn.apply(this, arguments)
       } catch (error) {
-        errorCh.publish(error)
+        ctx.error = error
+        errorCh.publish(ctx)
 
         throw error
       }

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

@@ -113,9 +113,9 @@ function isBaseSequencer (vitestPackage) {
   return vitestPackage.b?.name === 'BaseSequencer'
 }
 
-function getChannelPromise (channelToPublishTo) {
+function getChannelPromise (channelToPublishTo, frameworkVersion) {
   return new Promise(resolve => {
-    channelToPublishTo.publish({ onDone: resolve })
+    channelToPublishTo.publish({ onDone: resolve, frameworkVersion })
   })
 }
 
@@ -173,7 +173,7 @@ function getTestName (task) {
   return testName
 }
 
-function getSortWrapper (sort) {
+function getSortWrapper (sort, frameworkVersion) {
   return async function () {
     if (!testSessionFinishCh.hasSubscribers) {
       return sort.apply(this, arguments)
@@ -193,7 +193,7 @@ function getSortWrapper (sort) {
     let isDiEnabled = false
 
     try {
-      const { err, libraryConfig } = await getChannelPromise(libraryConfigurationCh)
+      const { err, libraryConfig } = await getChannelPromise(libraryConfigurationCh, frameworkVersion)
       if (!err) {
         isFlakyTestRetriesEnabled = libraryConfig.isFlakyTestRetriesEnabled
         flakyTestRetriesCount = libraryConfig.flakyTestRetriesCount

package/packages/datadog-plugin-aws-sdk/src/base.js

@@ -56,7 +56,12 @@ class BaseAwsSdkPlugin extends ClientPlugin {
       }
       if (this.requestTags) this.requestTags.set(request, tags)
 
-      const span = this.tracer.startSpan(this.operationFromRequest(request), { childOf, tags })
+      const span = this.tracer.startSpan(this.operationFromRequest(request),
+        {
+          childOf,
+          tags,
+          integrationName: 'aws-sdk'
+        })
 
       analyticsSampler.sample(span, this.config.measured)
 

package/packages/datadog-plugin-aws-sdk/src/services/dynamodb.js

@@ -119,8 +119,10 @@ class DynamoDb extends BaseAwsSdkPlugin {
 
     const configStr = this._tracerConfig?.trace?.dynamoDb?.tablePrimaryKeys
     if (!configStr) {
-      log.warn('Missing DD_TRACE_DYNAMODB_TABLE_PRIMARY_KEYS env variable. ' +
-        'Please add your table\'s primary keys under this env variable.')
+      log.warn(
+        // eslint-disable-next-line @stylistic/max-len
+        'Missing DD_TRACE_DYNAMODB_TABLE_PRIMARY_KEYS env variable. Please add your table\'s primary keys under this env variable.'
+      )
       return
     }
 
@@ -131,8 +133,11 @@ class DynamoDb extends BaseAwsSdkPlugin {
         if (Array.isArray(primaryKeys) && primaryKeys.length > 0 && primaryKeys.length <= 2) {
           config[tableName] = primaryKeys
         } else {
-          log.warn(`Invalid primary key configuration for table: ${tableName}.` +
-            'Please fix the DD_TRACE_DYNAMODB_TABLE_PRIMARY_KEYS env var.')
+          log.warn(
+            // eslint-disable-next-line @stylistic/max-len
+            'Invalid primary key configuration for table: %s. Please fix the DD_TRACE_DYNAMODB_TABLE_PRIMARY_KEYS env var.',
+            tableName
+          )
         }
       }
 

package/packages/datadog-plugin-aws-sdk/src/services/kinesis.js

@@ -38,7 +38,8 @@ class Kinesis extends BaseAwsSdkPlugin {
             tags: {
               ...this.requestTags.get(request),
               'span.kind': 'server'
-            }
+            },
+            integrationName: 'aws-sdk'
           }
           span = plugin.tracer.startSpan('aws.response', options)
           this.enter(span, store)
@@ -201,7 +202,7 @@ class Kinesis extends BaseAwsSdkPlugin {
 
   setDSMCheckpoint (span, parsedData, stream) {
     // get payload size of request data
-    const payloadSize = Buffer.from(JSON.stringify(parsedData)).byteLength
+    const payloadSize = Buffer.byteLength(JSON.stringify(parsedData))
     const dataStreamsContext = this.tracer
       .setCheckpoint(['direction:out', `topic:${stream}`, 'type:kinesis'], span, payloadSize)
     return dataStreamsContext

package/packages/datadog-plugin-aws-sdk/src/services/sqs.js

@@ -30,7 +30,8 @@ class Sqs extends BaseAwsSdkPlugin {
           tags: {
             ...this.requestTags.get(request),
             'span.kind': 'server'
-          }
+          },
+          integrationName: 'aws-sdk'
         }
         parsedMessageAttributes = contextExtraction.parsedAttributes
         span = this.tracer.startSpan('aws.response', options)