dd-trace 5.54.0 → 5.55.0

package/ci/cypress/plugin.js

@@ -1,3 +1,11 @@
+const { NODE_MAJOR } = require('../../version')
+
+// These polyfills are here because cypress@6.7.0, which we still support for v5, runs its plugin code
+// with Node.js@12.
+if (NODE_MAJOR < 18) {
+  require('./polyfills')
+}
+
 require('../init')
 
 module.exports = require('../../packages/datadog-plugin-cypress/src/plugin')

package/ci/cypress/polyfills.js

@@ -0,0 +1,23 @@
+if (!Object.hasOwn) {
+  Object.defineProperty(Object, 'hasOwn', {
+    // eslint-disable-next-line prefer-object-has-own
+    value: (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop),
+    writable: true,
+    configurable: true,
+  })
+}
+
+if (!Array.prototype.at) {
+  // eslint-disable-next-line no-extend-native
+  Object.defineProperty(Array.prototype, 'at', {
+    value: function (n) {
+      const len = this.length
+      if (len === 0) return
+      let index = Math.trunc(n)
+      if (index < 0) index += len
+      return (index < 0 || index >= len) ? undefined : this[index]
+    },
+    writable: true,
+    configurable: true
+  })
+}

package/ci/init.js

@@ -2,12 +2,13 @@
 const tracer = require('../packages/dd-trace')
 const { isTrue, isFalse } = require('../packages/dd-trace/src/util')
 const log = require('../packages/dd-trace/src/log')
+const { getEnvironmentVariable } = require('../packages/dd-trace/src/config-helper')
 
-const isJestWorker = !!process.env.JEST_WORKER_ID
-const isCucumberWorker = !!process.env.CUCUMBER_WORKER_ID
-const isMochaWorker = !!process.env.MOCHA_WORKER_ID
+const isJestWorker = !!getEnvironmentVariable('JEST_WORKER_ID')
+const isCucumberWorker = !!getEnvironmentVariable('CUCUMBER_WORKER_ID')
+const isMochaWorker = !!getEnvironmentVariable('MOCHA_WORKER_ID')
 
