dd-trace 5.109.0 → 5.110.0

package/packages/datadog-instrumentations/src/helpers/check-require-cache.js

@@ -1,8 +1,9 @@
 'use strict'
 
-// This code runs before the tracer is configured and before a logger is ready
-// For that reason we queue up the messages now and decide what to do with them later
-const warnings = []
+// Queued before the logger is ready; flushed once the tracer knows its config.
+const warnings = [] // conflicts; flushed under DD_TRACE_DEBUG
+const loadOrderWarnings = [] // "loaded before dd-trace"; flushed under startupLogs
+const frameworkWarnings = [] // curated (e.g. Next.js); flushed unconditionally
 
 /**
  * Here we maintain a list of packages that an application
@@ -28,6 +29,24 @@ const potentialConflicts = new Set([
 
 const extractPackageAndModulePath = require('./extract-package-and-module-path')
 
+/**
+ * Frameworks that load their own server code before any user code (and thus
+ * before a late `tracer.init()`) can run. When their server module is already
+ * in `require.cache` at init time, dd-trace was loaded too late to instrument
+ * them and the integration silently no-ops. Unlike the broad scan below, this
+ * set is high-signal enough to warn on by default. `file` is the module whose
+ * presence proves the server is already loaded; `guidance` is the bundler note
+ * appended to the warning.
+ */
+const earlyLoadFrameworks = new Map([
+  ['next', {
+    // dist/server/next-server.js (>=11.1), dist/next-server/server/next-server.js (older)
+    file: 'next-server.js',
+    guidance: "add 'dd-trace' to `serverExternalPackages` (Next.js >=15) or " +
+      '`experimental.serverComponentsExternalPackages` (13-14) so it is not bundled',
+  }],
+])
+
 /**
  * The lowest hanging fruit to debug an app that isn't tracing
  * properly is to check that it is loaded before any modules
@@ -43,25 +62,53 @@ const extractPackageAndModulePath = require('./extract-package-and-module-path')
  * app loads a package we instrument but outside of an
  * unsupported version then a warning would still be displayed.
  * This is OK as the tracer should be loaded earlier anyway.
+ *
+ * Curated frameworks (see `earlyLoadFrameworks`) surface unconditionally; the
+ * broad list of packages loaded before dd-trace is queued for the startupLogs-
+ * gated flush (`flushLoadOrderWarnings`).
  */
 module.exports.checkForRequiredModules = function () {
   const packages = require('./hooks')
   const naughties = new Set()
+  const frameworksSeen = new Set()
   let didWarn = false
 
   for (const pathToModule of Object.keys(require.cache)) {
-    const { pkg } = extractPackageAndModulePath(pathToModule)
+    // require.cache keys use the platform separator; normalize so the
+    // `node_modules/<pkg>` parsing works on Windows (backslash paths).
+    const { pkg, path } = extractPackageAndModulePath(pathToModule.replaceAll('\\', '/'))
 
-    if (naughties.has(pkg)) continue
-    if (!(pkg in packages)) continue
+    if (pkg === null) continue
+
+    // A curated framework loads its own server before user code, so its server
+    // module being cached means dd-trace was too late to instrument it. These
+    // surface unconditionally (see flushFrameworkWarnings) with an actionable
+    // message, so they never fall through to the broad load-order list below.
+    const framework = earlyLoadFrameworks.get(pkg)
+    if (framework !== undefined) {
+      if (!frameworksSeen.has(pkg) && path?.endsWith(framework.file)) {
+        frameworksSeen.add(pkg)
+        frameworkWarnings.push(
+          `'${pkg}' was loaded before dd-trace, so the ${pkg} integration will not be applied. ` +
+          'Initialize dd-trace before your application starts — ' +
+          "NODE_OPTIONS='--require dd-trace/init' (CommonJS) or '--import dd-trace/initialize.mjs' (ESM) — " +
+          `and ${framework.guidance}.`
+        )
+      }
+      continue
+    }
 
-    warnings.push(() => `Warning: Package '${pkg}' was loaded before dd-trace! This may break instrumentation.`)
+    if (naughties.has(pkg) || !(pkg in packages)) continue
+
+    loadOrderWarnings.push(
+      () => `Warning: Package '${pkg}' was loaded before dd-trace! This may break instrumentation.`
+    )
 
     naughties.add(pkg)
     didWarn = true
   }
 
-  if (didWarn) warnings.push('Warning: Please ensure dd-trace is loaded before other modules.')
+  if (didWarn) loadOrderWarnings.push('Warning: Please ensure dd-trace is loaded before other modules.')
 }
 
 /**
@@ -104,3 +151,29 @@ module.exports.flushStartupLogs = function (log) {
     log.warn(typeof entry === 'function' ? entry() : entry)
   }
 }
+
+/**
+ * Drains the broad "loaded before dd-trace" warnings collected by
+ * `checkForRequiredModules`. The tracer gates this on startupLogs (these are
+ * startup diagnostics), unlike the unconditional `flushFrameworkWarnings`.
+ * @param {(message: string) => void} warn
+ */
+module.exports.flushLoadOrderWarnings = function (warn) {
+  while (loadOrderWarnings.length) {
+    const entry = loadOrderWarnings.shift()
+    warn(typeof entry === 'function' ? entry() : entry)
+  }
+}
+
+/**
+ * Drains the framework warnings collected by `checkForRequiredModules`. The
+ * tracer surfaces these unconditionally (not gated on startupLogs or
+ * DD_TRACE_DEBUG), unlike the DD_TRACE_DEBUG-only `flushStartupLogs` queue,
+ * because the affected users run with neither enabled (#5430 / #5432).
+ * @param {(message: string) => void} warn
+ */
+module.exports.flushFrameworkWarnings = function (warn) {
+  while (frameworkWarnings.length) {
+    warn(frameworkWarnings.shift())
+  }
+}

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

