dd-trace 6.7.0 → 6.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "6.7.0",
+  "version": "6.8.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -96,6 +96,9 @@
     "test:integration:playwright:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 60000 \"integration-tests/playwright/${SPEC:-playwright-*}.spec.js\"",
     "test:integration:selenium": "mocha --timeout 60000 \"integration-tests/selenium/*.spec.js\"",
     "test:integration:selenium:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 60000 \"integration-tests/selenium/*.spec.js\"",
+    "test:integration:test-optimization:helpers": "mocha \"integration-tests/cypress/*dependencies.spec.js\" \"integration-tests/jest/*dependencies.spec.js\" \"integration-tests/playwright/version*.spec.js\"",
+    "test:integration:webdriverio": "mocha --timeout 60000 \"integration-tests/webdriverio/*.spec.js\"",
+    "test:integration:webdriverio:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 60000 \"integration-tests/webdriverio/*.spec.js\"",
     "test:integration:vitest": "mocha --timeout 60000 \"integration-tests/vitest/${SPEC:-vitest*}.spec.js\"",
     "test:integration:vitest:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 60000 \"integration-tests/vitest/${SPEC:-vitest*}.spec.js\"",
     "test:integration:testopt": "mocha --timeout 120000 \"integration-tests/ci-visibility/*.spec.js\"",
@@ -178,7 +181,7 @@
     "@datadog/native-appsec": "11.0.1",
     "@datadog/native-iast-taint-tracking": "4.2.0",
     "@datadog/native-metrics": "3.1.2",
-    "@datadog/openfeature-node-server": "2.0.0",
+    "@datadog/openfeature-node-server": "2.0.2",
     "@datadog/pprof": "5.17.0",
     "@datadog/wasm-js-rewriter": "5.0.1",
     "@opentelemetry/api": ">=1.0.0 <1.10.0",
@@ -199,6 +202,7 @@
     "@types/node": "^18.19.106",
     "@types/sinon": "^22.0.0",
     "@vercel/nft": "^1.10.2",
+    "@yarnpkg/lockfile": "^1.1.0",
     "axios": "^1.18.1",
     "benchmark": "^2.1.4",
     "body-parser": "^2.3.0",
@@ -213,7 +217,7 @@
     "eslint-plugin-n": "^18.2.1",
     "eslint-plugin-promise": "^7.3.0",
     "eslint-plugin-sonarjs": "^4.2.0",
-    "eslint-plugin-unicorn": "^68.0.0",
+    "eslint-plugin-unicorn": "^72.0.0",
     "express": "^5.1.0",
     "glob": "^10.4.5",
     "globals": "^17.7.0",
@@ -221,7 +225,9 @@
     "husky": "^9.1.7",
     "istanbul-lib-report": "^3.0.0",
     "istanbul-reports": "^3.0.2",
+    "jsonc-parser": "^3.3.1",
     "jszip": "^3.10.1",
+    "minimatch": "^10.2.5",
     "mocha": "^11.7.6",
     "mocha-junit-reporter": "^2.2.1",
     "mocha-multi-reporters": "^1.5.1",

package/packages/datadog-core/src/utils/src/kebabcase.js

@@ -5,10 +5,16 @@ module.exports = function kebabcase (str) {
     throw new TypeError('Expected a string')
   }
 
-  return str
+  const kebab = str
     .trim()
     .replaceAll(/([a-z])([A-Z])/g, '$1-$2') // Convert camelCase to kebab-case
     .replaceAll(/[\s_]+/g, '-') // Replace spaces and underscores with a single dash
-    .replaceAll(/^-+|-+$/g, '') // Trim leading and trailing dashes
     .toLowerCase()
+
+  // Trim by index; a `/-+$/` regex re-examines the dash run once per start position.
+  let start = 0
+  let end = kebab.length
+  while (kebab.charCodeAt(start) === 45) start++ // '-'
+  while (end > start && kebab.charCodeAt(end - 1) === 45) end--
+  return kebab.slice(start, end)
 }

package/packages/datadog-esbuild/index.js

