dd-trace 5.108.0 → 5.110.0

package/packages/datadog-instrumentations/src/helpers/optional-peer-bundler.js

@@ -0,0 +1,65 @@
+'use strict'
+
+const path = require('node:path')
+
+// Build-time half of the optional-peer mechanism shared by the webpack and esbuild plugins.
+//
+// Runtime files load an optional peer through `requireOptionalPeer('name')` (see
+// `require-optional-peer.js`), which bundlers cannot follow, so a build that does not opt into
+// the feature never pulls in the peer's (possibly optional) dependency chain (#8635). When the
+// peer is installed at build time the user has opted in, so the plugins rewrite the call into a
+// literal `require('name')` and let the bundler inline the peer, which keeps it working after
+// the bundle is relocated to a tree without the peer on disk (#8980). Peers that are absent at
+// build time stay opaque, so the rewrite is a no-op and the #8635 guarantee holds.
+
+// Files that load an optional peer this way, as suffixes of the resolved module path. The same
+// suffix matches the repo layout and `node_modules/dd-trace`. Add a file here to extend the
+// mechanism to a new optional peer; no plugin change is needed.
+const OPTIONAL_PEER_FILES = [
+  'packages/dd-trace/src/openfeature/flagging_provider.js',
+]
+
+// Captures the peer name from `requireOptionalPeer('name')` / `requireOptionalPeer("name")`.
+const OPTIONAL_PEER_LOAD = /requireOptionalPeer\((['"])(.+?)\1\)/g
+
+// esbuild's `onLoad` needs a path filter; match the basenames so the callback only fires for
+// the candidate files, then `matchesOptionalPeerFile` confirms the full suffix on a normalized
+// path (basenames carry no separators, so the filter is OS-agnostic).
+const OPTIONAL_PEER_FILTER = new RegExp(
+  `(?:${OPTIONAL_PEER_FILES.map((file) => path.basename(file).replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)).join('|')})$`
+)
+
+/**
+ * @param {string} normalizedResource - Resolved module path with forward slashes
+ * @returns {boolean} Whether the module is one of the optional-peer loader files
+ */
+function matchesOptionalPeerFile (normalizedResource) {
+  return OPTIONAL_PEER_FILES.some((suffix) => normalizedResource.endsWith(suffix))
+}
+
+/**
+ * Rewrites each `requireOptionalPeer('name')` whose peer resolves from `fromDir` into a literal
+ * `require('name')` so the bundler inlines it. Peers that do not resolve stay opaque, so a build
+ * without the peer keeps the #8635 guarantee.
+ *
+ * @param {string} source - Source of an optional-peer loader file
+ * @param {string} fromDir - Directory to resolve the optional peers from
+ * @returns {string} Source with installed optional peers turned into literal requires
+ */
+function rewriteOptionalPeerLoads (source, fromDir) {
+  return source.replaceAll(OPTIONAL_PEER_LOAD, (match, _quote, request) => {
+    try {
+      require.resolve(request, { paths: [fromDir] })
+    } catch {
+      return match
+    }
+    return `require('${request}')`
+  })
+}
+
+module.exports = {
+  OPTIONAL_PEER_FILES,
+  OPTIONAL_PEER_FILTER,
+  matchesOptionalPeerFile,
+  rewriteOptionalPeerLoads,
+}

package/packages/datadog-instrumentations/src/helpers/register.js

@@ -13,8 +13,9 @@ const Hook = require('./hook')
 const { isRelativeRequire } = require('./shared-utils')
 const rewriter = require('./rewriter')
 
-const DD_TRACE_DISABLED_INSTRUMENTATIONS = getValueFromEnvSources('DD_TRACE_DISABLED_INSTRUMENTATIONS') || ''
-const DD_TRACE_DEBUG = getValueFromEnvSources('DD_TRACE_DEBUG') || ''
+const DD_TRACE_DISABLED_INSTRUMENTATIONS =
+  getValueFromEnvSources('DD_TRACE_DISABLED_INSTRUMENTATIONS')
+const DD_TRACE_DEBUG = getValueFromEnvSources('DD_TRACE_DEBUG')
 
 const hooks = require('./hooks')
 const instrumentations = require('./instrumentations')
@@ -36,8 +37,9 @@ if (!disabledInstrumentations.has('process')) {
   require('../process')
 }
 
-if (DD_TRACE_DEBUG && DD_TRACE_DEBUG.toLowerCase() !== 'false') {
-  checkRequireCache.checkForRequiredModules()
+const debugEnabled = DD_TRACE_DEBUG
+checkRequireCache.checkForRequiredModules()
+if (debugEnabled) {
   setImmediate(checkRequireCache.checkForPotentialConflicts)
 }
 

package/packages/datadog-instrumentations/src/helpers/require-optional-peer.js

@@ -0,0 +1,17 @@
+'use strict'
+
+// Loads an optional peer through a require bundlers cannot follow: the package name is an
+// argument, not a `require('literal')`, so a build that does not install the peer never pulls
+// in its (possibly optional) dependency chain (#8635). When the peer is installed at build
+// time, the webpack and esbuild plugins rewrite `requireOptionalPeer('name')` into a literal
+// `require('name')` so the peer is bundled and survives the bundle being relocated without it
+// on disk (#8980). See `optional-peer-bundler.js` for the build-time half.
+
+/**
+ * @param {string} request - Module specifier of the optional peer
+ */
+module.exports = function requireOptionalPeer (request) {
+  // eslint-disable-next-line camelcase, no-undef
+  const runtimeRequire = typeof __non_webpack_require__ === 'function' ? __non_webpack_require__ : require
+  return runtimeRequire(request)
+}

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/aws-durable-execution-sdk-js.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const contextMethods = require('../../../aws-durable-execution-sdk-js-context-methods')
+
+const baseModule = { name: '@aws/durable-execution-sdk-js', versionRange: '>=1.1.0' }
+
+const buildEntries = filePath => {
+  const module = { ...baseModule, filePath }
+  return [
+    {
+      module,
+      functionQuery: { functionName: 'runHandler', kind: 'Async' },
+      channelName: 'withDurableExecution',
+    },
+    ...contextMethods.map(methodName => ({
+      module,
+      functionQuery: { className: 'DurableContextImpl', methodName, kind: 'Sync' },
+      channelName: `DurableContextImpl_${methodName}`,
+    })),
+    {
+      module,
+      functionQuery: { className: 'CheckpointManager', methodName: 'checkpoint', kind: 'Async' },
+      channelName: 'CheckpointManager_checkpoint',
+    },
+  ]
+}
+
+module.exports = [
+  ...buildEntries('dist/index.mjs'),
+  ...buildEntries('dist-cjs/index.js'),
+]

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/index.js

@@ -8,4 +8,5 @@ module.exports = [
   ...require('./langgraph'),
   ...require('./modelcontextprotocol-sdk'),
   ...require('./playwright'),
+  ...require('./aws-durable-execution-sdk-js'),
 ]

package/packages/datadog-instrumentations/src/helpers/rewriter/loader.mjs

@@ -3,9 +3,25 @@ import { rewrite } from './index.js'
 async function load (url, context, nextLoad) {
   const result = await nextLoad(url, context)
 
-  result.source = rewrite(result.source, url, context.format)
+  return rewriteResult(result, url, context)
+}
+
+function loadSync (url, context, nextLoad) {
+  const result = nextLoad(url, context)
+
+  return rewriteResult(result, url, context)
+}
+
+function rewriteResult (result, url, context) {
+  const format = result.format || context.format
+
+  // CommonJS source is rewritten by Module._compile. Rewriting it here too
+  // double-instruments CommonJS entrypoints loaded through sync hooks.
+  if (format === 'commonjs') return result
+
+  result.source = rewrite(result.source, url, format)
 
   return result
 }
 
-export { load }
+export { load, loadSync }

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

@@ -14,6 +14,7 @@ const finishChannel = channel('apm:http:client:request:finish')
 const endChannel = channel('apm:http:client:request:end')
 const asyncStartChannel = channel('apm:http:client:request:asyncStart')
 const errorChannel = channel('apm:http:client:request:error')
+const responseStartChannel = channel('apm:http:client:response:start')
 const responseFinishChannel = channel('apm:http:client:response:finish')
 
 addHook({ name: 'http' }, hookFn)
@@ -78,10 +79,15 @@ function setupResponseInstrumentation (ctx, res) {
   let dataReadStarted = false
 
   const { shouldCollectBody } = ctx
-  const bodyChunks = shouldCollectBody ? [] : null
+
+  let bodyChunks = null
+
+  if (shouldCollectBody) {
+    bodyChunks = []
+  }
 
   const collectChunk = chunk => {
-    if (!shouldCollectBody || !chunk) return
+    if (!bodyChunks || !chunk) return
 
     if (typeof chunk === 'string') {
       bodyChunks.push(chunk)
@@ -229,6 +235,10 @@ function patch (http, methodName) {
                 res.once('end', finish)
                 res.once(errorMonitor, finish)
 
+                if (responseStartChannel.hasSubscribers) {
+                  responseStartChannel.publish({ ctx, res })
+                }
+
                 const instrumentation = setupResponseInstrumentation(ctx, res)
 
                 if (!instrumentation) {

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

@@ -26,7 +26,6 @@ function wrapRedis (Redis) {
     }
 
     const ctx = {
-      db: options.db,
       command: command.name,
       args: command.args,
       connectionOptions,

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

@@ -18,10 +18,9 @@ addHook({ name: 'iovalkey', versions: ['>=0.0.1'] }, Valkey => {
 
     const options = this.options || {}
     const connectionName = options.connectionName
-    const db = options.db
     const connectionOptions = { host: options.host, port: options.port }
 
-    const ctx = { db, command: command.name, args: command.args, connectionOptions, connectionName }
+    const ctx = { command: command.name, args: command.args, connectionOptions, connectionName }
     return startCh.runStores(ctx, () => {
       command.promise.then(() => finish(finishCh, errorCh, ctx), err => finish(finishCh, errorCh, ctx, err))
 

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

@@ -1,7 +1,7 @@
 'use strict'
 
 const shimmer = require('../../datadog-shimmer')
-const { addHook, channel } = require('./helpers/instrument')
+const { addHook, channel, createErrorPublisher } = require('./helpers/instrument')
 
 const enterChannel = channel('apm:koa:middleware:enter')
 const exitChannel = channel('apm:koa:middleware:exit')
@@ -10,6 +10,7 @@ const nextChannel = channel('apm:koa:middleware:next')
 const finishChannel = channel('apm:koa:middleware:finish')
 const handleChannel = channel('apm:koa:request:handle')
 const routeChannel = channel('apm:koa:request:route')
+const publishError = createErrorPublisher(errorChannel)
 
 const originals = new WeakMap()
 
@@ -132,7 +133,7 @@ function fulfill (ctx, error) {
   const route = ctx.routePath
 
   if (error) {
-    errorChannel.publish({ req, error })
+    publishError({ req, error })
   }
 
   // TODO: make sure that the parent class cannot override this in `enter`

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

@@ -160,14 +160,16 @@ addHook({ name, file: 'lib/cmd/execute.js', versions: ['>=3'] }, (Execute) => {
   return wrapCommand(Execute)
 })
 
-// in 3.4.1 getConnection method start to use callbacks instead of promises
+// mariadb 3.4.1 refactored the pool: getConnection switched from promises to
+// callbacks and _createConnection was renamed to _createPoolConnection.
 addHook({ name, file: 'lib/pool.js', versions: ['>=3.4.1'] }, (Pool) => {
   shimmer.wrap(Pool.prototype, 'getConnection', wrapPoolGetConnectionMethod)
+  shimmer.wrap(Pool.prototype, '_createPoolConnection', wrapPoolMethod)
 
   return Pool
 })
 
-addHook({ name, file: 'lib/pool.js', versions: ['>=3'] }, (Pool) => {
+addHook({ name, file: 'lib/pool.js', versions: ['>=3 <3.4.1'] }, (Pool) => {
   shimmer.wrap(Pool.prototype, '_createConnection', wrapPoolMethod)
 
   return Pool

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

@@ -1093,9 +1093,9 @@ addHook({
   shimmer.wrap(BufferedWorkerPool.prototype, 'run', run => async function (testSuiteAbsolutePath, workerArgs) {
     if (!testFinishCh.hasSubscribers ||
         (!config.isKnownTestsEnabled &&
-         !config.isTestManagementTestsEnabled &&
-         !config.isImpactedTestsEnabled &&
-         !config.isFlakyTestRetriesEnabled)) {
+        !config.isTestManagementTestsEnabled &&
+        !config.isImpactedTestsEnabled &&
+        !config.isFlakyTestRetriesEnabled)) {
       return run.apply(this, arguments)
     }
 

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

@@ -141,19 +141,19 @@ function instrument (req, res, handler, error) {
   requests.add(req)
 
   const ctx = { req, res }
-  // Parse query parameters from request URL
   if (queryParsedChannel.hasSubscribers && req.url) {
-    // req.url is only the relative path (/foo?bar=baz) and new URL() needs a full URL
-    // so we give it a dummy base
-    const { searchParams } = new URL(req.url, 'http://dummy')
-    const query = {}
-    for (const key of searchParams.keys()) {
-      if (!query[key]) {
-        query[key] = searchParams.getAll(key)
+    const queryIndex = req.url.indexOf('?')
+    if (queryIndex !== -1) {
+      const searchParams = new URLSearchParams(req.url.slice(queryIndex + 1))
+      const query = {}
+      for (const key of searchParams.keys()) {
+        if (!query[key]) {
+          query[key] = searchParams.getAll(key)
+        }
       }
-    }
 
-    queryParsedChannel.publish({ query })
+      queryParsedChannel.publish({ query })
+    }
   }
 
   return startChannel.runStores(ctx, () => {
@@ -220,6 +220,40 @@ addHook({
   return NextRequestAdapter
 })
 
+// From next 15.4.1 each app-route build inlines its own copy of `fromNodeNextRequest`, so the hook
+// above no longer maps the node request to the app-route NextRequest and a thrown handler error
+// cannot reach `finish`. The app-route runtime reports real errors (redirect/notFound and other
+// control-flow signals excluded by next) through `RouteModule.onRequestError`, which next loads from
+// a precompiled `app-route*.runtime.{dev,prod}.js` bundle regardless of how the route chunk is
+// bundled. The bundler/experimental part of the name is matched with a pattern rather than
+// enumerated, so a variant next adds later is picked up without a code change.
+const patchedAppRouteModules = new WeakSet()
+
+function wrapOnRequestError (onRequestError) {
+  return function (req, error) {
+    if (error) {
+      errorChannel.publish({ error })
+    }
+    return onRequestError.apply(this, arguments)
+  }
+}
+
+function instrumentAppRouteRuntime (runtime) {
+  const AppRouteRouteModule = runtime.AppRouteRouteModule
+  const proto = AppRouteRouteModule?.prototype
+  if (proto && typeof proto.onRequestError === 'function' && !patchedAppRouteModules.has(AppRouteRouteModule)) {
+    patchedAppRouteModules.add(AppRouteRouteModule)
+    shimmer.wrap(proto, 'onRequestError', wrapOnRequestError)
+  }
+  return runtime
+}
+
+addHook({
+  name: 'next',
+  versions: ['>=15.4.1'],
+  filePattern: String.raw`dist/compiled/next-server/app-route[\w-]*\.runtime\.(?:dev|prod)\.js$`,
+}, instrumentAppRouteRuntime)
+
 addHook({
   name: 'next',
   versions: ['>=11.1'],

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

@@ -3,11 +3,52 @@
 const dc = require('dc-polyfill')
 const shimmer = require('../../datadog-shimmer')
 const { addHook } = require('./helpers/instrument')
-const aiGuard = require('./helpers/openai-ai-guard')
 
 const ch = dc.tracingChannel('apm:openai:request')
 const onStreamedChunkCh = dc.channel('apm:openai:request:chunk')
 
+// Provider lifecycle channels. Payloads stay OpenAI-native:
+// before { args, parentSpan, abortController, pending }
+// after  { args, body, parentSpan, abortController, pending }
+const chatCompletionsBeforeChannel = dc.channel('dd-trace:openai:chat.completions:before')
+const chatCompletionsAfterChannel = dc.channel('dd-trace:openai:chat.completions:after')
+const responsesBeforeChannel = dc.channel('dd-trace:openai:responses:before')
+const responsesAfterChannel = dc.channel('dd-trace:openai:responses:after')
+
+const LIFECYCLE_CHANNELS = {
+  'chat.completions': {
+    before: chatCompletionsBeforeChannel,
+    after: chatCompletionsAfterChannel,
+  },
+  responses: {
+    before: responsesBeforeChannel,
+    after: responsesAfterChannel,
+  },
+}
+
+/**
+ * Publishes a provider-native lifecycle payload to a cancelable lifecycle channel.
+ *
+ * Subscribers push async work into `pending` synchronously during publication and
+ * abort `abortController` with an error before the pushed promise resolves to block.
+ *
+ * @param {object} channel
+ * @param {object} payload
+ * @returns {Promise<void>}
+ */
+function publishLifecycle (channel, payload) {
+  const abortController = new AbortController()
+  const ctx = { ...payload, abortController, pending: [] }
+
+  channel.publish(ctx)
+
+  return Promise.all(ctx.pending).then(() => {
+    if (abortController.signal.aborted) {
+      throw abortController.signal.reason
+    }
+  })
+}
+
 const V4_PACKAGE_SHIMS = [
   {
     file: 'resources/chat/completions',
@@ -217,17 +258,15 @@ for (const extension of extensions) {
 
       for (const methodName of methods) {
         shimmer.wrap(targetPrototype, methodName, methodFn => function (...args) {
-          if (!ch.start.hasSubscribers && !aiGuard.hasSubscribers()) {
-            return methodFn.apply(this, args)
-          }
           // The OpenAI library lets you set `stream: true` on the options arg to any method
           // However, we only want to handle streamed responses in specific cases
           // chat.completions and completions
           const stream = streamedResponse && getOption(args, 'stream', false)
 
-          const guard = aiGuard.createGuard(baseResource, args[0], stream)
+          const channels = stream ? null : LIFECYCLE_CHANNELS[baseResource]
+          const hasLifecycle = !!channels && (channels.before.hasSubscribers || channels.after.hasSubscribers)
 
-          if (!ch.start.hasSubscribers && !guard) {
+          if (!ch.start.hasSubscribers && !hasLifecycle) {
             return methodFn.apply(this, args)
           }
 
@@ -240,12 +279,22 @@ for (const extension of extensions) {
           }
 
           return ch.start.runStores(ctx, () => {
-            // Explicit childOf rather than async-context: the _thenUnwrap/parse path
-            // decouples the lazy evaluation from the active scope at call time.
-            if (guard) guard.parentSpan = ctx.currentStore?.span
+            // Capture the parent span explicitly: the _thenUnwrap/parse path decouples
+            // the lazy evaluation from the active scope at call time.
+            const parentSpan = hasLifecycle ? ctx.currentStore?.span : undefined
 
             const apiProm = methodFn.apply(this, args)
 
+            const beforeChannel = hasLifecycle && channels.before.hasSubscribers ? channels.before : null
+            const afterChannel = hasLifecycle && channels.after.hasSubscribers ? channels.after : null
+            let beforeVerdict
+            const getBeforeVerdict = beforeChannel
+              ? function getBeforeVerdict () {
+                beforeVerdict ??= publishLifecycle(beforeChannel, { args, parentSpan })
+                return beforeVerdict
+              }
+              : null
+
             if (baseResource === 'chat.completions' && typeof apiProm._thenUnwrap === 'function') {
               // this should only ever be invoked from a client.beta.chat.completions.parse call
               shimmer.wrap(apiProm, '_thenUnwrap', origApiPromThenUnwrap => function (...args) {
@@ -259,7 +308,9 @@ for (const extension of extensions) {
                   const parsedPromise = origApiPromParse.apply(this, args)
                     .then(body => Promise.all([this.responsePromise, body]))
 
-                  return handleUnwrappedAPIPromise(parsedPromise, ctx, stream, guard)
+                  return handleUnwrappedAPIPromise(
+                    parsedPromise, ctx, stream, getBeforeVerdict, afterChannel, parentSpan
+                  )
                 })
 
                 return unwrappedPromise
@@ -272,10 +323,16 @@ for (const extension of extensions) {
               const parsedPromise = origApiPromParse.apply(this, args)
                 .then(body => Promise.all([this.responsePromise, body]))
 
-              return handleUnwrappedAPIPromise(parsedPromise, ctx, stream, guard)
+              return handleUnwrappedAPIPromise(parsedPromise, ctx, stream, getBeforeVerdict, afterChannel, parentSpan)
             })
 
-            if (guard) aiGuard.wrapAsResponse(apiProm, guard)
+            // Gate `.asResponse()` callers on the before verdict so raw-response paths still block.
+            if (beforeChannel && typeof apiProm.asResponse === 'function') {
+              shimmer.wrap(apiProm, 'asResponse', origAsResponse => function (...args) {
+                const responsePromise = origAsResponse.apply(this, args)
+                return Promise.all([getBeforeVerdict(), responsePromise]).then(([, response]) => response)
+              })
+            }
 
             ch.end.publish(ctx)
 
@@ -288,10 +345,12 @@ for (const extension of extensions) {
   }
 }
 
-function handleUnwrappedAPIPromise (apiProm, ctx, stream, guard) {
-  const guardedApiProm = guard ? aiGuard.gateParse(apiProm, guard) : apiProm
+function handleUnwrappedAPIPromise (apiProm, ctx, stream, getBeforeVerdict, afterChannel, parentSpan) {
+  const gatedApiProm = getBeforeVerdict
+    ? Promise.all([getBeforeVerdict(), apiProm]).then(([, result]) => result)
+    : apiProm
 
-  return guardedApiProm
+  return gatedApiProm
     .then(([{ response, options }, body]) => {
       if (stream) {
         if (body.iterator) {
@@ -313,14 +372,14 @@ function handleUnwrappedAPIPromise (apiProm, ctx, stream, guard) {
         },
       }
 
-      if (!guard) {
+      if (!afterChannel) {
         finish(ctx, responseData)
         return body
       }
 
       // Finish after evaluation so a block propagates the error to openai.request
-      // and the span wraps its ai_guard child instead of closing before it.
-      return aiGuard.evaluateOutput(guard, body).then(() => {
+      // and the span wraps its child instead of closing before it.
+      return publishLifecycle(afterChannel, { args: ctx.args, body, parentSpan }).then(() => {
         finish(ctx, responseData)
         return body
       })

package/packages/datadog-instrumentations/src/otel-sdk-trace.js

@@ -3,7 +3,6 @@
 const shimmer = require('../../datadog-shimmer')
 const tracer = require('../../dd-trace')
 const { getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
-const { isFalse, isTrue } = require('../../dd-trace/src/util')
 const { addHook } = require('./helpers/instrument')
 
 if (isOtelSdkEnabled()) {
@@ -21,9 +20,11 @@ if (isOtelSdkEnabled()) {
 
 function isOtelSdkEnabled () {
   // Datadog explicit opt-out wins over every OTel signal; check it first.
-  const ddTraceOtelEnabled = getValueFromEnvSources('DD_TRACE_OTEL_ENABLED')
-  if (isFalse(ddTraceOtelEnabled)) return false
-  const otelSdkDisabled = getValueFromEnvSources('OTEL_SDK_DISABLED')
-  if (isTrue(otelSdkDisabled)) return false
-  return isTrue(ddTraceOtelEnabled) || isFalse(otelSdkDisabled)
+  // skipDefault: an unset option must stay undefined so the OTel signal still decides — the
+  // registered defaults (false / true) would otherwise force-disable before that check.
+  const ddTraceOtelEnabled = getValueFromEnvSources('DD_TRACE_OTEL_ENABLED', true)
+  if (ddTraceOtelEnabled === false) return false
+  const otelSdkDisabled = getValueFromEnvSources('OTEL_SDK_DISABLED', true)
+  if (otelSdkDisabled) return false
+  return ddTraceOtelEnabled || otelSdkDisabled === false
 }

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

@@ -59,7 +59,7 @@ const testSuiteToTestStatuses = new Map()
 const testSuiteToErrors = new Map()
 const testsToTestStatuses = new Map()
 
-const RUM_FLUSH_WAIT_TIME = Number(getValueFromEnvSources('DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS')) || 500
+const RUM_FLUSH_WAIT_TIME = getValueFromEnvSources('DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS')
 const DD_PROPERTIES_TIMEOUT = 5000
 
 let applyRepeatEachIndex = null

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

@@ -147,7 +147,6 @@ function getStartCtx (client, command, args, argsStartIndex) {
   }
 
   return {
-    db: client.selected_db,
     command,
     args,
     argsStartIndex,

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

@@ -1,7 +1,7 @@
 'use strict'
 
 const shimmer = require('../../datadog-shimmer')
-const { addHook, channel } = require('./helpers/instrument')
+const { addHook, channel, createErrorPublisher } = require('./helpers/instrument')
 const handlers = ['use', 'pre']
 const methods = ['del', 'get', 'head', 'opts', 'post', 'put', 'patch']
 
@@ -11,6 +11,7 @@ const enterChannel = channel('apm:restify:middleware:enter')
 const exitChannel = channel('apm:restify:middleware:exit')
 const finishChannel = channel('apm:restify:middleware:finish')
 const nextChannel = channel('apm:restify:middleware:next')
+const publishError = createErrorPublisher(errorChannel)
 
 function wrapSetupRequest (setupRequest) {
   return function (req, res) {
@@ -53,7 +54,7 @@ function wrapFn (fn) {
           finishChannel.publish({ req })
           return result
         }).catch(function (error) {
-          errorChannel.publish({ req, error })
+          publishError({ req, error })
           nextChannel.publish({ req })
           finishChannel.publish({ req })
           throw error
@@ -61,7 +62,7 @@ function wrapFn (fn) {
       }
       return result
     } catch (error) {
-      errorChannel.publish({ req, error })
+      publishError({ req, error })
       nextChannel.publish({ req })
       finishChannel.publish({ req })
       throw error