dd-trace 5.73.0 → 5.74.0

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

@@ -0,0 +1,238 @@
+'use strict'
+
+const { channel } = require('./instrument')
+const shimmer = require('../../../datadog-shimmer')
+
+const routerMountPaths = new WeakMap() // to track mount paths for router instances
+const layerMatchers = new WeakMap() // to store layer matchers
+const appMountedRouters = new WeakSet() // to track routers mounted via app.use()
+
+const METHODS = [...require('http').METHODS.map(v => v.toLowerCase()), 'all']
+
+const routeAddedChannel = channel('apm:express:route:added')
+
+/**
+ * Joins two URL path segments into a single path
+ *
+ * @param {string} base - The base path
+ * @param {string} path - The path to append
+ * @returns {string|null} The joined path  or null if the combination would create an invalid route in Express
+ */
+function joinPath (base, path) {
+  if (!base || base === '/') return path || '/'
+  if (!path || path === '/') return base
+
+  // Express does not normalize paths without leading slashes.
+  // If either path doesn't start with '/', we should skip this combination.
+  // Allow only empty string for path
+  if (path !== '' && !path.startsWith('/')) return null
+  if (!base.startsWith('/')) return null
+
+  // Handle duplicate slashes when base ends with / and path starts with /
+  if (base.endsWith('/') && path.startsWith('/')) {
+    return base + path.slice(1)
+  }
+
+  return base + path
+}
+
+// Normalize route definitions coming from Express into a string representation
+function normalizeRoutePath (path) {
+  if (path == null) return null
+  if (typeof path === 'string') return path
+  if (path instanceof RegExp) return path.toString()
+
+  return String(path)
+}
+
+// Recursively publish every route reachable from the router.
+function collectRoutesFromRouter (router, prefix) {
+  if (!router?.stack?.length) return
+
+  for (const layer of router.stack) {
+    if (layer.route) {
+      // This layer has a direct route
+      const route = layer.route
+
+      const fullPaths = getRouteFullPaths(route, prefix)
+
+      for (const fullPath of fullPaths) {
+        for (const [method, enabled] of Object.entries(route.methods || {})) {
+          if (!enabled) continue
+          routeAddedChannel.publish({
+            method: normalizeMethodName(method),
+            path: fullPath
+          })
+        }
+      }
+    } else if (layer.handle?.stack?.length) {
+      // This layer contains a nested router
+      // Extract mount path from layer
+      const mountPath = typeof layer.path === 'string'
+        ? layer.path
+        : getLayerMatchers(layer)?.[0]?.path || ''
+
+      const nestedPrefix = joinPath(prefix, mountPath)
+      if (nestedPrefix === null) continue
+
+      // Set the mount path for the nested router
+      setRouterMountPath(layer.handle, nestedPrefix)
+      markAppMounted(layer.handle)
+      // Recursively collect from nested routers
+      collectRoutesFromRouter(layer.handle, nestedPrefix)
+    }
+  }
+}
+
+// Flatten any route definition into an array of normalized path strings.
+function normalizeRoutePaths (path) {
+  if (path == null) return []
+
+  if (Array.isArray(path) === false) {
+    const normalized = normalizeRoutePath(path)
+    return [normalized]
+  }
+
+  const paths = path.flat(Infinity)
+  const result = []
+  for (const _path of paths) {
+    const normalized = normalizeRoutePath(_path)
+    if (normalized !== null) {
+      result.push(normalized)
+    }
+  }
+
+  return result
+}
+
+function setRouterMountPath (router, mountPath) {
+  if (!router || typeof mountPath !== 'string') return
+  const existing = routerMountPaths.get(router)
+  if (existing) {
+    existing.add(mountPath)
+  } else {
+    routerMountPaths.set(router, new Set([mountPath]))
+  }
+}
+
+function getRouterMountPaths (router) {
+  const paths = routerMountPaths.get(router)
+  if (!paths) return []
+  return [...paths]
+}
+
+function setLayerMatchers (layer, matchers) {
+  layerMatchers.set(layer, matchers)
+}
+
+function getLayerMatchers (layer) {
+  return layerMatchers.get(layer)
+}
+
+function normalizeMethodName (method) {
+  return method === '_all' || method === 'all' ? '*' : method
+}
+
+function getRouteFullPaths (route, prefix) {
+  if (!route) return []
+
+  const routePaths = normalizeRoutePaths(route.path)
+  const pathsToPublish = routePaths.length ? routePaths : ['']
+
+  return pathsToPublish
+    .map(routePath => joinPath(prefix, routePath))
+    .filter(path => path !== null) // Filter out invalid path combinations
+}
+
+function markAppMounted (router) {
+  if (router) appMountedRouters.add(router)
+}
+
+function isAppMounted (router) {
+  return appMountedRouters.has(router)
+}
+
+/**
+ * Normalise the optional mount argument provided to app.use()/router.use().
+ * Express accepts strings, regex, arrays (possibly nested), or
+ * no mount path at all; this helper returns the flattened set of paths along
+ * with the index where actual middleware arguments start.
+ */
+function extractMountPaths (path) {
+  const hasMount = typeof path === 'string' || path instanceof RegExp || Array.isArray(path)
+
+  if (!hasMount) {
+    return { mountPaths: ['/'], startIdx: 0 }
+  }
+
+  const paths = normalizeRoutePaths(path)
+  return {
+    mountPaths: paths.length ? paths : ['/'],
+    startIdx: 1
+  }
+}
+
+/**
+ * Detect cycle router graphs.
+ */
+function hasRouterCycle (router, stack = new Set()) {
+  if (!router?.stack?.length) return false
+  if (stack.has(router)) return true
+
+  stack.add(router)
+
+  for (const layer of router.stack) {
+    if (!layer?.route && layer?.handle?.stack?.length) {
+      const hasCycle = hasRouterCycle(layer.handle, stack)
+      if (hasCycle) {
+        return true
+      }
+    }
+  }
+
+  stack.delete(router)
+  return false
+}
+
+function wrapRouteMethodsAndPublish (route, paths, publish) {
+  if (!route || !paths.length) return
+
+  const filteredPaths = paths.filter(Boolean)
+  if (!filteredPaths.length) return
+
+  const uniquePaths = new Set(filteredPaths)
+
+  METHODS.forEach(method => {
+    if (typeof route[method] !== 'function') return
+
+    shimmer.wrap(route, method, (originalMethod) => function wrappedRouteMethod (...args) {
+      const normalizedMethod = normalizeMethodName(method)
+
+      for (const path of uniquePaths) {
+        publish({
+          method: normalizedMethod,
+          path
+        })
+      }
+
+      return originalMethod.apply(this, args)
+    })
+  })
+}
+
+module.exports = {
+  setRouterMountPath,
+  getRouterMountPaths,
+  joinPath,
+  setLayerMatchers,
+  getLayerMatchers,
+  markAppMounted,
+  isAppMounted,
+  normalizeRoutePath,
+  normalizeRoutePaths,
+  getRouteFullPaths,
+  wrapRouteMethodsAndPublish,
+  extractMountPaths,
+  hasRouterCycle,
+  collectRoutesFromRouter
+}

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