@@ -265,10 +265,12 @@ ${build.initialOptions.banner.js}`
         }
       }
       // The file namespace is used when requiring files from disk in userland
+      if (extracted.pkg === null) return
+
       let pathToPackageJson
       try {
         // we can't use require.resolve('pkg/package.json') as ESM modules don't make the file available
-        pathToPackageJson = require.resolve(`${extracted.pkg}`, { paths: [args.resolveDir] })
+        pathToPackageJson = require.resolve(extracted.pkg, { paths: [args.resolveDir] })
         pathToPackageJson = extractPackageAndModulePath(pathToPackageJson).pkgJson
       } catch (err) {
         if (err.code === 'MODULE_NOT_FOUND') {
@@ -340,7 +342,7 @@ ${build.initialOptions.banner.js}`
 
       if (data.isESM) {
         if (args.path.endsWith(ESM_INTERCEPTED_SUFFIX)) {
-          args.path = args.path.slice(0, -1 * ESM_INTERCEPTED_SUFFIX.length)
+          args.path = args.path.slice(0, -ESM_INTERCEPTED_SUFFIX.length)
 
           if (data.internal) {
             args.path = args.path.slice(INTERNAL_ESM_INTERCEPTED_PREFIX.length)

package/packages/datadog-esbuild/src/utils.js

@@ -174,7 +174,7 @@ async function processModule ({ path, internal = false, context, excludeDefault
   for (const n of exportNames) {
     if (n === 'default' && excludeDefault) continue
 
-    if (isStarExportLine(n) === true) {
+    if (isStarExportLine(n)) {
       // export * from 'wherever'
       const [, modFile] = n.split('* from ')
 

package/packages/datadog-instrumentations/src/claude-agent-sdk.js

@@ -54,7 +54,7 @@ function buildTracerHooks (sessionCtx) {
     sessionCtx.cwd = input.cwd
     sessionCtx.transcriptPath = input.transcript_path
     sessionCtx.agentType = input.agent_type
-    sessionCtx.permissionMode = sessionCtx.permissionMode || input.permission_mode
+    sessionCtx.permissionMode ||= input.permission_mode
     return {}
   }
 
@@ -64,8 +64,8 @@ function buildTracerHooks (sessionCtx) {
   }
 
   function onUserPromptSubmit (input) {
-    sessionCtx.sessionId = sessionCtx.sessionId || input.session_id
-    sessionCtx.prompt = sessionCtx.prompt || input.prompt
+    sessionCtx.sessionId ||= input.session_id
+    sessionCtx.prompt ||= input.prompt
     return {}
   }
 
@@ -254,7 +254,7 @@ function createStreamLookup (chunks) {
     scanLocalLifecycle(chunks, startIndex, toolUseId, localLifecycle)
     if (localLifecycle.toolResultIndex !== undefined) return localLifecycle
 
-    streamIndex = streamIndex || buildStreamIndex(chunks)
+    streamIndex ||= buildStreamIndex(chunks)
     const indexedLifecycle = streamIndex.get(toolUseId)
     return {
       taskStartedChunk: localLifecycle.taskStartedChunk || indexedLifecycle?.taskStartedChunk,

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

@@ -6,6 +6,7 @@ const { createCoverageMap } = require('../../../vendor/dist/istanbul-lib-coverag
 const shimmer = require('../../datadog-shimmer')
 const log = require('../../dd-trace/src/log')
 const { getEnvironmentVariable } = require('../../dd-trace/src/config/helper')
+const { getSegment } = require('../../dd-trace/src/util')
 const {
   getCoveredFilesFromCoverage,
   getExecutableFilesFromCoverage,
@@ -342,7 +343,7 @@ function handleParallelTestCaseFinished (pickle, worstTestStepResult) {
   }
 
   const testFileAbsolutePath = pickle.uri
-  const finished = pickleResultByFile[testFileAbsolutePath] || (pickleResultByFile[testFileAbsolutePath] = [])
+  const finished = (pickleResultByFile[testFileAbsolutePath] ||= [])
 
   if (isEarlyFlakeDetectionEnabled && isNew) {
     const testFullname = `${pickle.uri}:${pickle.name}`
@@ -555,8 +556,7 @@ function getErrorFromCucumberResult (cucumberResult) {
     return
   }
 
-  const [message] = cucumberResult.message.split('\n')
-  const error = new Error(message)
+  const error = new Error(getSegment(cucumberResult.message, '\n', 0))
   if (cucumberResult.exception) {
     error.type = cucumberResult.exception.type
   }
@@ -696,7 +696,7 @@ function publishRetriedAttempt (runner, state) {
 
   // ATR: record this attempt as failed so when run().finally runs (after retry) we have all statuses
   if (isFlakyTestRetriesEnabled) {
-    const nameForKey = runner.pickle.name.replace(/\s*\(attempt \d+(?:, retried)?\)\s*$/, '')
+    const nameForKey = runner.pickle.name.replace(/ ?\(attempt \d+(?:, retried)?\) ?$/, '')
     const atrKey = `${runner.pickle.uri}:${nameForKey}`
     if (atrStatusesByScenarioKey.has(atrKey)) {
       atrStatusesByScenarioKey.get(atrKey).push('fail')
@@ -793,7 +793,7 @@ function wrapRun (pl, isLatestVersion, version) {
       testFnCh.runStores(ctx, () => {
         promise = run.apply(this, args)
       })
-      promise.finally(async () => {
+      const finalize = async () => {
         if (!canAwaitRetries) {
           this.eventBroadcaster.removeListener('envelope', onEnvelope)
         }
@@ -889,7 +889,7 @@ function wrapRun (pl, isLatestVersion, version) {
         // ATR: accumulate statuses by stable scenario key (uri:name) so retries are grouped.
         // Cucumber appends " (attempt N)" or " (attempt N, retried)" to the scenario name; normalize for keying.
         if (isFlakyTestRetriesEnabled && !isAttemptToFix && !isEfdRetry && numTestRetries > 0) {
-          const nameForKey = this.pickle.name.replace(/\s*\(attempt \d+(?:, retried)?\)\s*$/, '')
+          const nameForKey = this.pickle.name.replace(/ ?\(attempt \d+(?:, retried)?\) ?$/, '')
           const atrKey = `${this.pickle.uri}:${nameForKey}`
           if (atrStatusesByScenarioKey.has(atrKey)) {
             atrStatusesByScenarioKey.get(atrKey).push(status)
@@ -966,6 +966,9 @@ function wrapRun (pl, isLatestVersion, version) {
           ...attemptCtx.currentStore,
           finalStatus,
         })
+      }
+      promise.then(finalize, finalize).catch(error => {
+        log.error('Cucumber test finalization error', error)
       })
       return promise
     } catch (err) {

package/packages/datadog-instrumentations/src/helpers/extract-package-and-module-path.js

@@ -2,11 +2,21 @@
 
 const NM = 'node_modules/'
 
+/**
+ * @typedef {object} PackageAndModulePath
+ * @property {string|null} pkg
+ * @property {string|null} path
+ * @property {string} [pkgJson]
+ */
+
 /**
  * For a given full path to a module,
  *   return the package name it belongs to and the local path to the module
  *   input: '/foo/node_modules/@co/stuff/foo/bar/baz.js'
  *   output: { pkg: '@co/stuff', path: 'foo/bar/baz.js',  pkgJson: '/foo/node_modules/@co/stuff/package.json' }
+ *
+ * @param {string} fullPath
+ * @returns {PackageAndModulePath}
  */
 module.exports = function extractPackageAndModulePath (fullPath) {
   const nm = fullPath.lastIndexOf(NM)

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

@@ -6,6 +6,7 @@ const iitm = require('../../../dd-trace/src/iitm')
 const ritm = require('../../../dd-trace/src/ritm')
 const log = require('../../../dd-trace/src/log')
 const requirePackageJson = require('../../../dd-trace/src/require-package-json')
+const { isNodeBuiltinModuleName } = require('./shared-utils')
 
 /**
  * @param {string} moduleBaseDir
@@ -82,7 +83,7 @@ function Hook (modules, hookOptions, onrequire) {
       moduleVersion ||= getVersion(moduleBaseDir)
     } catch (error) {
       log.error('Error getting version for "%s": %s', moduleName, error.message, error)
-      return
+      return moduleExports
     }
 
     if (
@@ -101,7 +102,23 @@ function Hook (modules, hookOptions, onrequire) {
       }
     }
 
-    const newExports = wrappedOnrequire(moduleExports, moduleName, moduleBaseDir, moduleVersion, isIitm)
+    // A builtin's named ESM exports are a second view of what `default` already points at, and
+    // `patched` cannot relate them because it keys on the object the hook ran against.
+    let newExports
+    if (defaultWrapResult && isNodeBuiltinModuleName(moduleName)) {
+      // Accessor exports are read, not skipped: `replaceGetter` leaves Node 20's `fs.opendir`
+      // an accessor, and Node's ESM facade resolved every export before handing us this view.
+      for (const key of Object.keys(defaultWrapResult)) {
+        const wrapped = defaultWrapResult[key]
+        const existing = moduleExports[key]
+        if (existing !== wrapped && existing !== undefined) {
+          moduleExports[key] = wrapped
+        }
+      }
+      newExports = moduleExports
+    } else {
+      newExports = wrappedOnrequire(moduleExports, moduleName, moduleBaseDir, moduleVersion, isIitm)
+    }
 
     if (defaultWrapResult && defaultExportAliases) {
       newExports.default = defaultWrapResult

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

@@ -58,6 +58,8 @@ module.exports = {
   '@smithy/core': () => require('../aws-sdk'),
   '@smithy/smithy-client': () => require('../aws-sdk'),
   '@vitest/runner': { esmFirst: true, fn: () => require('../vitest') },
+  '@wdio/cli': { esmFirst: true, fn: () => require('../webdriverio') },
+  '@wdio/local-runner': { esmFirst: true, fn: () => require('../webdriverio') },
   aerospike: () => require('../aerospike'),
   ai: () => require('../ai'),
   amqp10: () => require('../amqp10'),

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

@@ -57,19 +57,23 @@ const alreadyLoggedIncompatibleIntegrations = new Set()
 // Always disable prefixed and unprefixed node modules if one is disabled.
 if (disabledInstrumentations.size) {
   const builtinsSet = new Set(builtinModules)
+  const disabledBuiltinCounterparts = []
   for (const name of disabledInstrumentations) {
     const hasPrefix = name.startsWith('node:')
     if (hasPrefix || builtinsSet.has(name)) {
       if (hasPrefix) {
         const unprefixedName = name.slice(5)
         if (!disabledInstrumentations.has(unprefixedName)) {
-          disabledInstrumentations.add(unprefixedName)
+          disabledBuiltinCounterparts.push(unprefixedName)
         }
       } else if (!disabledInstrumentations.has(`node:${name}`)) {
-        disabledInstrumentations.add(`node:${name}`)
+        disabledBuiltinCounterparts.push(`node:${name}`)
       }
     }
   }
+  for (const name of disabledBuiltinCounterparts) {
+    disabledInstrumentations.add(name)
+  }
   builtinsSet.clear()
 }
 
@@ -163,7 +167,9 @@ function logAbortedIntegrations () {
   for (const [nameVersion, success] of instrumentedIntegrationsSuccess) {
     // Only ever log a single version of an integration, even if it is loaded later.
     if (!success && !alreadyLoggedIncompatibleIntegrations.has(nameVersion)) {
-      const [name, version] = nameVersion.split('@')
+      const lastAtPosition = nameVersion.lastIndexOf('@')
+      const name = nameVersion.slice(0, lastAtPosition)
+      const version = nameVersion.slice(lastAtPosition + 1)
       telemetry('abort.integration', [
         `integration:${name}`,
         `integration_version:${version}`,

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

@@ -39,6 +39,7 @@ for (const matcher of [matcherCjs, matcherEsm]) {
 
 // Keep the marker split: source-map scanners can read a contiguous token in
 // string literals as this file's own inline map.
+// eslint-disable-next-line unicorn/no-useless-concat -- Keep the source-map marker non-contiguous.
 const SOURCE_MAP_PREFIX = '//# sourceMapping' + 'URL=data:application/json;base64,'
 
 function rewrite (content, filename, format) {

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

@@ -12,5 +12,6 @@ module.exports = [
   ...require('./modelcontextprotocol-sdk'),
   ...require('./openai-agents'),
   ...require('./playwright'),
+  ...require('./webdriverio'),
   ...require('./aws-durable-execution-sdk-js'),
 ]

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

@@ -0,0 +1,57 @@
+'use strict'
+
+module.exports = [
+  {
+    module: {
+      name: '@wdio/cli',
+      versionRange: '>=9.0.0',
+      filePath: 'build/index.js',
+    },
+    functionQuery: {
+      className: 'Launcher',
+      methodName: '_startInstance',
+      kind: 'Async',
+    },
+    channelName: 'Launcher_startInstance',
+  },
+  {
+    module: {
+      name: '@wdio/local-runner',
+      versionRange: '>=9.0.0',
+      filePath: 'build/index.js',
+    },
+    functionQuery: {
+      className: 'LocalRunner',
+      methodName: 'run',
+      kind: 'Async',
+    },
+    channelName: 'LocalRunner_run',
+  },
+  {
+    module: {
+      name: '@wdio/local-runner',
+      versionRange: '>=9.0.0',
+      filePath: 'build/index.js',
+    },
+    functionQuery: {
+      className: 'LocalRunner',
+      methodName: 'shutdown',
+      kind: 'Async',
+    },
+    channelName: 'LocalRunner_shutdown',
+  },
+  {
+    module: {
+      name: '@wdio/local-runner',
+      versionRange: '>=9.0.0',
+      filePath: 'build/index.js',
+    },
+    astQuery: 'VariableDeclarator[id.name="LocalRunner"] > ClassExpression > ClassBody > ' +
+      'MethodDefinition[key.name="shutdown"] ReturnStatement > ' +
+      'CallExpression[callee.object.name="promise"][callee.property.name="then"], ' +
+      'ClassDeclaration[id.name="LocalRunner"] > ClassBody > MethodDefinition[key.name="shutdown"] ReturnStatement > ' +
+      'CallExpression[callee.object.name="promise"][callee.property.name="then"]',
+    channelName: 'LocalRunner_shutdown',
+    transform: 'waitForAsyncEnd',
+  },
+]

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

@@ -17,8 +17,8 @@ const { parse, query } = require('./compiler')
 module.exports = { waitForAsyncEnd }
 
 /**
- * Injects a wait for `ctx.asyncEndPromise` into a generated `tracePromise`
- * wrapper's native-Promise fulfillment handler.
+ * Injects settlement-specific asyncEnd waits into a generated `tracePromise`
+ * wrapper's native-Promise handlers.
  *
  * @param {object} _state
  * @param {import('estree').CallExpression} node
@@ -26,36 +26,68 @@ module.exports = { waitForAsyncEnd }
  */
 function waitForAsyncEnd (_state, node) {
   const onFulfilled = node.arguments[0]
-  const statements = onFulfilled?.body?.body
+  const onRejected = node.arguments[1]
 
-  if (!statements || query(onFulfilled.body, '[id.name=__apm$asyncEndPromise]').length > 0) {
+  if (!onFulfilled?.body || !onRejected?.body) {
     return
   }
 
-  const returnIndex = statements.findIndex(statement =>
-    statement.type === 'ReturnStatement' && statement.argument
+  injectAsyncEndCallbackWait(onFulfilled.body, 'ReturnStatement', 'resolveCallback')
+  injectAsyncEndCallbackWait(onRejected.body, 'ThrowStatement', 'rejectCallback')
+}
+
+/**
+ * Injects a settlement-specific callback wait before an exit.
+ *
+ * @param {import('estree').BlockStatement} body
+ * @param {'ReturnStatement'|'ThrowStatement'} exitType
+ * @param {'resolveCallback'|'rejectCallback'} callbackProperty
+ * @returns {void}
+ */
+function injectAsyncEndCallbackWait (body, exitType, callbackProperty) {
+  const callbackVariable = `__apm$${callbackProperty}`
+  if (query(body, `[id.name=${callbackVariable}]`).length > 0) {
+    return
+  }
+
+  const exitIndex = body.body.findIndex(statement =>
+    statement.type === exitType && statement.argument
   )
 
-  // The generated fulfillment handler always ends in a return; a miss means the
+  // The generated settlement handlers always end in a return or throw; a miss means the
   // upstream template changed and the caller's try/catch falls back to the
   // unwrapped source.
-  assert(returnIndex !== -1, 'waitForAsyncEnd: no return statement to wait on')
+  assert(exitIndex !== -1, `waitForAsyncEnd: no ${exitType} to wait on`)
 
+  // This runs inside tracePromise's native-Promise settlement handler. The
+  // Promise adapts subscriber callback completion to that existing chain.
   const waitStatements = parse(`
     function wrapper () {
-      const __apm$asyncEndPromise = __apm$ctx.asyncEndPromise;
-      if (__apm$asyncEndPromise && typeof __apm$asyncEndPromise.then === 'function') {
-        return __apm$asyncEndPromise.then(() => __apm$result, () => __apm$result);
+      const ${callbackVariable} = __apm$ctx.${callbackProperty};
+      if (typeof ${callbackVariable} === 'function') {
+        return new Promise(${callbackVariable}).then(() => __apm$result, () => __apm$result);
       }
     }
   `).body[0].body.body
 
-  // Resolve to whatever the fulfillment handler returns (its return argument),
-  // so a subscriber that reassigned `__apm$ctx.result` in `asyncEnd` still wins.
-  const returnArgument = statements[returnIndex].argument
-  const { arguments: onSettled } = waitStatements[1].consequent.body[0].argument
-  onSettled[0].body = clone(returnArgument)
-  onSettled[1].body = clone(returnArgument)
+  const exitArgument = body.body[exitIndex].argument
+  const callbackIf = waitStatements[1]
+  const { arguments: onCallbackSettled } = callbackIf.consequent.body[0].argument
+
+  if (exitType === 'ThrowStatement') {
+    for (const handler of onCallbackSettled) {
+      handler.body = {
+        type: 'BlockStatement',
+        body: [{
+          type: 'ThrowStatement',
+          argument: clone(exitArgument),
+        }],
+      }
+    }
+  } else {
+    onCallbackSettled[0].body = clone(exitArgument)
+    onCallbackSettled[1].body = clone(exitArgument)
+  }
 
-  statements.splice(returnIndex, 0, ...waitStatements)
+  body.body.splice(exitIndex, 0, ...waitStatements)
 }

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

@@ -88,7 +88,7 @@ function collectRoutesFromRouter (router, prefix) {
 function normalizeRoutePaths (path) {
   if (path == null) return []
 
-  if (Array.isArray(path) === false) {
+  if (!Array.isArray(path)) {
     const normalized = normalizeRoutePath(path)
     return [normalized]
   }

package/packages/datadog-instrumentations/src/helpers/shared-utils.js

@@ -1,9 +1,48 @@
 'use strict'
 
+const { builtinModules } = require('node:module')
+
+/**
+ * @param {string} moduleName
+ */
+function stripNodePrefix (moduleName) {
+  return moduleName.startsWith('node:') ? moduleName.slice(5) : moduleName
+}
+
+const builtinModuleNames = new Set(builtinModules.map(stripNodePrefix))
+
+/**
+ * @param {string} moduleName
+ */
+function isNodeBuiltinModuleName (moduleName) {
+  return builtinModuleNames.has(stripNodePrefix(moduleName))
+}
+
+/**
+ * @param {string} moduleName
+ */
+function isBuiltinModuleName (moduleName) {
+  return moduleName === 'electron' || isNodeBuiltinModuleName(moduleName)
+}
+
+/**
+ * @param {string} moduleName
+ */
+function normalizeModuleName (moduleName) {
+  const stripped = stripNodePrefix(moduleName)
+  return builtinModuleNames.has(stripped) ? stripped : moduleName
+}
+
+/**
+ * @param {string} moduleName
+ */
 function isRelativeRequire (moduleName) {
   return moduleName.startsWith('./') || moduleName.startsWith('../')
 }
 
 module.exports = {
+  isBuiltinModuleName,
+  isNodeBuiltinModuleName,
   isRelativeRequire,
+  normalizeModuleName,
 }

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

@@ -89,9 +89,7 @@ function setupResponseInstrumentation (ctx, res) {
   const collectChunk = chunk => {
     if (!bodyChunks || !chunk) return
 
-    if (typeof chunk === 'string') {
-      bodyChunks.push(chunk)
-    } else if (Buffer.isBuffer(chunk)) {
+    if (typeof chunk === 'string' || Buffer.isBuffer(chunk)) {
       bodyChunks.push(chunk)
     } else {
       // Handle Uint8Array or other array-like types

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

@@ -96,7 +96,7 @@ const DD_JEST_HANDLE_TEST_EVENT_WRAPPED = Symbol('dd-trace:jest:handle-test-even
 const DD_JEST_HANDLE_TEST_EVENT_DATADOG = Symbol('dd-trace:jest:handle-test-event-datadog')
 const DD_JEST_CONCURRENT_TEST_ORIGINAL = Symbol('dd-trace:jest:concurrent-test-original')
 const isJestWorker = !!getEnvironmentVariable('JEST_WORKER_ID')
-const jestSessionState = globalThis[JEST_SESSION_STATE] || (globalThis[JEST_SESSION_STATE] = {})
+const jestSessionState = (globalThis[JEST_SESSION_STATE] ||= {})
 
 // https://github.com/jestjs/jest/blob/41f842a46bb2691f828c3a5f27fc1d6290495b82/packages/jest-circus/src/types.ts#L9C8-L9C54
 const RETRY_TIMES = Symbol.for('RETRY_TIMES')
@@ -1192,9 +1192,9 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         ctx.testParameters = testParameters
         ctx.frameworkVersion = jestVersion
         ctx.isNew = isNewTest
-        ctx.isEfdRetry = ctx.isEfdRetry || numEfdRetry > 0
+        ctx.isEfdRetry ||= numEfdRetry > 0
         ctx.isAttemptToFix = isAttemptToFix
-        ctx.isAttemptToFixRetry = ctx.isAttemptToFixRetry || numOfAttemptsToFixRetries > 0
+        ctx.isAttemptToFixRetry ||= numOfAttemptsToFixRetries > 0
         ctx.isJestRetry = isJestRetry
         ctx.isDisabled = isDisabled
         ctx.isQuarantined = isQuarantined
@@ -1361,8 +1361,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             }
           }
         }
-      }
-      if (event.name === 'test_done') {
+      } else if (event.name === 'test_done') {
         const originalError = event.test?.errors?.[0]
         let status = 'pass'
         if (event.test.errors && event.test.errors.length) {
@@ -1565,8 +1564,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         if (ctx.concurrentTestState) {
           ctx.currentStore = undefined
         }
-      }
-      if (event.name === 'run_finish') {
+      } else if (event.name === 'run_finish') {
         for (const [test, errors] of atrSuppressedErrors) {
           // Do not restore errors for non-ATF quarantined tests — they should stay suppressed
           // so Jest doesn't see the failure (prevents --bail from stopping the run).
@@ -1595,8 +1593,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         attemptToFixRetriedTestsStatuses.clear()
         testsToBeRetried.clear()
         testSuiteDatadogEnvironments.delete(this.testSuiteAbsolutePath)
-      }
-      if (event.name === 'test_skip' || event.name === 'test_todo') {
+      } else if (event.name === 'test_skip' || event.name === 'test_todo') {
         const testName = getJestTestName(event.test)
         testSkippedCh.publish({
           test: {
@@ -2298,12 +2295,11 @@ function getCliWrapper (isNewJestVersion) {
           } = skippableSuitesResponse || await getChannelPromise(skippableSuitesCh)
           if (err) {
             skippableSuitesCoverage = {}
-            skippedSuitesCoverage = {}
           } else {
             skippableSuites = receivedSkippableSuites
             skippableSuitesCoverage = receivedSkippableSuitesCoverage || {}
-            skippedSuitesCoverage = {}
           }
+          skippedSuitesCoverage = {}
         } catch (err) {
           log.error('Jest test-suite skippable error', err)
         }
@@ -3037,9 +3033,7 @@ function wrapJestObject (jestObject, suiteFilePath) {
 
   shimmer.wrap(jestObject, 'mock', mock => function (moduleName) {
     // If the library is mocked with `jest.mock`, we don't want to bypass jest's own require engine
-    if (LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.has(moduleName)) {
-      LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.delete(moduleName)
-    }
+    LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.delete(moduleName)
     recordMockedFile(suiteFilePath, moduleName)
     return mock.apply(this, arguments)
   })

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

@@ -41,11 +41,9 @@ addHook({
 }, (Suite) => {
   shimmer.wrap(Suite.prototype, 'addTest', addTest => function (test) {
     const callSites = getCallSites()
-    let startLine
     const testCallSite = callSites.find(site => site.getFileName() === test.file)
     if (testCallSite) {
-      startLine = testCallSite.getLineNumber()
-      testToStartLine.set(test, startLine)
+      testToStartLine.set(test, testCallSite.getLineNumber())
     }
     return addTest.apply(this, arguments)
   })