dd-trace 5.72.0 → 5.74.0

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-amqplib/src/consumer.js

@@ -10,7 +10,7 @@ class AmqplibConsumerPlugin extends ConsumerPlugin {
   static operation = 'consume'
 
   bindStart (ctx) {
-    const { method, fields, message, queue } = ctx
+    const { method, fields = {}, message, queue } = ctx
 
     if (method !== 'basic.deliver' && method !== 'basic.get') return
 

package/packages/datadog-plugin-azure-functions/src/index.js

@@ -24,10 +24,10 @@ class AzureFunctionsPlugin extends TracingPlugin {
   static prefix = 'tracing:datadog:azure:functions:invoke'
 
   bindStart (ctx) {
-    const childOf = extractTraceContext(this._tracer, ctx)
     const meta = getMetaForTrigger(ctx)
     const triggerType = triggerMap[ctx.methodName]
     const isMessagingService = (triggerType === 'ServiceBus' || triggerType === 'EventHubs')
+    const childOf = isMessagingService ? null : extractTraceContext(this._tracer, ctx)
     const span = this.startSpan(this.operationName(), {
       childOf,
       service: this.serviceName(),
@@ -36,7 +36,7 @@ class AzureFunctionsPlugin extends TracingPlugin {
     }, ctx)
 
     if (isMessagingService) {
-      setSpanLinks(this.tracer, span, ctx)
+      setSpanLinks(triggerType, this.tracer, span, ctx)
     }
 
     ctx.span = span
@@ -116,29 +116,39 @@ function extractTraceContext (tracer, ctx) {
   switch (String(triggerMap[ctx.methodName])) {
     case 'Http':
       return tracer.extract('http_headers', Object.fromEntries(ctx.httpRequest.headers))
-    case 'ServiceBus':
-      return tracer.extract('text_map', ctx.invocationContext.triggerMetadata.applicationProperties)
     default:
       null
   }
 }
 
-function setSpanLinks (tracer, span, ctx) {
+// message & messages & batch with cardinality of 1 == applicationProperties
+// messages with cardinality of many == applicationPropertiesArray
+function setSpanLinks (triggerType, tracer, span, ctx) {
   const cardinality = ctx.invocationContext.options.trigger.cardinality
   const triggerMetadata = ctx.invocationContext.triggerMetadata
-  if (cardinality === 'many' && triggerMetadata.propertiesArray.length > 0) {
-    triggerMetadata.propertiesArray.forEach(event => {
-      // Check for possible empty event when span links are disabled
-      if (Object.keys(event).length > 0) {
-        span.addLink(tracer.extract('text_map', event))
-      }
-    })
-  } else if (cardinality === 'one') {
-    const spanContext = tracer.extract('text_map', triggerMetadata.properties)
+  const isServiceBus = triggerType === 'ServiceBus'
+
+  const properties = isServiceBus
+    ? triggerMetadata.applicationProperties
+    : triggerMetadata.properties
+
+  const propertiesArray = isServiceBus
+    ? triggerMetadata.applicationPropertiesArray
+    : triggerMetadata.propertiesArray
+
+  const addLinkFromProperties = (props) => {
+    if (!props || Object.keys(props).length === 0) return
+    const spanContext = tracer.extract('text_map', props)
     if (spanContext) {
       span.addLink(spanContext)
     }
   }
+
+  if (cardinality === 'many' && propertiesArray?.length > 0) {
+    propertiesArray.forEach(addLinkFromProperties)
+  } else if (cardinality === 'one') {
+    addLinkFromProperties(properties)
+  }
 }
 
 module.exports = AzureFunctionsPlugin

package/packages/datadog-plugin-azure-service-bus/src/index.js

@@ -4,7 +4,7 @@ const ProducerPlugin = require('./producer')
 const CompositePlugin = require('../../dd-trace/src/plugins/composite')
 
 class AzureServiceBusPlugin extends CompositePlugin {
-  static id = 'azure-service-bus'
+  static get id () { return 'azure-service-bus' }
   static get plugins () {
     return {
       producer: ProducerPlugin

package/packages/datadog-plugin-azure-service-bus/src/producer.js

@@ -1,36 +1,84 @@
 'use strict'
 
+const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
 const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
 
 class AzureServiceBusProducerPlugin extends ProducerPlugin {
-  static id = 'azure-service-bus'
-  static operation = 'send'
+  static get id () { return 'azure-service-bus' }
+  static get operation () { return 'send' }
+  static get prefix () { return 'tracing:apm:azure-service-bus:send' }
 
   bindStart (ctx) {
-    const { sender, msg } = ctx
-    const qualifiedSenderNamespace = sender._sender.audience.replace('sb://', '')
+    // we do not want to make these spans when batch linking is disabled.
+    if (!batchLinksAreEnabled() && ctx.functionName === 'tryAddMessage') {
+      return ctx.currentStore
+    }
+
+    const qualifiedSenderNamespace = ctx.config.host
     const span = this.startSpan({
-      resource: sender.entityPath,
+      resource: ctx.entityPath,
       type: 'messaging',
       meta: {
         component: 'azure-service-bus',
-        'messaging.destination.name': sender.entityPath,
+        'messaging.destination.name': ctx.entityPath,
         'messaging.operation': 'send',
         'messaging.system': 'servicebus',
         'network.destination.name': qualifiedSenderNamespace,
       }
     }, ctx)
 
-    // This is the correct key for injecting trace context into Azure Service Bus messages
-    // It may not be present in the message properties, so we ensure it exists
-    if (!msg.applicationProperties) {
-      msg.applicationProperties = {}
-    }
+    if (ctx.functionName === 'tryAddMessage') {
+      span._spanContext._name = 'azure.servicebus.create'
+      span.setTag('messaging.operation', 'create')
 
-    this.tracer.inject(span, 'text_map', msg.applicationProperties)
+      if (ctx.msg.messageID !== undefined) {
+        span.setTag('message.id', ctx.msg)
+      }
 
+      if (batchLinksAreEnabled()) {
+        ctx.batch._spanContexts.push(span.context())
+        injectTraceContext(this.tracer, span, ctx.msg)
+      }
+    }
+
+    if (ctx.functionName === 'send' || ctx.functionName === 'sendBatch' || ctx.functionName === 'scheduleMessages') {
+      const messages = ctx.msg
+      const isBatch = messages.constructor?.name === 'ServiceBusMessageBatchImpl'
+      if (isBatch) {
+        span.setTag('messaging.batch.message_count', messages.count)
+        if (batchLinksAreEnabled()) {
+          messages._spanContexts.forEach(spanContext => {
+            span.addLink(spanContext)
+          })
+        }
+      } else if (Array.isArray(messages)) {
+        span.setTag('messaging.batch.message_count', messages.length)
+        messages.forEach(event => {
+          injectTraceContext(this.tracer, span, event)
+        })
+      } else {
+        injectTraceContext(this.tracer, span, messages)
+      }
+    }
     return ctx.currentStore
   }
+
+  asyncEnd (ctx) {
+    super.finish()
+  }
+}
+
+function injectTraceContext (tracer, span, msg) {
+  if (!msg.applicationProperties) {
+    msg.applicationProperties = {}
+  }
+
+  tracer.inject(span, 'text_map', msg.applicationProperties)
+}
+
+function batchLinksAreEnabled () {
+  const sb = getEnvironmentVariable('DD_TRACE_AZURE_SERVICEBUS_BATCH_LINKS_ENABLED')
+  return sb !== 'false'
 }
 
 module.exports = AzureServiceBusProducerPlugin

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))
     })