-const isPlaywrightWorker = !!process.env.DD_PLAYWRIGHT_WORKER
+const isPlaywrightWorker = !!getEnvironmentVariable('DD_PLAYWRIGHT_WORKER')
 
 const packageManagers = [
   'npm',
@@ -25,17 +26,17 @@ const options = {
   flushInterval: isJestWorker ? 0 : 5000
 }
 
-let shouldInit = !isFalse(process.env.DD_CIVISIBILITY_ENABLED)
+let shouldInit = !isFalse(getEnvironmentVariable('DD_CIVISIBILITY_ENABLED'))
 
 if (isPackageManager()) {
   log.debug('dd-trace is not initialized in a package manager.')
   shouldInit = false
 }
 
-const isAgentlessEnabled = isTrue(process.env.DD_CIVISIBILITY_AGENTLESS_ENABLED)
+const isAgentlessEnabled = isTrue(getEnvironmentVariable('DD_CIVISIBILITY_AGENTLESS_ENABLED'))
 
 if (isAgentlessEnabled) {
-  if (process.env.DATADOG_API_KEY || process.env.DD_API_KEY) {
+  if (getEnvironmentVariable('DD_API_KEY')) {
     options.experimental = {
       exporter: 'datadog'
     }

package/initialize.mjs

@@ -17,7 +17,7 @@ import { fileURLToPath } from 'node:url'
 import {
   load as origLoad,
   resolve as origResolve,
-  getSource as origGetSource
+  getSource as origGetSource,
 } from 'import-in-the-middle/hook.mjs'
 
 let hasInsertedInit = false
@@ -31,7 +31,7 @@ ${result.source}`
   return result
 }
 
-const [NODE_MAJOR, NODE_MINOR] = process.versions.node.split('.').map(x => +x)
+const [NODE_MAJOR, NODE_MINOR] = process.versions.node.split('.').map(Number)
 
 const brokenLoaders = NODE_MAJOR === 18 && NODE_MINOR === 0
 const iitmExclusions = [/langsmith/, /openai\/_shims/, /openai\/resources\/chat\/completions\/messages/]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.54.0",
+  "version": "5.55.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -26,8 +26,8 @@
     "test:debugger:ci": "nyc --no-clean --include 'packages/dd-trace/src/debugger/**/*.js' -- npm run test:debugger",
     "test:trace:core": "tap packages/dd-trace/test/*.spec.js \"packages/dd-trace/test/{ci-visibility,datastreams,encode,exporters,opentelemetry,opentracing,plugins,service-naming,standalone,telemetry}/**/*.spec.js\"",
     "test:trace:core:ci": "npm run test:trace:core -- --coverage --nyc-arg=--include=\"packages/dd-trace/src/**/*.js\"",
-    "test:instrumentations": "mocha -r 'packages/dd-trace/test/setup/mocha.js' 'packages/datadog-instrumentations/test/**/*.spec.js'",
-    "test:instrumentations:ci": "nyc --no-clean --include 'packages/datadog-instrumentations/src/**/*.js' -- npm run test:instrumentations",
+    "test:instrumentations": "mocha -r 'packages/dd-trace/test/setup/mocha.js' \"packages/datadog-instrumentations/test/@($(echo $PLUGINS)).spec.js\"",
+    "test:instrumentations:ci": "yarn services && nyc --no-clean --include \"packages/datadog-instrumentations/src/@($(echo $PLUGINS)).js\" --include \"packages/datadog-instrumentations/src/@($(echo $PLUGINS))/**/*.js\" -- npm run test:instrumentations",
     "test:instrumentations:misc": "mocha -r 'packages/dd-trace/test/setup/mocha.js' 'packages/datadog-instrumentations/test/*/**/*.spec.js'",
     "test:instrumentations:misc:ci": "nyc --no-clean --include 'packages/datadog-instrumentations/src/**/*.js' -- npm run test:instrumentations:misc",
     "test:core": "tap \"packages/datadog-core/test/**/*.spec.js\"",
@@ -38,8 +38,8 @@
     "test:llmobs:sdk:ci": "nyc --no-clean --include \"packages/dd-trace/src/llmobs/**/*.js\" -- npm run test:llmobs:sdk",
     "test:llmobs:plugins": "mocha -r \"packages/dd-trace/test/setup/mocha.js\" \"packages/dd-trace/test/llmobs/plugins/@($(echo $PLUGINS))/*.spec.js\"",
     "test:llmobs:plugins:ci": "yarn services && nyc --no-clean --include \"packages/dd-trace/src/llmobs/**/*.js\" -- npm run test:llmobs:plugins",
-    "test:plugins": "mocha -r \"packages/dd-trace/test/setup/mocha.js\" \"packages/datadog-instrumentations/test/@($(echo $PLUGINS)).spec.js\" \"packages/datadog-plugin-@($(echo $PLUGINS))/test/**/*.spec.js\"",
-    "test:plugins:ci": "yarn services && nyc --no-clean --include \"packages/datadog-instrumentations/src/@($(echo $PLUGINS)).js\" --include \"packages/datadog-instrumentations/src/@($(echo $PLUGINS))/**/*.js\" --include \"packages/datadog-plugin-@($(echo $PLUGINS))/src/**/*.js\" -- npm run test:plugins",
+    "test:plugins": "mocha -r \"packages/dd-trace/test/setup/mocha.js\" \"packages/datadog-plugin-@($(echo $PLUGINS))/test/**/*.spec.js\"",
+    "test:plugins:ci": "yarn services && nyc --no-clean --include \"packages/datadog-plugin-@($(echo $PLUGINS))/src/**/*.js\" -- npm run test:plugins",
     "test:plugins:upstream": "node ./packages/dd-trace/test/plugins/suite.js",
     "test:profiler": "tap \"packages/dd-trace/test/profiling/**/*.spec.js\"",
     "test:profiler:ci": "npm run test:profiler -- --coverage --nyc-arg=--include=\"packages/dd-trace/src/profiling/**/*.js\"",
@@ -143,7 +143,7 @@
     "graphql": "0.13.2",
     "jszip": "^3.10.1",
     "mocha": "^10.8.2",
-    "multer": "^2.0.0",
+    "multer": "^2.0.1",
     "nock": "^11.9.1",
     "nyc": "^15.1.0",
     "proxyquire": "^1.8.0",

package/packages/datadog-code-origin/index.js

@@ -2,22 +2,40 @@
 
 const { getUserLandFrames } = require('../dd-trace/src/plugins/util/stacktrace')
 
-const limit = Number(process.env._DD_CODE_ORIGIN_MAX_USER_FRAMES) || 8
+const ENTRY_SPAN_STACK_FRAMES_LIMIT = 1
+const EXIT_SPAN_STACK_FRAMES_LIMIT = Number(process.env._DD_CODE_ORIGIN_FOR_SPANS_EXIT_SPAN_MAX_USER_FRAMES) || 8
 
 module.exports = {
   entryTags,
   exitTags
 }
 
+/**
+ * @param {Function} topOfStackFunc - A function present in the current stack, above which no stack frames should be
+ *   collected.
+ * @returns {Record<string, string>}
+ */
 function entryTags (topOfStackFunc) {
-  return tag('entry', topOfStackFunc)
+  return tag('entry', topOfStackFunc, ENTRY_SPAN_STACK_FRAMES_LIMIT)
 }
 
+/**
+ * @param {Function} topOfStackFunc - A function present in the current stack, above which no stack frames should be
+ *   collected.
+ * @returns {Record<string, string>}
+ */
 function exitTags (topOfStackFunc) {
-  return tag('exit', topOfStackFunc)
+  return tag('exit', topOfStackFunc, EXIT_SPAN_STACK_FRAMES_LIMIT)
 }
 
-function tag (type, topOfStackFunc) {
+/**
+ * @param {'entry'|'exit'} type - The type of code origin.
+ * @param {Function} topOfStackFunc - A function present in the current stack, above which no stack frames should be
+ *   collected.
+ * @param {number} limit - The maximum number of stack frames to include in the tags.
+ * @returns {Record<string, string>}
+ */
+function tag (type, topOfStackFunc, limit) {
   const frames = getUserLandFrames(topOfStackFunc, limit)
   const tags = {
     '_dd.code_origin.type': type

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

@@ -7,8 +7,8 @@ module.exports = function kebabcase (str) {
 
   return str
     .trim()
-    .replace(/([a-z])([A-Z])/g, '$1-$2') // Convert camelCase to kebab-case
-    .replace(/[\s_]+/g, '-') // Replace spaces and underscores with a single dash
-    .replace(/^-+|-+$/g, '') // Trim leading and trailing dashes
+    .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()
 }

package/packages/datadog-instrumentations/src/cassandra-driver.js

@@ -34,13 +34,12 @@ addHook({ name: 'cassandra-driver', versions: ['>=3.0.0'] }, cassandra => {
         const res = batch.apply(this, arguments)
         if (typeof res === 'function' || !res) {
           return wrapCallback(finishCh, errorCh, asyncResource, res)
-        } else {
-          const promiseAsyncResource = new AsyncResource('bound-anonymous-fn')
-          return res.then(
-            promiseAsyncResource.bind(() => finish(finishCh, errorCh)),
-            promiseAsyncResource.bind(err => finish(finishCh, errorCh, err))
-          )
         }
+        const promiseAsyncResource = new AsyncResource('bound-anonymous-fn')
+        return res.then(
+          promiseAsyncResource.bind(() => finish(finishCh, errorCh)),
+          promiseAsyncResource.bind(err => finish(finishCh, errorCh, err))
+        )
       } catch (e) {
         finish(finishCh, errorCh, e)
         throw e

package/packages/datadog-instrumentations/src/confluentinc-kafka-javascript.js

@@ -379,10 +379,9 @@ function wrapKafkaCallback (callback, { startCh, commitCh, finishCh, errorCh },
               finishCh.publish(ctx)
               throw err
             })
-        } else {
-          finishCh.publish(ctx)
-          return result
         }
+        finishCh.publish(ctx)
+        return result
       } catch (error) {
         ctx.error = error
         errorCh.publish(ctx)

package/packages/datadog-instrumentations/src/cookie-parser.js

@@ -10,7 +10,7 @@ function publishRequestCookieAndNext (req, res, next) {
     if (cookieParserReadCh.hasSubscribers && req) {
       const abortController = new AbortController()
 
-      const mergedCookies = Object.assign({}, req.cookies, req.signedCookies)
+      const mergedCookies = { ...req.cookies, ...req.signedCookies }
 
       cookieParserReadCh.publish({ req, res, abortController, cookies: mergedCookies })
 

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

@@ -43,14 +43,11 @@ function wrapMaybeInvoke (_maybeInvoke) {
 
 function wrapQuery (query) {
   const wrapped = function (q, params, callback) {
-    callback = AsyncResource.bind(arguments[arguments.length - 1])
-
-    if (typeof callback === 'function') {
-      arguments[arguments.length - 1] = callback
+    if (typeof arguments[arguments.length - 1] === 'function') {
+      arguments[arguments.length - 1] = AsyncResource.bind(arguments[arguments.length - 1])
     }
 
-    const res = query.apply(this, arguments)
-    return res
+    return query.apply(this, arguments)
   }
   return wrapped
 }

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

@@ -1,9 +1,10 @@
 'use strict'
 const { createCoverageMap } = require('istanbul-lib-coverage')
 
-const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+const { addHook, channel } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 const log = require('../../dd-trace/src/log')
+const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
 
 const testStartCh = channel('ci:cucumber:test:start')
 const testRetryCh = channel('ci:cucumber:test:retry')
@@ -63,8 +64,6 @@ let eventDataCollector = null
 let pickleByFile = {}
 const pickleResultByFile = {}
 
-const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
-
 let skippableSuites = []
 let itrCorrelationId = ''
 let isForcedToRun = false
@@ -160,9 +159,7 @@ function getErrorFromCucumberResult (cucumberResult) {
 
 function getChannelPromise (channelToPublishTo, isParallel = false) {
   return new Promise(resolve => {
-    sessionAsyncResource.runInAsyncScope(() => {
-      channelToPublishTo.publish({ onDone: resolve, isParallel })
-    })
+    channelToPublishTo.publish({ onDone: resolve, isParallel })
   })
 }
 
@@ -247,7 +244,7 @@ function wrapRun (pl, isLatestVersion) {
       testName: this.pickle.name,
       testFileAbsolutePath,
       testSourceLine,
-      isParallel: !!process.env.CUCUMBER_WORKER_ID
+      isParallel: !!getEnvironmentVariable('CUCUMBER_WORKER_ID')
     }
     const ctx = testStartPayload
     numAttemptToCtx.set(numAttempt, ctx)
@@ -540,15 +537,13 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
     }
 
     const processArgv = process.argv.slice(2).join(' ')
-    const command = process.env.npm_lifecycle_script || `cucumber-js ${processArgv}`
+    const command = getEnvironmentVariable('npm_lifecycle_script') || `cucumber-js ${processArgv}`
 
     if (isFlakyTestRetriesEnabled && !options.retry && numTestRetries > 0) {
       options.retry = numTestRetries
     }
 
-    sessionAsyncResource.runInAsyncScope(() => {
-      sessionStartCh.publish({ command, frameworkVersion })
-    })
+    sessionStartCh.publish({ command, frameworkVersion })
 
     if (!errorSkippableRequest && skippedSuites.length) {
       itrSkippedSuitesCh.publish({ skippedSuites, frameworkVersion })
@@ -576,19 +571,17 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
       global.__coverage__ = fromCoverageMapToCoverage(originalCoverageMap)
     }
 
-    sessionAsyncResource.runInAsyncScope(() => {
-      sessionFinishCh.publish({
-        status: success ? 'pass' : 'fail',
-        isSuitesSkipped,
-        testCodeCoverageLinesTotal,
-        numSkippedSuites: skippedSuites.length,
-        hasUnskippableSuites: isUnskippable,
-        hasForcedToRunSuites: isForcedToRun,
-        isEarlyFlakeDetectionEnabled,
-        isEarlyFlakeDetectionFaulty,
-        isTestManagementTestsEnabled,
-        isParallel
-      })
+    sessionFinishCh.publish({
+      status: success ? 'pass' : 'fail',
+      isSuitesSkipped,
+      testCodeCoverageLinesTotal,
+      numSkippedSuites: skippedSuites.length,
+      hasUnskippableSuites: isUnskippable,
+      hasForcedToRunSuites: isForcedToRun,
+      isEarlyFlakeDetectionEnabled,
+      isEarlyFlakeDetectionFaulty,
+      isTestManagementTestsEnabled,
+      isParallel
     })
     eventDataCollector = null
     return success
@@ -676,6 +669,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     if (isAttemptToFix && lastTestStatus !== 'skip') {
       for (let retryIndex = 0; retryIndex < testManagementAttemptToFixRetries; retryIndex++) {
         numRetriesByPickleId.set(pickle.id, retryIndex + 1)
+        // eslint-disable-next-line no-await-in-loop
         runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
       }
     }
@@ -684,6 +678,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     if (isEarlyFlakeDetectionEnabled && lastTestStatus !== 'skip' && (isNew || isModified)) {
       for (let retryIndex = 0; retryIndex < earlyFlakeDetectionNumRetries; retryIndex++) {
         numRetriesByPickleId.set(pickle.id, retryIndex + 1)
+        // eslint-disable-next-line no-await-in-loop
         runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
       }
     }
@@ -758,9 +753,7 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
     if (Array.isArray(message)) {
       const [messageCode, payload] = message
       if (messageCode === CUCUMBER_WORKER_TRACE_PAYLOAD_CODE) {
-        sessionAsyncResource.runInAsyncScope(() => {
-          workerReportTraceCh.publish(payload)
-        })
+        workerReportTraceCh.publish(payload)
         return
       }
     }
@@ -932,7 +925,7 @@ addHook({
   shimmer.wrap(
     workerPackage.Worker.prototype,
     'runTestCase',
-    runTestCase => getWrappedRunTestCase(runTestCase, true, !!process.env.CUCUMBER_WORKER_ID)
+    runTestCase => getWrappedRunTestCase(runTestCase, true, !!getEnvironmentVariable('CUCUMBER_WORKER_ID'))
   )
   return workerPackage
 })

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

@@ -39,12 +39,12 @@ addHook({ name: names }, dns => {
 })
 
 function patchResolveShorthands (prototype) {
-  Object.keys(rrtypes)
-    .filter(method => !!prototype[method])
-    .forEach(method => {
+  for (const method of Object.keys(rrtypes)) {
+    if (prototype[method]) {
       rrtypeMap.set(prototype[method], rrtypes[method])
       shimmer.wrap(prototype, method, fn => wrap('apm:dns:resolve', fn, 2, rrtypes[method]))
-    })
+    }
+  }
 }
 
 function wrap (prefix, fn, expectedArgs, rrtype) {

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

@@ -91,18 +91,17 @@ function createWrapRequest (name) {
               return cb.apply(null, arguments)
             }))
             return request.apply(this, arguments)
+          }
+          const promise = request.apply(this, arguments)
+          if (promise && typeof promise.then === 'function') {
+            const onResolve = asyncResource.bind(() => finish(params))
+            const onReject = asyncResource.bind(e => finish(params, e))
+
+            promise.then(onResolve, onReject)
           } else {
-            const promise = request.apply(this, arguments)
-            if (promise && typeof promise.then === 'function') {
-              const onResolve = asyncResource.bind(() => finish(params))
-              const onReject = asyncResource.bind(e => finish(params, e))
-
-              promise.then(onResolve, onReject)
-            } else {
-              finish(params)
-            }
-            return promise
+            finish(params)
           }
+          return promise
         } catch (err) {
           err.stack // trigger getting the stack at the original throwing point
           errorCh.publish(err)

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

@@ -59,21 +59,19 @@ function wrapAddHook (addHook) {
               return parsingResource.runInAsyncScope(() => {
                 return done.apply(this, arguments)
               })
-            } else {
-              return done.apply(this, arguments)
             }
+            return done.apply(this, arguments)
           }
 
           return fn.apply(this, arguments)
-        } else {
-          const promise = fn.apply(this, arguments)
-
-          if (promise && typeof promise.catch === 'function') {
-            return promise.catch(err => publishError(err, req))
-          }
+        }
+        const promise = fn.apply(this, arguments)
 
-          return promise
+        if (promise && typeof promise.catch === 'function') {
+          return promise.catch(err => publishError(err, req))
         }
+
+        return promise
       } catch (e) {
         throw publishError(e, req)
       }

package/packages/datadog-instrumentations/src/google-cloud-pubsub.js

@@ -79,21 +79,20 @@ function wrapMethod (method) {
         })
 
         return method.apply(this, arguments)
-      } else {
-        return method.apply(this, arguments)
-          .then(
-            response => {
-              requestFinishCh.publish(ctx)
-              return response
-            },
-            error => {
-              ctx.error = error
-              requestErrorCh.publish(ctx)
-              requestFinishCh.publish(ctx)
-              throw error
-            }
-          )
       }
+      return method.apply(this, arguments)
+        .then(
+          response => {
+            requestFinishCh.publish(ctx)
+            return response
+          },
+          error => {
+            ctx.error = error
+            requestErrorCh.publish(ctx)
+            requestFinishCh.publish(ctx)
+            throw error
+          }
+        )
     })
   }
 }
@@ -133,9 +132,8 @@ addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'], file: 'build/src/le
     if (receiveStartCh.hasSubscribers) {
       ctx.message = message
       return receiveStartCh.runStores(ctx, dispense, this, ...arguments)
-    } else {
-      return dispense.apply(this, arguments)
     }
+    return dispense.apply(this, arguments)
   })
 
   shimmer.wrap(LeaseManager.prototype, 'remove', remove => function (message) {

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

@@ -42,7 +42,10 @@ function wrapExt (ext) {
     if (events !== null && typeof events === 'object') {
       arguments[0] = wrapEvents(events)
     } else {
-      arguments[1] = wrapExtension(method)
+      // The method should never be an array. The check is done as a safe guard
+      // during a refactoring where it was unclear if this would be possible or
+      // not.
+      arguments[1] = Array.isArray(method) ? method.map(wrapHandler) : [wrapHandler(method)]
     }
 
     return ext.apply(this, arguments)
@@ -75,17 +78,13 @@ function wrapRebuild (rebuild) {
   }
 }
 
-function wrapExtension (method) {
-  return [].concat(method).map(wrapHandler)
-}
+function wrapEvents (events, flat = false) {
+  const eventsArray = Array.isArray(events) ? events : [events]
 
-function wrapEvents (events) {
-  return [].concat(events).map(event => {
-    if (!event || !event.method) return event
+  return eventsArray.map(event => {
+    if (!event?.method) return event
 
-    return Object.assign({}, event, {
-      method: wrapExtension(event.method)
-    })
+    return { ...event, method: wrapHandler(event.method) }
   })
 }
 
@@ -93,7 +92,7 @@ function wrapHandler (handler) {
   if (typeof handler !== 'function') return handler
 
   return shimmer.wrapFunction(handler, handler => function (request, h) {
-    const req = request && request.raw && request.raw.req
+    const req = request?.raw?.req
 
     if (!req) return handler.apply(this, arguments)
 

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

@@ -16,12 +16,11 @@ exports.createWrapFetch = function createWrapFetch (Request, ch, onLoad) {
         const ctx = { req: input }
 
         return ch.tracePromise(() => fetch.call(this, input, init), ctx)
-      } else {
-        const req = new Request(input, init)
-        const ctx = { req }
-
-        return ch.tracePromise(() => fetch.call(this, req), ctx)
       }
+      const req = new Request(input, init)
+      const ctx = { req }
+
+      return ch.tracePromise(() => fetch.call(this, req), ctx)
     }
   }
 }

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

@@ -41,9 +41,8 @@ function Hook (modules, hookOptions, onrequire) {
     if (moduleExports && moduleExports.default) {
       moduleExports.default = safeHook(moduleExports.default, moduleName, moduleBaseDir)
       return moduleExports
-    } else {
-      return safeHook(moduleExports, moduleName, moduleBaseDir)
     }
+    return safeHook(moduleExports, moduleName, moduleBaseDir)
   })
 }
 

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

@@ -9,11 +9,14 @@ const log = require('../../../dd-trace/src/log')
 const checkRequireCache = require('./check-require-cache')
 const telemetry = require('../../../dd-trace/src/guardrails/telemetry')
 const { isInServerlessEnvironment } = require('../../../dd-trace/src/serverless')
+const { getEnvironmentVariables } = require('../../../dd-trace/src/config-helper')
+
+const envs = getEnvironmentVariables()
 
 const {
   DD_TRACE_DISABLED_INSTRUMENTATIONS = '',
   DD_TRACE_DEBUG = ''
-} = process.env
+} = envs
 
 const hooks = require('./hooks')
 const instrumentations = require('./instrumentations')
@@ -24,7 +27,7 @@ const disabledInstrumentations = new Set(
 )
 
 // Check for DD_TRACE_<INTEGRATION>_ENABLED environment variables
-for (const [key, value] of Object.entries(process.env)) {
+for (const [key, value] of Object.entries(envs)) {
   const match = key.match(/^DD_TRACE_(.+)_ENABLED$/)
   if (match && (value?.toLowerCase() === 'false' || value === '0')) {
     const integration = match[1].toLowerCase()
@@ -96,9 +99,7 @@ for (const packageName of names) {
       // That way it would also not be duplicated. The actual name being used has to be identified else wise.
       // Maybe it is also not important to know what name was actually used?
       hook[HOOK_SYMBOL] ??= new WeakSet()
-      let matchesFile = false
-
-      matchesFile = moduleName === fullFilename
+      let matchesFile = moduleName === fullFilename
 
       if (fullFilePattern) {
         // Some libraries include a hash in their filenames when installed,