dd-trace 4.44.0 → 4.46.0

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

@@ -92,7 +92,7 @@ function wrapUnifiedCommand (command, operation, name) {
     }
     return instrument(operation, command, this, arguments, server, ns, ops, { name })
   }
-  return shimmer.wrap(command, wrapped)
+  return wrapped
 }
 
 function wrapConnectionCommand (command, operation, name, instrumentFn = instrument) {
@@ -109,7 +109,7 @@ function wrapConnectionCommand (command, operation, name, instrumentFn = instrum
     ns = `${ns.db}.${ns.collection}`
     return instrumentFn(operation, command, this, arguments, topology, ns, ops, { name })
   }
-  return shimmer.wrap(command, wrapped)
+  return wrapped
 }
 
 function wrapQuery (query, operation, name) {
@@ -123,7 +123,7 @@ function wrapQuery (query, operation, name) {
     return instrument(operation, query, this, arguments, pool, ns, ops)
   }
 
-  return shimmer.wrap(query, wrapped)
+  return wrapped
 }
 
 function wrapCursor (cursor, operation, name) {
@@ -135,7 +135,7 @@ function wrapCursor (cursor, operation, name) {
     const ns = this.ns
     return instrument(operation, cursor, this, arguments, pool, ns, {}, { name })
   }
-  return shimmer.wrap(cursor, wrapped)
+  return wrapped
 }
 
 function wrapCommand (command, operation, name) {
@@ -145,7 +145,7 @@ function wrapCommand (command, operation, name) {
     }
     return instrument(operation, command, this, arguments, this, ns, ops, { name })
   }
-  return shimmer.wrap(command, wrapped)
+  return wrapped
 }
 
 function instrument (operation, command, ctx, args, server, ns, ops, options = {}) {
@@ -164,7 +164,7 @@ function instrument (operation, command, ctx, args, server, ns, ops, options = {
   return asyncResource.runInAsyncScope(() => {
     startCh.publish({ ns, ops, options: serverInfo, name })
 
-    args[index] = asyncResource.bind(function (err, res) {
+    args[index] = shimmer.wrapFunction(callback, callback => asyncResource.bind(function (err, res) {
       if (err) {
         errorCh.publish(err)
       }
@@ -174,7 +174,7 @@ function instrument (operation, command, ctx, args, server, ns, ops, options = {
       if (callback) {
         return callback.apply(this, arguments)
       }
-    })
+    }))
 
     try {
       return command.apply(ctx, args)

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

@@ -128,22 +128,21 @@ addHook({
                     const resolve = arguments[0]
                     const reject = arguments[1]
 
-                    // not using shimmer here because resolve/reject could be empty
-                    arguments[0] = function wrappedResolve () {
+                    arguments[0] = shimmer.wrapFunction(resolve, resolve => function wrappedResolve () {
                       finish()
 
                       if (resolve) {
                         return resolve.apply(this, arguments)
                       }
-                    }
+                    })
 
-                    arguments[1] = function wrappedReject () {
+                    arguments[1] = shimmer.wrapFunction(reject, reject => function wrappedReject () {
                       finish()
 
                       if (reject) {
                         return reject.apply(this, arguments)
                       }
-                    }
+                    })
 
                     return originalThen.apply(this, arguments)
                   }
@@ -169,7 +168,7 @@ addHook({
   versions: ['6', '>=7'],
   file: 'lib/helpers/query/sanitizeFilter.js'
 }, sanitizeFilter => {
-  return shimmer.wrap(sanitizeFilter, function wrappedSanitizeFilter () {
+  return shimmer.wrapFunction(sanitizeFilter, sanitizeFilter => function wrappedSanitizeFilter () {
     const sanitizedObject = sanitizeFilter.apply(this, arguments)
 
     if (sanitizeFilterFinishCh.hasSubscribers) {

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

@@ -37,14 +37,14 @@ addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connect
 
         if (res._callback) {
           const cb = callbackResource.bind(res._callback)
-          res._callback = asyncResource.bind(function (error, result) {
+          res._callback = shimmer.wrapFunction(cb, cb => asyncResource.bind(function (error, result) {
             if (error) {
               errorCh.publish(error)
             }
             finishCh.publish(result)
 
             return cb.apply(this, arguments)
-          })
+          }))
         } else {
           const cb = asyncResource.bind(function () {
             finishCh.publish(undefined)
@@ -92,7 +92,7 @@ addHook({ name: 'mysql', file: 'lib/Pool.js', versions: ['>=2'] }, Pool => {
 
       const cb = arguments[arguments.length - 1]
       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/mysql2.js

@@ -31,19 +31,19 @@ addHook({ name: 'mysql2', file: 'lib/connection.js', versions: ['>=1'] }, Connec
   return Connection
 
   function bindExecute (cmd, execute, asyncResource) {
-    return asyncResource.bind(function executeWithTrace (packet, connection) {
+    return shimmer.wrapFunction(execute, execute => asyncResource.bind(function executeWithTrace (packet, connection) {
       if (this.onResult) {
         this.onResult = asyncResource.bind(this.onResult)
       }
 
       return execute.apply(this, arguments)
-    }, cmd)
+    }, cmd))
   }
 
   function wrapExecute (cmd, execute, asyncResource, config) {
     const callbackResource = new AsyncResource('bound-anonymous-fn')
 
-    return asyncResource.bind(function executeWithTrace (packet, connection) {
+    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)
@@ -57,13 +57,13 @@ addHook({ name: 'mysql2', file: 'lib/connection.js', versions: ['>=1'] }, Connec
       if (this.onResult) {
         const onResult = callbackResource.bind(this.onResult)
 
-        this.onResult = asyncResource.bind(function (error) {
+        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)
+        }, 'bound-anonymous-fn', this))
       } else {
         this.on('error', asyncResource.bind(error => errorCh.publish(error)))
         this.on('end', asyncResource.bind(() => finishCh.publish(undefined)))
@@ -76,6 +76,6 @@ addHook({ name: 'mysql2', file: 'lib/connection.js', versions: ['>=1'] }, Connec
       } catch (err) {
         errorCh.publish(err)
       }
-    }, cmd)
+    }, cmd))
   }
 })

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/nyc.js

@@ -0,0 +1,23 @@
+const { addHook, channel } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const codeCoverageWrapCh = channel('ci:nyc:wrap')
+
+addHook({
+  name: 'nyc',
+  versions: ['>=17']
+}, (nycPackage) => {
+  shimmer.wrap(nycPackage.prototype, 'wrap', wrap => async function () {
+    // Only relevant if the config `all` is set to true
+    try {
+      if (JSON.parse(process.env.NYC_CONFIG).all) {
+        codeCoverageWrapCh.publish(this)
+      }
+    } catch (e) {
+      // ignore errors
+    }
+
+    return wrap.apply(this, arguments)
+  })
+  return nycPackage
+})

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)
     })
   }
 
@@ -213,7 +194,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,11 +234,13 @@ 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
+                }
               })
             }
 
@@ -281,7 +264,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 +286,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

@@ -122,7 +122,7 @@ function wrapPoolQuery (query) {
 
       const cb = arguments[arguments.length - 1]
       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) {