dd-trace 5.109.0 → 5.111.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/graphql.js

@@ -0,0 +1,201 @@
+'use strict'
+
+module.exports = [
+  {
+    module: {
+      name: 'graphql',
+      versionRange: '>=0.10',
+      filePath: 'execution/execute.js',
+    },
+    functionQuery: {
+      functionName: 'execute',
+      kind: 'Sync',
+    },
+    channelName: 'apm:graphql:execute',
+  },
+  {
+    module: {
+      name: 'graphql',
+      versionRange: '>=0.10',
+      filePath: 'execution/execute.mjs',
+    },
+    functionQuery: {
+      functionName: 'execute',
+      kind: 'Sync',
+    },
+    channelName: 'apm:graphql:execute',
+  },
+  {
+    module: {
+      name: 'graphql',
+      versionRange: '>=0.10',
+      filePath: 'language/parser.js',
+    },
+    functionQuery: {
+      functionName: 'parse',
+      kind: 'Sync',
+    },
+    channelName: 'apm:graphql:parser',
+  },
+  {
+    module: {
+      name: 'graphql',
+      versionRange: '>=0.10',
+      filePath: 'language/parser.mjs',
+    },
+    functionQuery: {
+      functionName: 'parse',
+      kind: 'Sync',
+    },
+    channelName: 'apm:graphql:parser',
+  },
+  {
+    module: {
+      name: 'graphql',
+      versionRange: '>=0.10',
+      filePath: 'validation/validate.js',
+    },
+    functionQuery: {
+      functionName: 'validate',
+      kind: 'Sync',
+    },
+    channelName: 'apm:graphql:validate',
+  },
+  {
+    module: {
+      name: 'graphql',
+      versionRange: '>=0.10',
+      filePath: 'validation/validate.mjs',
+    },
+    functionQuery: {
+      functionName: 'validate',
+      kind: 'Sync',
+    },
+    channelName: 'apm:graphql:validate',
+  },
+  // executeField / resolveField intentionally NOT instrumented here. Resolve spans
+  // are produced by wrapping user resolvers + the default field resolver at execute
+  // time (see packages/datadog-plugin-graphql/src/execute.js). That gives a zero-cost
+  // fast path when no subscribers are active, which per-field orchestrion hooks
+  // cannot offer (the publish is baked into graphql's compiled code).
+  {
+    module: {
+      name: '@graphql-tools/executor',
+      versionRange: '>=0.0.14',
+      filePath: 'cjs/execution/execute.js',
+    },
+    functionQuery: {
+      functionName: 'execute',
+      kind: 'Sync',
+    },
+    channelName: 'apm:graphql:execute',
+  },
+  {
+    module: {
+      name: '@graphql-tools/executor',
+      versionRange: '>=0.0.14',
+      filePath: 'esm/execution/execute.js',
+    },
+    functionQuery: {
+      functionName: 'execute',
+      kind: 'Sync',
+    },
+    channelName: 'apm:graphql:execute',
+  },
+  {
+    module: {
+      name: '@graphql-tools/executor',
+      versionRange: '>=0.0.14',
+      filePath: 'cjs/execution/normalizedExecutor.js',
+    },
+    functionQuery: {
+      functionName: 'normalizedExecutor',
+      kind: 'Sync',
+    },
+    channelName: 'apm:graphql:execute',
+  },
+  {
+    module: {
+      name: '@graphql-tools/executor',
+      versionRange: '>=0.0.14',
+      filePath: 'esm/execution/normalizedExecutor.js',
+    },
+    functionQuery: {
+      functionName: 'normalizedExecutor',
+      kind: 'Sync',
+    },
+    channelName: 'apm:graphql:execute',
+  },
+  {
+    module: {
+      name: 'graphql',
+      versionRange: '>=0.10',
+      filePath: 'language/printer.js',
+    },
+    functionQuery: {
+      functionName: '__module_export__',
+      kind: 'Sync',
+    },
+    channelName: 'dd:graphql:printer:load',
+  },
+  {
+    module: {
+      name: 'graphql',
+      versionRange: '>=0.10',
+      filePath: 'language/printer.mjs',
+    },
+    functionQuery: {
+      functionName: '__module_export__',
+      kind: 'Sync',
+    },
+    channelName: 'dd:graphql:printer:load',
+  },
+  {
+    module: {
+      name: 'graphql',
+      versionRange: '>=0.10',
+      filePath: 'language/visitor.js',
+    },
+    functionQuery: {
+      functionName: '__module_export__',
+      kind: 'Sync',
+    },
+    channelName: 'dd:graphql:visitor:load',
+  },
+  {
+    module: {
+      name: 'graphql',
+      versionRange: '>=0.10',
+      filePath: 'language/visitor.mjs',
+    },
+    functionQuery: {
+      functionName: '__module_export__',
+      kind: 'Sync',
+    },
+    channelName: 'dd:graphql:visitor:load',
+  },
+  {
+    module: {
+      name: 'graphql',
+      versionRange: '>=0.10',
+      filePath: 'utilities/index.js',
+    },
+    functionQuery: {
+      functionName: '__module_export__',
+      kind: 'Sync',
+    },
+    channelName: 'dd:graphql:utilities:load',
+  },
+  {
+    module: {
+      name: 'graphql',
+      versionRange: '>=0.10',
+      filePath: 'utilities/index.mjs',
+    },
+    functionQuery: {
+      functionName: '__module_export__',
+      kind: 'Sync',
+    },
+    channelName: 'dd:graphql:utilities:load',
+  },
+]

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

@@ -4,6 +4,7 @@ module.exports = [
   ...require('./ai'),
   ...require('./azure-cosmos'),
   ...require('./bullmq'),
+  ...require('./graphql'),
   ...require('./langchain'),
   ...require('./langgraph'),
   ...require('./modelcontextprotocol-sdk'),

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

@@ -6,6 +6,12 @@ const { wrapThen } = require('./helpers/promise')
 
 const startCh = channel('datadog:mongoose:model:filter:start')
 const finishCh = channel('datadog:mongoose:model:filter:finish')
+// Bound around the deferred query execution. A subscriber returns the store that
+// stays active for the whole async scope that reaches the mongodb driver, so the
+// nested driver query can see the parent's analysis marker without it leaking
+// past the query. `runStores` enters the store only for that scope and restores
+// the parent on its own.
+const execCh = channel('datadog:mongoose:model:filter:exec')
 // this channel is for wrapping the callback of exec methods and handling store context
 const execStartCh = channel('apm:mongoose:exec:start')
 const execFinishCh = channel('apm:mongoose:exec:finish')
@@ -103,7 +109,13 @@ addHook({
         return startCh.runStores(ctx, () => {
           wrapCallbackIfExist(args, ctx)
 
-          const res = method.apply(this, args)
+          // A callback query executes synchronously inside `method.apply`, so the
+          // exec scope (and the deferred driver call it spawns) must be entered
+          // here. A promise query defers execution to a later `exec`/`then`, which
+          // is bound separately below.
+          const res = callbackWrapped
+            ? execCh.runStores(ctx, () => method.apply(this, args))
+            : method.apply(this, args)
 
           // if it is not callback, wrap exec method and its then
           if (!callbackWrapped) {
@@ -113,7 +125,7 @@ addHook({
                   wrapCallbackIfExist(args, ctx)
                 }
 
-                const execResult = originalExec.apply(this, args)
+                const execResult = execCh.runStores(ctx, () => originalExec.apply(this, args))
 
                 if (callbackWrapped || typeof execResult?.then !== 'function') {
                   return execResult

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)