@@ -42,6 +42,31 @@ exports.tracingChannel = function (name) {
   return tc
 }
 
+/**
+ * Build a guarded publisher for a public error channel. A subscriber that
+ * re-enters the same wrapped dispatch while handling the error would otherwise
+ * republish here and recurse until the stack overflows. Each framework binds
+ * its own publisher, so the in-flight flag stays private to one channel: a
+ * genuinely nested error on a different framework's channel (a Koa app mounted
+ * inside Express) still reaches its subscribers instead of being dropped, and
+ * the guard costs a closure read rather than a per-publish channel lookup.
+ *
+ * @param {Channel} errorChannel
+ */
+exports.createErrorPublisher = function createErrorPublisher (errorChannel) {
+  let publishing = false
+  /** @param {object} message */
+  return function publishError (message) {
+    if (publishing) return
+    publishing = true
+    try {
+      errorChannel.publish(message)
+    } finally {
+      publishing = false
+    }
+  }
+}
+
 exports.getHooks = function getHooks (names) {
   names = [names].flat()
 
@@ -55,9 +80,9 @@ exports.getHooks = function getHooks (names) {
  * @param {object} args
  * @param {string} args.name module name
  * @param {string[]} [args.versions] array of semver range strings
- * @param {string} [args.file] path to file within package to instrument. Defaults to 'index.js'.
+ * @param {string} [args.file] path to file within package to instrument. Defaults to 'index.js'.
  * @param {string} [args.filePattern] pattern to match files within package to instrument
- * @param {boolean} [args.patchDefault] whether to patch the default export. Defaults to true.
+ * @param {boolean} [args.patchDefault] whether to patch the default export. Defaults to true.
  * @param {(moduleExports: unknown, version: string, isIitm?: boolean, hookMeta?: object) => unknown} [hook]
  * Patches module exports
  */

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/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/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, () => {

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/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

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

@@ -2,7 +2,7 @@
 
 const METHODS = [...require('http').METHODS.map(v => v.toLowerCase()), 'all']
 const shimmer = require('../../datadog-shimmer')
-const { addHook, channel } = require('./helpers/instrument')
+const { addHook, channel, createErrorPublisher } = require('./helpers/instrument')
 const { getCompileToRegexp } = require('./path-to-regexp')
 
 const {
@@ -40,6 +40,8 @@ function createWrapRouterMethod (name, compile) {
   const errorChannel = channel(`apm:${name}:middleware:error`)
   const nextChannel = channel(`apm:${name}:middleware:next`)
   const routeAddedChannel = channel(`apm:${name}:route:added`)
+  // Bound per name so express and a bare router keep independent guards.
+  const publishError = createErrorPublisher(errorChannel)
 
   function wrapLayerHandle (layer, original, matchers) {
     // Resolve `name` once at wrap time: cached on the original for any code
@@ -65,9 +67,20 @@ function createWrapRouterMethod (name, compile) {
     // `Layer.handleError`. Specialising lets the per-call body use named
     // parameters and `.call`, avoiding the rest-spread Array allocation that
     // the unified shape forced on every middleware invocation.
-    return original.length === 4
+    const wrapped = original.length === 4
       ? shimmer.wrapFunction(original, errorHandlerLayerWrap(layer, name, captureRoute, needMultiMatch, matchers))
       : shimmer.wrapFunction(original, requestHandlerLayerWrap(layer, name, captureRoute, needMultiMatch, matchers))
+
+    // Workaround for loopback's phase-based middleware sorting. Its
+    // `_findLayerByHandler` maps a layer back to the user handler by scanning
+    // the layer handle's enumerable properties for the original function.
+    // Replacing `layer.handle` with this wrapper hides that handler, so without
+    // the back-reference loopback cannot tag the layer with its phase and
+    // `app.middleware(phase, ...)` handlers run in insertion order instead of
+    // phase order. The property name is part of that contract; keep it stable.
+    wrapped._datadog_orig = original
+
+    return wrapped
   }
 
   function requestHandlerLayerWrap (layer, name, captureRoute, needMultiMatch, matchers) {
@@ -91,7 +104,7 @@ function createWrapRouterMethod (name, compile) {
       try {
         return original.call(this, req, res, wrappedNext)
       } catch (error) {
-        errorChannel.publish({ req, error })
+        publishError({ req, error })
         nextChannel.publish({ req })
         finishChannel.publish({ req })
 
@@ -123,7 +136,7 @@ function createWrapRouterMethod (name, compile) {
       try {
         return original.call(this, error, req, res, wrappedNext)
       } catch (caught) {
-        errorChannel.publish({ req, error: caught })
+        publishError({ req, error: caught })
         nextChannel.publish({ req })
         finishChannel.publish({ req })
 
@@ -161,7 +174,7 @@ function createWrapRouterMethod (name, compile) {
     // router continuation so wrapCallback skips its name/length rewrite.
     return shimmer.wrapCallback(originalNext, original => function next (error) {
       if (error && error !== 'route' && error !== 'router') {
-        errorChannel.publish({ req, error })
+        publishError({ req, error })
       }
 
       nextChannel.publish({ req })

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

@@ -19,8 +19,7 @@ if (window.DD_RUM && window.DD_RUM.stopSession) {
 `
 const IS_RUM_ACTIVE_SCRIPT = 'return !!window.DD_RUM'
 
-const DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS =
-Number(getValueFromEnvSources('DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS')) || 500
+const DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS = getValueFromEnvSources('DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS')
 const DD_CIVISIBILITY_TEST_EXECUTION_ID_COOKIE_NAME = 'datadog-ci-visibility-test-execution-id'
 
 // TODO: can we increase the supported version range?

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

@@ -4,12 +4,40 @@ const shimmer = require('../../datadog-shimmer')
 const {
   channel,
   addHook,
+  AsyncResource,
 } = require('./helpers/instrument')
 
+// Listeners added to the BulkLoad row stream (`bulkLoad.getRowStream()`) by the caller would
+// otherwise run in whatever async context emits the stream event, losing the span that was active
+// when the listener was registered. Bind each registered listener to its registration context so
+// `'finish'`/`'error'`/`'data'` handlers run in the caller's span, as they did before the tracer
+// moved to AsyncLocalStorage. tedious' own internal listeners are attached before `getRowStream`
+// returns, so only caller listeners are bound.
+const ROW_STREAM_LISTENER_METHODS = ['addListener', 'on', 'once', 'prependListener', 'prependOnceListener']
+
+function bindRowStreamListeners (rowStream) {
+  for (const method of ROW_STREAM_LISTENER_METHODS) {
+    shimmer.wrap(rowStream, method, register => function (eventName, listener) {
+      if (typeof listener !== 'function') {
+        return register.apply(this, arguments)
+      }
+      return register.call(this, eventName, AsyncResource.bind(listener))
+    })
+  }
+  return rowStream
+}
+
 addHook({ name: 'tedious', versions: ['>=1.0.0'] }, tedious => {
   const startCh = channel('apm:tedious:request:start')
   const finishCh = channel('apm:tedious:request:finish')
   const errorCh = channel('apm:tedious:request:error')
+
+  if (typeof tedious.BulkLoad?.prototype?.getRowStream === 'function') {
+    shimmer.wrap(tedious.BulkLoad.prototype, 'getRowStream', getRowStream => function () {
+      return bindRowStreamListeners(getRowStream.apply(this, arguments))
+    })
+  }
+
   shimmer.wrap(tedious.Connection.prototype, 'makeRequest', makeRequest => function (request) {
     if (!startCh.hasSubscribers) {
       return makeRequest.apply(this, arguments)