dd-trace 5.21.0 → 5.23.0

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

@@ -58,7 +58,7 @@ addHook({ name: names }, (net, version, name) => {
       }
 
       const emit = this.emit
-      this.emit = function (eventName) {
+      this.emit = shimmer.wrapFunction(emit, emit => function (eventName) {
         switch (eventName) {
           case 'ready':
           case 'connect':
@@ -68,7 +68,7 @@ addHook({ name: names }, (net, version, name) => {
           default:
             return emit.apply(this, arguments)
         }
-      }
+      })
 
       try {
         return connect.apply(this, arguments)

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

@@ -188,7 +188,7 @@ function finish (ctx, result, err) {
 // however, it is not provided as a class function or exported property
 addHook({
   name: 'next',
-  versions: ['>=13.3.0'],
+  versions: ['>=13.3.0 <14.2.7'],
   file: 'dist/server/web/spec-extension/adapters/next-request.js'
 }, NextRequestAdapter => {
   shimmer.wrap(NextRequestAdapter.NextRequestAdapter, 'fromNodeNextRequest', fromNodeNextRequest => {
@@ -203,7 +203,7 @@ addHook({
 
 addHook({
   name: 'next',
-  versions: ['>=11.1'],
+  versions: ['>=11.1 <14.2.7'],
   file: 'dist/server/serve-static.js'
 }, serveStatic => shimmer.wrap(serveStatic, 'serveStatic', wrapServeStatic))
 
@@ -213,7 +213,7 @@ addHook({
   file: 'dist/next-server/server/serve-static.js'
 }, serveStatic => shimmer.wrap(serveStatic, 'serveStatic', wrapServeStatic))
 
-addHook({ name: 'next', versions: ['>=11.1'], file: 'dist/server/next-server.js' }, nextServer => {
+addHook({ name: 'next', versions: ['>=11.1 <14.2.7'], file: 'dist/server/next-server.js' }, nextServer => {
   const Server = nextServer.default
 
   shimmer.wrap(Server.prototype, 'handleRequest', wrapHandleRequest)
@@ -230,7 +230,7 @@ addHook({ name: 'next', versions: ['>=11.1'], file: 'dist/server/next-server.js'
 })
 
 // `handleApiRequest` changes parameters/implementation at 13.2.0
-addHook({ name: 'next', versions: ['>=13.2'], file: 'dist/server/next-server.js' }, nextServer => {
+addHook({ name: 'next', versions: ['>=13.2 <14.2.7'], file: 'dist/server/next-server.js' }, nextServer => {
   const Server = nextServer.default
   shimmer.wrap(Server.prototype, 'handleApiRequest', wrapHandleApiRequestWithMatch)
   return nextServer
@@ -264,7 +264,7 @@ addHook({
 
 addHook({
   name: 'next',
-  versions: ['>=13'],
+  versions: ['>=13 <14.2.7'],
   file: 'dist/server/web/spec-extension/request.js'
 }, request => {
   const nextUrlDescriptor = Object.getOwnPropertyDescriptor(request.NextRequest.prototype, 'nextUrl')

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

@@ -1,14 +1,10 @@
 'use strict'
 
-const {
-  channel,
-  addHook
-} = require('./helpers/instrument')
+const { addHook } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
-const startCh = channel('apm:openai:request:start')
-const finishCh = channel('apm:openai:request:finish')
-const errorCh = channel('apm:openai:request:error')
+const tracingChannel = require('dc-polyfill').tracingChannel
+const ch = tracingChannel('apm:openai:request')
 
 const V4_PACKAGE_SHIMS = [
   {
@@ -110,33 +106,18 @@ addHook({ name: 'openai', file: 'dist/api.js', versions: ['>=3.0.0 <4'] }, expor
 
   for (const methodName of methodNames) {
     shimmer.wrap(exports.OpenAIApi.prototype, methodName, fn => function () {
-      if (!startCh.hasSubscribers) {
+      if (!ch.start.hasSubscribers) {
         return fn.apply(this, arguments)
       }
 
-      startCh.publish({
+      const ctx = {
         methodName,
         args: arguments,
         basePath: this.basePath,
         apiKey: this.configuration.apiKey
-      })
-
-      return fn.apply(this, arguments)
-        .then((response) => {
-          finish({
-            headers: response.headers,
-            body: response.data,
-            path: response.request.path,
-            method: response.request.method
-          })
-
-          return response
-        })
-        .catch(error => {
-          finish(undefined, error)
+      }
 
-          throw error
-        })
+      return ch.tracePromise(fn, ctx, this, ...arguments)
     })
   }
 
@@ -184,10 +165,12 @@ function addStreamedChunk (content, chunk) {
 
       if (tools) {
         oldChoice.delta.tool_calls = tools.map((newTool, toolIdx) => {
-          const oldTool = oldChoice.delta.tool_calls[toolIdx]
+          const oldTool = oldChoice.delta.tool_calls?.[toolIdx]
 
           if (oldTool) {
             oldTool.function.arguments += newTool.function.arguments
+          } else {
+            return newTool
           }
 
           return oldTool
@@ -213,7 +196,7 @@ function convertBufferstoObjects (chunks = []) {
  * the chunks, and let the combined content be the final response.
  * This way, spans look the same as when not streamed.
  */
-function wrapStreamIterator (response, options, n) {
+function wrapStreamIterator (response, options, n, ctx) {
   let processChunksAsBuffers = false
   let chunks = []
   return function (itr) {
@@ -253,18 +236,20 @@ function wrapStreamIterator (response, options, n) {
                 }
               }
 
-              finish({
+              finish(ctx, {
                 headers: response.headers,
-                body,
-                path: response.url,
-                method: options.method
+                data: body,
+                request: {
+                  path: response.url,
+                  method: options.method
+                }
               })
             }
 
             return res
           })
           .catch(err => {
-            finish(undefined, err)
+            finish(ctx, undefined, err)
 
             throw err
           })
@@ -281,7 +266,7 @@ for (const shim of V4_PACKAGE_SHIMS) {
 
     for (const methodName of methods) {
       shimmer.wrap(targetPrototype, methodName, methodFn => function () {
-        if (!startCh.hasSubscribers) {
+        if (!ch.start.hasSubscribers) {
           return methodFn.apply(this, arguments)
         }
 
@@ -303,66 +288,72 @@ for (const shim of V4_PACKAGE_SHIMS) {
 
         const client = this._client || this.client
 
-        startCh.publish({
+        const ctx = {
           methodName: `${baseResource}.${methodName}`,
           args: arguments,
           basePath: client.baseURL,
           apiKey: client.apiKey
-        })
+        }
 
-        const apiProm = methodFn.apply(this, arguments)
+        return ch.start.runStores(ctx, () => {
+          const apiProm = methodFn.apply(this, arguments)
 
-        // wrapping `parse` avoids problematic wrapping of `then` when trying to call
-        // `withResponse` in userland code after. This way, we can return the whole `APIPromise`
-        shimmer.wrap(apiProm, 'parse', origApiPromParse => function () {
-          return origApiPromParse.apply(this, arguments)
+          // wrapping `parse` avoids problematic wrapping of `then` when trying to call
+          // `withResponse` in userland code after. This way, we can return the whole `APIPromise`
+          shimmer.wrap(apiProm, 'parse', origApiPromParse => function () {
+            return origApiPromParse.apply(this, arguments)
             // the original response is wrapped in a promise, so we need to unwrap it
-            .then(body => Promise.all([this.responsePromise, body]))
-            .then(([{ response, options }, body]) => {
-              if (stream) {
-                if (body.iterator) {
-                  shimmer.wrap(body, 'iterator', wrapStreamIterator(response, options, n))
+              .then(body => Promise.all([this.responsePromise, body]))
+              .then(([{ response, options }, body]) => {
+                if (stream) {
+                  if (body.iterator) {
+                    shimmer.wrap(body, 'iterator', wrapStreamIterator(response, options, n, ctx))
+                  } else {
+                    shimmer.wrap(
+                      body.response.body, Symbol.asyncIterator, wrapStreamIterator(response, options, n, ctx)
+                    )
+                  }
                 } else {
-                  shimmer.wrap(
-                    body.response.body, Symbol.asyncIterator, wrapStreamIterator(response, options, n)
-                  )
+                  finish(ctx, {
+                    headers: response.headers,
+                    data: body,
+                    request: {
+                      path: response.url,
+                      method: options.method
+                    }
+                  })
                 }
-              } else {
-                finish({
-                  headers: response.headers,
-                  body,
-                  path: response.url,
-                  method: options.method
-                })
-              }
 
-              return body
-            })
-            .catch(error => {
-              finish(undefined, error)
+                return body
+              })
+              .catch(error => {
+                finish(ctx, undefined, error)
 
-              throw error
-            })
-            .finally(() => {
+                throw error
+              })
+              .finally(() => {
               // maybe we don't want to unwrap here in case the promise is re-used?
               // other hand: we want to avoid resource leakage
-              shimmer.unwrap(apiProm, 'parse')
-            })
-        })
+                shimmer.unwrap(apiProm, 'parse')
+              })
+          })
 
-        return apiProm
+          return apiProm
+        })
       })
     }
     return exports
   })
 }
 
-function finish (response, error) {
+function finish (ctx, response, error) {
   if (error) {
-    errorCh.publish({ error })
+    ctx.error = error
+    ch.error.publish(ctx)
   }
 
-  finishCh.publish(response)
+  ctx.result = response
+  ch.asyncEnd.publish(ctx)
 }
 
 function getOption (args, option, defaultValue) {

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

@@ -31,10 +31,10 @@ 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] = function wrappedCb (err, result) {
+        arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => function wrappedCb (err, result) {
           finish(err)
           return outerAr.runInAsyncScope(() => cb.apply(this, arguments))
-        }
+        })
       }
 
       return new AsyncResource('apm:oracledb:inner-scope').runInAsyncScope(() => {
@@ -67,12 +67,12 @@ addHook({ name: 'oracledb', versions: ['>=5'] }, oracledb => {
   shimmer.wrap(oracledb, 'getConnection', getConnection => {
     return function wrappedGetConnection (connAttrs, callback) {
       if (callback) {
-        arguments[1] = (err, connection) => {
+        arguments[1] = shimmer.wrapFunction(callback, callback => (err, connection) => {
           if (connection) {
             connectionAttributes.set(connection, connAttrs)
           }
           callback(err, connection)
-        }
+        })
 
         getConnection.apply(this, arguments)
       } else {
@@ -86,12 +86,12 @@ addHook({ name: 'oracledb', versions: ['>=5'] }, oracledb => {
   shimmer.wrap(oracledb, 'createPool', createPool => {
     return function wrappedCreatePool (poolAttrs, callback) {
       if (callback) {
-        arguments[1] = (err, pool) => {
+        arguments[1] = shimmer.wrapFunction(callback, callback => (err, pool) => {
           if (pool) {
             poolAttributes.set(pool, poolAttrs)
           }
           callback(err, pool)
-        }
+        })
 
         createPool.apply(this, arguments)
       } else {
@@ -109,12 +109,12 @@ addHook({ name: 'oracledb', versions: ['>=5'] }, oracledb => {
         callback = arguments[arguments.length - 1]
       }
       if (callback) {
-        arguments[arguments.length - 1] = (err, connection) => {
+        arguments[arguments.length - 1] = shimmer.wrapFunction(callback, callback => (err, connection) => {
           if (connection) {
             connectionAttributes.set(connection, poolAttributes.get(this))
           }
           callback(err, connection)
-        }
+        })
         getConnection.apply(this, arguments)
       } else {
         return getConnection.apply(this, arguments).then((connection) => {

package/packages/datadog-instrumentations/src/passport-http.js

@@ -9,7 +9,7 @@ addHook({
   file: 'lib/passport-http/strategies/basic.js',
   versions: ['>=0.3.0']
 }, BasicStrategy => {
-  return shimmer.wrap(BasicStrategy, function () {
+  return shimmer.wrapFunction(BasicStrategy, BasicStrategy => function () {
     const type = 'http'
 
     if (typeof arguments[0] === 'function') {

package/packages/datadog-instrumentations/src/passport-local.js

@@ -9,7 +9,7 @@ addHook({
   file: 'lib/strategy.js',
   versions: ['>=1.0.0']
 }, Strategy => {
-  return shimmer.wrap(Strategy, function () {
+  return shimmer.wrapFunction(Strategy, Strategy => function () {
     const type = 'local'
 
     if (typeof arguments[0] === 'function') {

package/packages/datadog-instrumentations/src/passport-utils.js

@@ -11,7 +11,7 @@ function wrapVerifiedAndPublish (username, password, verified, type) {
   }
 
   // eslint-disable-next-line n/handle-callback-err
-  return shimmer.wrap(verified, function (err, user, info) {
+  return shimmer.wrapFunction(verified, verified => function (err, user, info) {
     const credentials = { type, username }
     passportVerifyChannel.publish({ credentials, user })
     return verified.apply(this, arguments)

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

@@ -53,14 +53,15 @@ function wrapQuery (query) {
     }
 
     return asyncResource.runInAsyncScope(() => {
+      const abortController = new AbortController()
+
       startCh.publish({
         params: this.connectionParameters,
         query: pgQuery,
-        processId
+        processId,
+        abortController
       })
 
-      arguments[0] = pgQuery
-
       const finish = asyncResource.bind(function (error) {
         if (error) {
           errorCh.publish(error)
@@ -68,6 +69,43 @@ function wrapQuery (query) {
         finishCh.publish()
       })
 
+      if (abortController.signal.aborted) {
+        const error = abortController.signal.reason || new Error('Aborted')
+
+        // eslint-disable-next-line 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]
+
+        finish(error)
+
+        if (reusingQuery) {
+          if (!pgQuery.callback && typeof callback === 'function') {
+            pgQuery.callback = callback
+          }
+
+          if (pgQuery.callback) {
+            pgQuery.callback(error)
+          } else {
+            process.nextTick(() => {
+              pgQuery.emit('error', error)
+            })
+          }
+
+          return pgQuery
+        }
+
+        if (typeof callback === 'function') {
+          callback(error)
+
+          return
+        }
+
+        return Promise.reject(error)
+      }
+
+      arguments[0] = pgQuery
+
       const retval = query.apply(this, arguments)
       const queryQueue = this.queryQueue || this._queryQueue
       const activeQuery = this.activeQuery || this._activeQuery
@@ -112,8 +150,11 @@ function wrapPoolQuery (query) {
     const pgQuery = arguments[0] !== null && typeof arguments[0] === 'object' ? arguments[0] : { text: arguments[0] }
 
     return asyncResource.runInAsyncScope(() => {
+      const abortController = new AbortController()
+
       startPoolQueryCh.publish({
-        query: pgQuery
+        query: pgQuery,
+        abortController
       })
 
       const finish = asyncResource.bind(function () {
@@ -121,8 +162,22 @@ function wrapPoolQuery (query) {
       })
 
       const cb = arguments[arguments.length - 1]
+
+      if (abortController.signal.aborted) {
+        const error = abortController.signal.reason || new Error('Aborted')
+        finish()
+
+        if (typeof cb === 'function') {
+          cb(error)
+
+          return
+        } else {
+          return Promise.reject(error)
+        }
+      }
+
       if (typeof cb === 'function') {
-        arguments[arguments.length - 1] = shimmer.wrap(cb, function () {
+        arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => function () {
           finish()
           return cb.apply(this, arguments)
         })

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

@@ -76,19 +76,19 @@ function wrapPrettyFactory (prettyFactory) {
 addHook({ name: 'pino', versions: ['2 - 3', '4', '>=5 <5.14.0'] }, pino => {
   const asJsonSym = (pino.symbols && pino.symbols.asJsonSym) || 'asJson'
 
-  return shimmer.wrap(pino, wrapPino(asJsonSym, wrapAsJson, pino))
+  return shimmer.wrapFunction(pino, pino => wrapPino(asJsonSym, wrapAsJson, pino))
 })
 
 addHook({ name: 'pino', versions: ['>=5.14.0 <6.8.0'] }, pino => {
   const mixinSym = pino.symbols.mixinSym
 
-  return shimmer.wrap(pino, wrapPino(mixinSym, wrapMixin, pino))
+  return shimmer.wrapFunction(pino, pino => wrapPino(mixinSym, wrapMixin, pino))
 })
 
 addHook({ name: 'pino', versions: ['>=6.8.0'] }, pino => {
   const mixinSym = pino.symbols.mixinSym
 
-  const wrapped = shimmer.wrap(pino, wrapPino(mixinSym, wrapMixin, pino))
+  const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(mixinSym, wrapMixin, pino))
   wrapped.pino = wrapped
   wrapped.default = wrapped
 
@@ -101,5 +101,5 @@ addHook({ name: 'pino-pretty', file: 'lib/utils.js', versions: ['>=3'] }, utils
 })
 
 addHook({ name: 'pino-pretty', versions: ['1 - 2'] }, prettyFactory => {
-  return shimmer.wrap(prettyFactory, wrapPrettyFactory(prettyFactory))
+  return shimmer.wrapFunction(prettyFactory, wrapPrettyFactory)
 })

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

@@ -2,7 +2,7 @@ const semver = require('semver')
 
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
-const { parseAnnotations, getTestSuitePath, NUM_FAILED_TEST_RETRIES } = require('../../dd-trace/src/plugins/util/test')
+const { parseAnnotations, getTestSuitePath } = require('../../dd-trace/src/plugins/util/test')
 const log = require('../../dd-trace/src/log')
 
 const testStartCh = channel('ci:playwright:test:start')
@@ -36,8 +36,9 @@ const STATUS_TO_TEST_STATUS = {
 
 let remainingTestsByFile = {}
 let isEarlyFlakeDetectionEnabled = false
-let isFlakyTestRetriesEnabled = false
 let earlyFlakeDetectionNumRetries = 0
+let isFlakyTestRetriesEnabled = false
+let flakyTestRetriesCount = 0
 let knownTests = {}
 let rootDir = ''
 const MINIMUM_SUPPORTED_VERSION_EFD = '1.38.0'
@@ -407,6 +408,7 @@ function runnerHook (runnerExport, playwrightVersion) {
         isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
         earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
         isFlakyTestRetriesEnabled = libraryConfig.isFlakyTestRetriesEnabled
+        flakyTestRetriesCount = libraryConfig.flakyTestRetriesCount
       }
     } catch (e) {
       isEarlyFlakeDetectionEnabled = false
@@ -429,10 +431,10 @@ function runnerHook (runnerExport, playwrightVersion) {
 
     const projects = getProjectsFromRunner(this)
 
-    if (isFlakyTestRetriesEnabled) {
+    if (isFlakyTestRetriesEnabled && flakyTestRetriesCount > 0) {
       projects.forEach(project => {
         if (project.retries === 0) { // Only if it hasn't been set by the user
-          project.retries = NUM_FAILED_TEST_RETRIES
+          project.retries = flakyTestRetriesCount
         }
       })
     }

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

@@ -156,12 +156,12 @@ function start (client, command, args, url = {}) {
 }
 
 function wrapCallback (finishCh, errorCh, callback) {
-  return function (err) {
+  return shimmer.wrapFunction(callback, callback => function (err) {
     finish(finishCh, errorCh, err)
     if (callback) {
       return callback.apply(this, arguments)
     }
-  }
+  })
 }
 
 function finish (finishCh, errorCh, error) {

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

@@ -40,7 +40,7 @@ function wrapMiddleware (middleware) {
 function wrapFn (fn) {
   if (Array.isArray(fn)) return wrapMiddleware(fn)
 
-  return function (req, res, next) {
+  return shimmer.wrapFunction(fn, fn => function (req, res, next) {
     if (typeof next === 'function') {
       arguments[2] = wrapNext(req, next)
     }
@@ -72,16 +72,16 @@ function wrapFn (fn) {
     } finally {
       exitChannel.publish({ req })
     }
-  }
+  })
 }
 
 function wrapNext (req, next) {
-  return function () {
+  return shimmer.wrapFunction(next, next => function () {
     nextChannel.publish({ req })
     finishChannel.publish({ req })
 
     next.apply(this, arguments)
-  }
+  })
 }
 
 addHook({ name: 'restify', versions: ['>=3'], file: 'lib/server.js' }, Server => {

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

@@ -153,11 +153,11 @@ function wrapDeliveryUpdate (obj, update) {
   const asyncResource = context.asyncResource
   if (obj && asyncResource) {
     const cb = asyncResource.bind(update)
-    return AsyncResource.bind(function wrappedUpdate (settled, stateData) {
+    return shimmer.wrapFunction(cb, cb => AsyncResource.bind(function wrappedUpdate (settled, stateData) {
       const state = getStateFromData(stateData)
       dispatchReceiveCh.publish({ state })
       return cb.apply(this, arguments)
-    })
+    }))
   }
   return function wrappedUpdate (settled, stateData) {
     return update.apply(this, arguments)
@@ -178,7 +178,7 @@ function patchCircularBuffer (proto, Session) {
         }
         if (CircularBuffer && !patched.has(CircularBuffer.prototype)) {
           shimmer.wrap(CircularBuffer.prototype, 'pop_if', popIf => function (fn) {
-            arguments[0] = AsyncResource.bind(function (entry) {
+            arguments[0] = shimmer.wrapFunction(fn, fn => AsyncResource.bind(function (entry) {
               const context = contexts.get(entry)
               const asyncResource = context && context.asyncResource
 
@@ -198,7 +198,7 @@ function patchCircularBuffer (proto, Session) {
               }
 
               return shouldPop
-            })
+            }))
             return popIf.apply(this, arguments)
           })
           patched.add(CircularBuffer.prototype)

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

@@ -18,7 +18,7 @@ function createWrapRouterMethod (name) {
   function wrapLayerHandle (layer, original) {
     original._name = original._name || layer.name
 
-    const handle = shimmer.wrap(original, function () {
+    const handle = shimmer.wrapFunction(original, original => function () {
       if (!enterChannel.hasSubscribers) return original.apply(this, arguments)
 
       const matchers = layerMatchers.get(layer)
@@ -89,7 +89,7 @@ function createWrapRouterMethod (name) {
   }
 
   function wrapNext (req, next) {
-    return function (error) {
+    return shimmer.wrapFunction(next, next => function (error) {
       if (error && error !== 'route' && error !== 'router') {
         errorChannel.publish({ req, error })
       }
@@ -98,7 +98,7 @@ function createWrapRouterMethod (name) {
       finishChannel.publish({ req })
 
       next.apply(this, arguments)
-    }
+    })
   }
 
   function extractMatchers (fn) {
@@ -151,7 +151,7 @@ function createWrapRouterMethod (name) {
   }
 
   function wrapMethod (original) {
-    return function methodWithTrace (fn) {
+    return shimmer.wrapFunction(original, original => function methodWithTrace (fn) {
       const offset = this.stack ? [].concat(this.stack).length : 0
       const router = original.apply(this, arguments)
 
@@ -162,7 +162,7 @@ function createWrapRouterMethod (name) {
       wrapStack(this.stack, offset, extractMatchers(fn))
 
       return router
-    }
+    })
   }
 
   return wrapMethod