@@ -1335,7 +1335,7 @@ addHook({
       }
       const returnedValue = requireModuleOrMock.apply(this, arguments)
       if (process.exitCode === 1) {
-        if (this.loggedReferenceErrors.size > 0) {
+        if (this.loggedReferenceErrors?.size > 0) {
           const errorMessage = [...this.loggedReferenceErrors][0]
           testSuiteErrorCh.publish({
             errorMessage,
@@ -1427,6 +1427,7 @@ function enqueueWrapper (enqueue) {
       if (worker && !wrappedWorkers.has(worker)) {
         shimmer.wrap(worker._child, 'send', sendWrapper)
         shimmer.wrap(worker, '_onMessage', onMessageWrapper)
+        worker._child.removeAllListeners('message')
         worker._child.on('message', worker._onMessage.bind(worker))
         wrappedWorkers.add(worker)
       }

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

@@ -7,7 +7,8 @@ const shimmer = require('../../datadog-shimmer')
 const {
   parseAnnotations,
   getTestSuitePath,
-  PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE
+  PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE,
+  getIsFaultyEarlyFlakeDetection
 } = require('../../dd-trace/src/plugins/util/test')
 const log = require('../../dd-trace/src/log')
 const { DD_MAJOR } = require('../../../version')
@@ -52,6 +53,7 @@ let isKnownTestsEnabled = false
 let isEarlyFlakeDetectionEnabled = false
 let earlyFlakeDetectionNumRetries = 0
 let isEarlyFlakeDetectionFaulty = false
+let earlyFlakeDetectionFaultyThreshold = 0
 let isFlakyTestRetriesEnabled = false
 let flakyTestRetriesCount = 0
 let knownTests = {}
@@ -111,8 +113,10 @@ function deepCloneSuite (suite, filterTest, tags = []) {
       if (filterTest(entry)) {
         const copiedTest = entry._clone()
         tags.forEach(tag => {
-          if (tag) {
-            copiedTest[tag] = true
+          const resolvedTag = typeof tag === 'function' ? tag(entry) : tag
+
+          if (resolvedTag) {
+            copiedTest[resolvedTag] = true
           }
         })
         copy._addTest(copiedTest)
@@ -542,6 +546,7 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
         isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
         isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
         earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
+        earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
         isFlakyTestRetriesEnabled = libraryConfig.isFlakyTestRetriesEnabled
         flakyTestRetriesCount = libraryConfig.flakyTestRetriesCount
         isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
@@ -761,6 +766,30 @@ addHook({
   return suiteUtilsPackage
 })
 
+/**
+ * We could repeat the logic of `applyRepeatEachIndex` here, but it'd be more risky
+ * as playwright could change it at any time.
+ *
+ * `applyRepeatEachIndex` goes through all the tests in a suite and applies the "repeat" logic
+ * for a single repeat index.
+ *
+ * This means that the clone logic is cumbersome:
+ * - we grab the unique file suites that have new tests
+ * - we store its project suite
+ * - we clone each of these file suites for each repeat index
+ * - we execute `applyRepeatEachIndex` for each of these cloned file suites
+ * - we add the cloned file suites to the project suite
+ */
+function applyRetriesToTests (fileSuitesWithTestsToRetry, filterTest, tagsToApply, numRetries) {
+  for (const [fileSuite, projectSuite] of fileSuitesWithTestsToRetry.entries()) {
+    for (let repeatEachIndex = 1; repeatEachIndex <= numRetries; repeatEachIndex++) {
+      const copyFileSuite = deepCloneSuite(fileSuite, filterTest, tagsToApply)
+      applyRepeatEachIndex(projectSuite._fullProject, copyFileSuite, repeatEachIndex + 1)
+      projectSuite._addSuite(copyFileSuite)
+    }
+  }
+}
+
 addHook({
   name: 'playwright',
   file: 'lib/runner/loadUtils.js',
@@ -780,87 +809,112 @@ addHook({
     const allTests = rootSuite.allTests()
 
     if (isTestManagementTestsEnabled) {
+      const fileSuitesWithManagedTestsToProjects = new Map()
       for (const test of allTests) {
         const testProperties = getTestProperties(test)
+        // Disabled tests are skipped and not retried
         if (testProperties.disabled) {
           test._ddIsDisabled = true
-        } else if (testProperties.quarantined) {
+          test.expectedStatus = 'skipped'
+          continue
+        }
+        if (testProperties.quarantined) {
           test._ddIsQuarantined = true
+          if (!testProperties.attemptToFix) {
+            // Do not skip quarantined tests, let them run and overwrite results post-run if they fail
+            const testFqn = getTestFullyQualifiedName(test)
+            quarantinedButNotAttemptToFixFqns.add(testFqn)
+          }
         }
         if (testProperties.attemptToFix) {
           test._ddIsAttemptToFix = true
           const fileSuite = getSuiteType(test, 'file')
-          const projectSuite = getSuiteType(test, 'project')
-          const isAttemptToFix = test => getTestProperties(test).attemptToFix
-          for (let repeatEachIndex = 1; repeatEachIndex <= testManagementAttemptToFixRetries; repeatEachIndex++) {
-            const copyFileSuite = deepCloneSuite(fileSuite, isAttemptToFix, [
-              testProperties.disabled && '_ddIsDisabled',
-              testProperties.quarantined && '_ddIsQuarantined',
-              '_ddIsAttemptToFix',
-              '_ddIsAttemptToFixRetry'
-            ])
-            applyRepeatEachIndex(projectSuite._fullProject, copyFileSuite, repeatEachIndex + 1)
-            projectSuite._addSuite(copyFileSuite)
+
+          if (!fileSuitesWithManagedTestsToProjects.has(fileSuite)) {
+            fileSuitesWithManagedTestsToProjects.set(fileSuite, getSuiteType(test, 'project'))
           }
           if (testProperties.disabled || testProperties.quarantined) {
             quarantinedOrDisabledTestsAttemptToFix.push(test)
           }
-        } else if (testProperties.disabled) {
-          test.expectedStatus = 'skipped'
-        } else if (testProperties.quarantined) {
-          // Do not skip quarantined tests, let them run and overwrite results post-run if they fail
-          const testFqn = getTestFullyQualifiedName(test)
-          quarantinedButNotAttemptToFixFqns.add(testFqn)
         }
       }
+      applyRetriesToTests(
+        fileSuitesWithManagedTestsToProjects,
+        (test) => test._ddIsAttemptToFix,
+        [
+          (test) => test._ddIsQuarantined && '_ddIsQuarantined',
+          '_ddIsAttemptToFix',
+          '_ddIsAttemptToFixRetry'
+        ],
+        testManagementAttemptToFixRetries
+      )
     }
 
     if (isImpactedTestsEnabled) {
-      await Promise.all(allTests.map(async (test) => {
-        const { isModified } = await getChannelPromise(isModifiedCh, {
+      const impactedTests = allTests.filter(test => {
+        let isImpacted = false
+        isModifiedCh.publish({
           filePath: test._requireFile,
-          modifiedFiles
+          modifiedFiles,
+          onDone: (isModified) => { isImpacted = isModified }
         })
-        if (isModified) {
-          test._ddIsModified = true
-        }
-        if (isEarlyFlakeDetectionEnabled && test.expectedStatus !== 'skipped') {
-          const isNew = isKnownTestsEnabled && isNewTest(test)
-          const fileSuite = getSuiteType(test, 'file')
-          const projectSuite = getSuiteType(test, 'project')
-          // If something change in the file, all tests in the file are impacted
-          const isModifiedTest = () => isModified
-          for (let repeatEachIndex = 1; repeatEachIndex <= earlyFlakeDetectionNumRetries; repeatEachIndex++) {
-            const copyFileSuite = deepCloneSuite(fileSuite, isModifiedTest, [
-              isNew && '_ddIsNew',
-              '_ddIsModified',
-              '_ddIsEfdRetry'
-            ])
-            applyRepeatEachIndex(projectSuite._fullProject, copyFileSuite, repeatEachIndex + 1)
-            projectSuite._addSuite(copyFileSuite)
+        return isImpacted
+      })
+
+      const fileSuitesWithImpactedTestsToProjects = new Map()
+      impactedTests.forEach(impactedTest => {
+        impactedTest._ddIsModified = true
+        if (isEarlyFlakeDetectionEnabled && impactedTest.expectedStatus !== 'skipped') {
+          const fileSuite = getSuiteType(impactedTest, 'file')
+          if (!fileSuitesWithImpactedTestsToProjects.has(fileSuite)) {
+            fileSuitesWithImpactedTestsToProjects.set(fileSuite, getSuiteType(impactedTest, 'project'))
           }
         }
-      }))
+      })
+      // If something change in the file, all tests in the file are impacted, hence the () => true filter
+      applyRetriesToTests(
+        fileSuitesWithImpactedTestsToProjects,
+        () => true,
+        [
+          '_ddIsModified',
+          '_ddIsEfdRetry',
+          (test) => (isKnownTestsEnabled && isNewTest(test) ? '_ddIsNew' : null)
+        ],
+        earlyFlakeDetectionNumRetries
+      )
     }
 
     if (isKnownTestsEnabled) {
       const newTests = allTests.filter(isNewTest)
 
-      for (const newTest of newTests) {
-        // No need to filter out attempt to fix tests here because attempt to fix tests are never new
-        newTest._ddIsNew = true
-        if (isEarlyFlakeDetectionEnabled && newTest.expectedStatus !== 'skipped' && !newTest._ddIsModified) {
-          const fileSuite = getSuiteType(newTest, 'file')
-          const projectSuite = getSuiteType(newTest, 'project')
-          for (let repeatEachIndex = 1; repeatEachIndex <= earlyFlakeDetectionNumRetries; repeatEachIndex++) {
-            const copyFileSuite = deepCloneSuite(fileSuite, isNewTest, [
-              '_ddIsNew',
-              '_ddIsEfdRetry'
-            ])
-            applyRepeatEachIndex(projectSuite._fullProject, copyFileSuite, repeatEachIndex + 1)
-            projectSuite._addSuite(copyFileSuite)
+      const isFaulty = getIsFaultyEarlyFlakeDetection(
+        allTests.map(test => getTestSuitePath(test._requireFile, rootDir)),
+        knownTests.playwright,
+        earlyFlakeDetectionFaultyThreshold
+      )
+
+      if (isFaulty) {
+        isEarlyFlakeDetectionEnabled = false
+        isKnownTestsEnabled = false
+        isEarlyFlakeDetectionFaulty = true
+      } else {
+        const fileSuitesWithNewTestsToProjects = new Map()
+        newTests.forEach(newTest => {
+          newTest._ddIsNew = true
+          if (isEarlyFlakeDetectionEnabled && newTest.expectedStatus !== 'skipped' && !newTest._ddIsModified) {
+            const fileSuite = getSuiteType(newTest, 'file')
+            if (!fileSuitesWithNewTestsToProjects.has(fileSuite)) {
+              fileSuitesWithNewTestsToProjects.set(fileSuite, getSuiteType(newTest, 'project'))
+            }
           }
-        }
+        })
+
+        applyRetriesToTests(
+          fileSuitesWithNewTestsToProjects,
+          isNewTest,
+          ['_ddIsNew', '_ddIsEfdRetry'],
+          earlyFlakeDetectionNumRetries
+        )
       }
     }
 

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

@@ -5,6 +5,19 @@ const pathToRegExp = require('path-to-regexp')
 const shimmer = require('../../datadog-shimmer')
 const { addHook, channel } = require('./helpers/instrument')
 
+const {
+  getRouterMountPaths,
+  joinPath,
+  getLayerMatchers,
+  setLayerMatchers,
+  isAppMounted,
+  setRouterMountPath,
+  extractMountPaths,
+  getRouteFullPaths,
+  wrapRouteMethodsAndPublish,
+  collectRoutesFromRouter
+} = require('./helpers/router-helper')
+
 function isFastStar (layer, matchers) {
   return layer.regexp?.fast_star ?? matchers.some(matcher => matcher.path === '*')
 }
@@ -22,7 +35,6 @@ function createWrapRouterMethod (name) {
   const nextChannel = channel(`apm:${name}:middleware:next`)
   const routeAddedChannel = channel(`apm:${name}:route:added`)
 
-  const layerMatchers = new WeakMap()
   const regexpCache = Object.create(null)
 
   function wrapLayerHandle (layer, original) {
@@ -31,7 +43,7 @@ function createWrapRouterMethod (name) {
     return shimmer.wrapFunction(original, original => function () {
       if (!enterChannel.hasSubscribers) return original.apply(this, arguments)
 
-      const matchers = layerMatchers.get(layer)
+      const matchers = getLayerMatchers(layer)
       const lastIndex = arguments.length - 1
       const name = original._name || original.name
       const req = arguments[arguments.length > 3 ? 1 : 0]
@@ -78,7 +90,7 @@ function createWrapRouterMethod (name) {
         layer.handle = wrapLayerHandle(layer, layer.handle)
       }
 
-      layerMatchers.set(layer, matchers)
+      setLayerMatchers(layer, matchers)
 
       if (layer.route) {
         METHODS.forEach(method => {
@@ -115,7 +127,7 @@ function createWrapRouterMethod (name) {
     return arg.map(pattern => ({
       path: pattern instanceof RegExp ? `(${pattern})` : pattern,
       test: layer => {
-        const matchers = layerMatchers.get(layer)
+        const matchers = getLayerMatchers(layer)
         return !isFastStar(layer, matchers) &&
           !isFastSlash(layer, matchers) &&
           cachedPathToRegExp(pattern).test(layer.path)
@@ -134,12 +146,12 @@ function createWrapRouterMethod (name) {
   }
 
   function wrapMethod (original) {
-    return shimmer.wrapFunction(original, original => function methodWithTrace (fn) {
+    return shimmer.wrapFunction(original, original => function methodWithTrace (fn, ...otherArgs) {
       let offset = 0
       if (this.stack) {
         offset = Array.isArray(this.stack) ? this.stack.length : 1
       }
-      const router = original.apply(this, arguments)
+      const router = original.call(this, fn, ...otherArgs)
 
       if (typeof this.stack === 'function') {
         this.stack = [{ handle: this.stack }]
@@ -149,6 +161,51 @@ function createWrapRouterMethod (name) {
         routeAddedChannel.publish({ topOfStackFunc: methodWithTrace, layer: this.stack.at(-1) })
       }
 
+      // Publish only if this router was mounted by app.use() (prevents early '/sub/...')
+      if (routeAddedChannel.hasSubscribers && isAppMounted(this) && this.stack?.length > offset) {
+        // Handle nested router mounting for 'use' method
+        if (original.name === 'use' && otherArgs.length >= 1) {
+          const { mountPaths, startIdx } = extractMountPaths(fn)
+
+          if (mountPaths.length) {
+            const parentPaths = getRouterMountPaths(this)
+            const callArgs = [fn, ...otherArgs]
+
+            for (let i = startIdx; i < callArgs.length; i++) {
+              const nestedRouter = callArgs[i]
+
+              if (!nestedRouter || typeof nestedRouter !== 'function') continue
+
+              for (const parentPath of parentPaths) {
+                for (const normalizedMountPath of mountPaths) {
+                  const fullMountPath = joinPath(parentPath, normalizedMountPath)
+                  if (fullMountPath === null) continue
+
+                  setRouterMountPath(nestedRouter, fullMountPath)
+                  collectRoutesFromRouter(nestedRouter, fullMountPath)
+                }
+              }
+            }
+          }
+        }
+
+        const mountPaths = getRouterMountPaths(this)
+
+        if (mountPaths.length) {
+          const layer = this.stack.at(-1)
+
+          if (layer?.route) {
+            const route = layer.route
+
+            const fullPaths = mountPaths.flatMap(mountPath => getRouteFullPaths(route, mountPath))
+
+            wrapRouteMethodsAndPublish(route, fullPaths, (payload) => {
+              routeAddedChannel.publish(payload)
+            })
+          }
+        }
+      }
+
       if (this.stack.length > offset) {
         wrapStack(this.stack.slice(offset), extractMatchers(fn))
       }

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

@@ -41,7 +41,7 @@ function wrapSend (send) {
 
     const [data, options, cb] = arguments
 
-    const ctx = { data, socket: this._sender._socket }
+    const ctx = { data, socket: this._sender?._socket }
 
     return typeof cb === 'function'
       ? producerCh.traceCallback(send, undefined, ctx, this, data, options, cb)
@@ -70,7 +70,7 @@ function createWrappedHandler (handler) {
   return function wrappedMessageHandler (data, binary) {
     const byteLength = dataLength(data)
 
-    const ctx = { data, binary, socket: this._sender._socket, byteLength }
+    const ctx = { data, binary, socket: this._sender?._socket, byteLength }
 
     return receiverCh.traceSync(handler, ctx, this, data, binary)
   }
@@ -93,7 +93,7 @@ function wrapClose (close) {
     // if both are true then the self is sending the close event
     const isPeerClose = this._closeFrameReceived === true && this._closeFrameSent === false
 
-    const ctx = { code, data, socket: this._sender._socket, isPeerClose }
+    const ctx = { code, data, socket: this._sender?._socket, isPeerClose }
 
     return closeCh.traceSync(close, ctx, this, ...arguments)
   }

package/packages/datadog-plugin-express/src/code_origin.js

@@ -19,6 +19,7 @@ class ExpressCodeOriginForSpansPlugin extends Plugin {
     })
 
     this.addSub('apm:express:route:added', ({ topOfStackFunc, layer }) => {
+      if (!layer) return
       if (layerTags.has(layer)) return
       layerTags.set(layer, entryTags(topOfStackFunc))
     })
@@ -30,6 +31,7 @@ class ExpressCodeOriginForSpansPlugin extends Plugin {
     })
 
     this.addSub('apm:router:route:added', ({ topOfStackFunc, layer }) => {
+      if (!layer) return
       if (layerTags.has(layer)) return
       layerTags.set(layer, entryTags(topOfStackFunc))
     })

package/packages/datadog-plugin-ws/src/close.js

@@ -17,7 +17,7 @@ class WSClosePlugin extends TracingPlugin {
     if (!traceWebsocketMessagesEnabled) return
 
     const { code, data, socket, isPeerClose } = ctx
-    if (!socket.spanContext) return
+    if (!socket?.spanContext) return
 
     const spanKind = isPeerClose ? 'consumer' : 'producer'
     const spanTags = socket.spanContext.spanTags

package/packages/dd-trace/src/config-helper.js

@@ -37,7 +37,9 @@ for (const deprecation of Object.keys(deprecations)) {
 module.exports = {
   /**
    * Returns the environment variables that are supported by the tracer
-   * (including all non-Datadog/OTEL specific environment variables)
+   * (including all non-Datadog/OTEL specific environment variables).
+   *
+   * This should only be called once in config.js to avoid copying the object frequently.
    *
    * @returns {TracerEnv} The environment variables
    */