dd-trace 5.115.0 → 5.116.0

package/packages/datadog-plugin-graphql/src/execute.js

@@ -197,7 +197,6 @@ class GraphQLExecutePlugin extends TracingPlugin {
       config: this.config,
       fields: new Map(),
       pathCache: new Map(),
-      collapsedPathCache: this.config.collapse ? { byPath: new Map(), byParent: new Map() } : undefined,
       abortController,
       executeSpan: span,
       plugin: this,
@@ -228,9 +227,13 @@ class GraphQLExecutePlugin extends TracingPlugin {
     if (!span) return
 
     // Synchronous execute() throw (e.g. execute(null, doc)) — error handler
-    // already tagged the span, just finish it.
+    // already tagged the span.
     if (ctx.error) {
-      this.#drain(ctx, span)
+      if (ctx.ddAborted) {
+        span.finish()
+      } else {
+        this.#finishSpan(ctx, span)
+      }
       return ctx.parentStore
     }
 
@@ -239,10 +242,7 @@ class GraphQLExecutePlugin extends TracingPlugin {
     if (typeof result?.then === 'function') {
       result.then(
         (res) => this.#finishSpan(ctx, span, res),
-        (err) => {
-          span.setTag('error', err)
-          this.#drain(ctx, span)
-        }
+        (err) => this.#finishSpan(ctx, span, undefined, err)
       )
     } else {
       this.#finishSpan(ctx, span, result)
@@ -261,8 +261,16 @@ class GraphQLExecutePlugin extends TracingPlugin {
     }
   }
 
-  #finishSpan (ctx, span, res) {
-    this.config.hooks.execute(span, ctx.ddArgs, res)
+  /**
+   * @param {object} ctx
+   * @param {import('../../dd-trace/src/opentracing/span')} span
+   * @param {import('graphql').ExecutionResult} [res]
+   * @param {unknown} [error]
+   */
+  #finishSpan (ctx, span, res, error) {
+    if (error !== undefined) {
+      span.setTag('error', error)
+    }
 
     if (res?.errors?.length) {
       span.setTag('error', res.errors[0])
@@ -271,17 +279,16 @@ class GraphQLExecutePlugin extends TracingPlugin {
       }
     }
 
-    this.#drain(ctx, span)
-  }
-
-  #drain (ctx, span) {
-    span.finish()
     if (ctx.ddContextValue) {
       contexts.delete(ctx.ddContextValue)
     }
     if (ctx.ddInstrumentedArgs) {
       instrumentedArgs.delete(ctx.ddInstrumentedArgs)
     }
+
+    this.config.hooks.execute(span, ctx.ddArgs, res)
+
+    span.finish()
   }
 
   // Public — called from wrapResolve (free function, crosses class boundary).
@@ -307,6 +314,7 @@ class GraphQLExecutePlugin extends TracingPlugin {
       type: 'graphql',
       startTime,
       meta: {
+        'graphql.field.coordinates': `${field.parentTypeName}.${fieldName}`,
         'graphql.field.name': fieldName,
         'graphql.field.path': collapsedKey,
         'graphql.field.type': baseTypeName,
@@ -423,20 +431,35 @@ function wrapResolve (resolve) {
       return resolve.apply(this, arguments)
     }
 
-    const fieldKey = config.collapse ? buildCachedCollapsedPath(infoPath, rootCtx.collapsedPathCache) : infoPath
+    const fieldKey = config.collapse ? pathString : infoPath
+    const parentTypeName = info.parentType.name
     let field = rootCtx.fields.get(fieldKey)
+    const collapsedField = field
+    if (config.collapse && field !== undefined && field.parentTypeName !== parentTypeName) {
+      const parentTypeFields = field.parentTypeFields
+      if (parentTypeFields?.parentTypeName === undefined) {
+        field = parentTypeFields?.get(parentTypeName)
+      } else if (parentTypeFields.parentTypeName === parentTypeName) {
+        field = parentTypeFields
+      } else {
+        field = undefined
+      }
+      if (field && infoPath.typename === undefined) {
+        cacheFieldByPath(rootCtx, infoPath, field)
+      }
+    }
     const isFirst = !field
 
     if (isFirst) {
       field = {
         fieldNode: info.fieldNodes?.[0],
         fieldName: info.fieldName,
+        parentTypeName,
         returnType: info.returnType,
         baseTypeName: getBaseTypeName(info.returnType),
         variableValues: info.variableValues,
         args,
         infoPath,
-        fieldKey,
         pathString,
         collapsedKey: collapsedKey ?? pathString,
         span: null,
@@ -445,7 +468,25 @@ function wrapResolve (resolve) {
         parentStore: null,
         currentStore: null,
       }
-      rootCtx.fields.set(fieldKey, field)
+      if (config.collapse && collapsedField) {
+        const parentTypeFields = collapsedField.parentTypeFields
+        if (parentTypeFields === undefined) {
+          collapsedField.parentTypeFields = field
+        } else if (parentTypeFields.parentTypeName === undefined) {
+          parentTypeFields.set(parentTypeName, field)
+        } else {
+          const fieldsByParentType = new Map()
+            .set(collapsedField.parentTypeName, collapsedField)
+            .set(parentTypeFields.parentTypeName, parentTypeFields)
+            .set(parentTypeName, field)
+          collapsedField.parentTypeFields = fieldsByParentType
+        }
+        if (infoPath.typename === undefined) {
+          cacheFieldByPath(rootCtx, infoPath, field)
+        }
+      } else {
+        rootCtx.fields.set(fieldKey, field)
+      }
     }
 
     // Collapsed siblings still publish updateField (master's contract: one
@@ -592,31 +633,18 @@ function buildCachedPathString (path, cache, collapse) {
   return pathString
 }
 
-function buildCachedCollapsedPath (path, cache) {
-  if (!path) return
-
-  const cached = cache.byPath.get(path)
-  if (cached !== undefined) return cached
-
-  const segment = typeof path.key === 'string' ? path.key : '*'
-  const prev = path.prev === undefined
-    ? undefined
-    : buildCachedCollapsedPath(path.prev, cache)
-
-  let siblings = cache.byParent.get(prev)
-  if (siblings === undefined) {
-    siblings = new Map()
-    cache.byParent.set(prev, siblings)
-  }
-
-  let collapsedPath = siblings.get(segment)
-  if (collapsedPath === undefined) {
-    collapsedPath = { key: segment, prev }
-    siblings.set(segment, collapsedPath)
-  }
-
-  cache.byPath.set(path, collapsedPath)
-  return collapsedPath
+/**
+ * @param {{ hasFieldsByPath?: boolean, fields: Map<string|object, object> }} rootCtx
+ * @param {object} path
+ * @param {object} field
+ */
+function cacheFieldByPath (rootCtx, path, field) {
+  // Leaf fields cannot parent resolver spans, so their concrete paths are never read.
+  if (field.fieldNode?.selectionSet === undefined) return
+
+  // Concrete info path objects cannot collide with collapsed path string keys.
+  rootCtx.hasFieldsByPath = true
+  rootCtx.fields.set(path, field)
 }
 
 // Depth filtering directly on the linked-list node — no array allocation needed.
@@ -640,9 +668,23 @@ function shouldInstrumentNode (config, path) {
 }
 
 function getParentField (rootCtx, field) {
-  for (let curr = field.fieldKey?.prev; curr; curr = curr.prev) {
-    const innerField = rootCtx.fields.get(curr)
-    if (innerField) return innerField
+  for (let curr = field.infoPath?.prev; curr; curr = curr.prev) {
+    const fieldKey = rootCtx.config.collapse ? rootCtx.pathCache.get(curr) : curr
+    const innerField = rootCtx.fields.get(fieldKey)
+    if (innerField) {
+      if (curr.typename === undefined) {
+        if (rootCtx.hasFieldsByPath) {
+          const fieldByPath = rootCtx.fields.get(curr)
+          if (fieldByPath) return fieldByPath
+        }
+        return innerField
+      }
+      if (innerField.parentTypeName === curr.typename) return innerField
+
+      const parentTypeFields = innerField.parentTypeFields
+      if (parentTypeFields.parentTypeName === undefined) return parentTypeFields.get(curr.typename)
+      return parentTypeFields
+    }
   }
 
   return null

package/packages/datadog-plugin-graphql/src/validate.js

@@ -68,8 +68,6 @@ class GraphQLValidatePlugin extends TracingPlugin {
     const errors = ctx.result
     const span = ctx?.currentStore?.span || this.activeSpan
 
-    this.config.hooks.validate(span, document, errors)
-
     if (errors?.length) {
       span.setTag('error', errors[0])
       for (const err of errors) {
@@ -77,6 +75,8 @@ class GraphQLValidatePlugin extends TracingPlugin {
       }
     }
 
+    this.config.hooks.validate(span, document, errors)
+
     span.finish()
 
     return ctx.parentStore

package/packages/datadog-plugin-http2/src/client.js

@@ -32,7 +32,7 @@ class Http2ClientPlugin extends ClientPlugin {
     const { authority, options, headers = {} } = message
     const sessionDetails = extractSessionDetails(authority, options)
     const path = headers[HTTP2_HEADER_PATH] || '/'
-    const pathname = path.split(/[?#]/)[0]
+    const pathname = path.split(/[?#]/, 1)[0]
     const method = headers[HTTP2_HEADER_METHOD] || HTTP2_METHOD_GET
     const base = `${sessionDetails.protocol}//${sessionDetails.host}:${sessionDetails.port}`
     const uri = `${base}${pathname}`

package/packages/datadog-plugin-langchain/src/handlers/embedding.js

@@ -1,10 +1,11 @@
 'use strict'
 
+const { getSegment } = require('../../../dd-trace/src/util')
 const LangChainHandler = require('./default')
 
 class LangChainEmbeddingHandler extends LangChainHandler {
   extractProvider (instance) {
-    return instance.constructor.name.split('Embeddings')[0].toLowerCase()
+    return getSegment(instance.constructor.name, 'Embeddings', 0).toLowerCase()
   }
 
   extractModel (instance) {

package/packages/datadog-plugin-langchain/src/handlers/language_models.js

@@ -1,10 +1,11 @@
 'use strict'
 
+const { getSegment } = require('../../../dd-trace/src/util')
 const LangChainHandler = require('./default')
 
 class LangChainLanguageModelHandler extends LangChainHandler {
   extractProvider (instance) {
-    return typeof instance._llmType === 'function' && instance._llmType().split('-')[0]
+    return typeof instance._llmType === 'function' && getSegment(instance._llmType(), '-', 0)
   }
 
   extractModel (instance) {

package/packages/datadog-plugin-langchain/src/tokens.js

@@ -15,10 +15,10 @@ function getTokensFromLlmOutput (result) {
   for (const tokenNames of [['input', 'prompt'], ['output', 'completion'], ['total']]) {
     let token = 0
     for (const tokenName of tokenNames) {
-      const underScore = `${tokenName}_tokens`
+      const underscore = `${tokenName}_tokens`
       const camelCase = `${tokenName}Tokens`
 
-      token = tokenUsage[underScore] || tokenUsage[camelCase] || token
+      token = tokenUsage[underscore] || tokenUsage[camelCase] || token
     }
 
     tokens[tokenNames[0]] = token

package/packages/datadog-plugin-playwright/src/index.js

@@ -1,16 +1,26 @@
 'use strict'
 
+const { basename } = require('node:path')
+
 const { storage } = require('../../datadog-core')
 const id = require('../../dd-trace/src/id')
 const CiPlugin = require('../../dd-trace/src/plugins/ci_plugin')
+const getConfig = require('../../dd-trace/src/config')
+const {
+  SCREENSHOT_UPLOAD_RESULT_ERROR,
+  SCREENSHOT_UPLOAD_RESULT_UPLOADED,
+  getScreenshotCapturedAtMs,
+  getScreenshotUploadResult,
+  getScreenshotUploadTag,
+} = require('../../dd-trace/src/ci-visibility/test-screenshot')
 
 const {
   finishAllTraceSpans,
   getTestSuiteCommonTags,
   getTestSuitePath,
   isModifiedTest,
+  setRumTestCorrelation,
   TEST_BROWSER_NAME,
-  TEST_BROWSER_VERSION,
   TEST_CODE_OWNERS,
   TEST_EARLY_FLAKE_ABORT_REASON,
   TEST_EARLY_FLAKE_ENABLED,
@@ -51,6 +61,21 @@ const {
 const { appClosing: appClosingTelemetry } = require('../../dd-trace/src/telemetry')
 const log = require('../../dd-trace/src/log')
 
+const PLAYWRIGHT_FAILURE_SCREENSHOT_RE = /^test-failed-\d+\.png$/
+
+/**
+ * Returns whether an attachment is an automatic Playwright failure screenshot.
+ *
+ * @param {object} attachment - Playwright test attachment
+ * @returns {boolean}
+ */
+function isPlaywrightFailureScreenshot (attachment) {
+  return attachment?.name === 'screenshot' &&
+    attachment.contentType === 'image/png' &&
+    typeof attachment.path === 'string' &&
+    PLAYWRIGHT_FAILURE_SCREENSHOT_RE.test(basename(attachment.path))
+}
+
 class PlaywrightPlugin extends CiPlugin {
   static id = 'playwright'
 
@@ -60,6 +85,8 @@ class PlaywrightPlugin extends CiPlugin {
     this._testSuiteSpansByTestSuiteAbsolutePath = new Map()
     this.numFailedTests = 0
     this.numFailedSuites = 0
+    this.pendingTestFinishes = 0
+    this.finishSession = undefined
 
     this.addSub('ci:playwright:test:is-modified', ({
       filePath,
@@ -71,6 +98,30 @@ class PlaywrightPlugin extends CiPlugin {
       onDone(isModified)
     })
 
+    this.addSub('ci:playwright:session:start', ({ isFailureScreenshotEnabled }) => {
+      if (!getConfig().testOptimization.DD_TEST_FAILURE_SCREENSHOTS_ENABLED) return
+
+      if (!isFailureScreenshotEnabled) {
+        log.warn(
+          '%s %s',
+          'DD_TEST_FAILURE_SCREENSHOTS_ENABLED is true, but Playwright screenshot capture is disabled.',
+          'Set Playwright use.screenshot to "only-on-failure", "on-first-failure", or "on".'
+        )
+      }
+    })
+
+    this.addSub('ci:playwright:session:configuration', ({ isFailureScreenshotEnabled }) => {
+      if (!getConfig().testOptimization.DD_TEST_FAILURE_SCREENSHOTS_ENABLED || !isFailureScreenshotEnabled) return
+
+      if (!this.tracer._exporter?.canUploadTestScreenshots?.()) {
+        log.warn(
+          '%s %s',
+          'DD_TEST_FAILURE_SCREENSHOTS_ENABLED is true, but Playwright screenshot upload is not supported',
+          'by the active Test Optimization transport.'
+        )
+      }
+    })
+
     this.addSub('ci:playwright:session:finish', ({
       status,
       isEarlyFlakeDetectionEnabled,
@@ -78,42 +129,51 @@ class PlaywrightPlugin extends CiPlugin {
       isTestManagementTestsEnabled,
       onDone,
     }) => {
-      this.testModuleSpan.setTag(TEST_STATUS, status)
-      this.testSessionSpan.setTag(TEST_STATUS, status)
+      const finishSession = () => {
+        this.testModuleSpan.setTag(TEST_STATUS, status)
+        this.testSessionSpan.setTag(TEST_STATUS, status)
 
-      if (isEarlyFlakeDetectionEnabled) {
-        this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ENABLED, 'true')
-      }
-      if (isEarlyFlakeDetectionFaulty) {
-        this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ABORT_REASON, 'faulty')
-      }
-      if (status === 'fail' && this.numFailedSuites > 0) {
-        let errorMessage = `Test suites failed: ${this.numFailedSuites}.`
-        if (this.numFailedTests > 0) {
-          errorMessage += ` Tests failed: ${this.numFailedTests}`
+        if (isEarlyFlakeDetectionEnabled) {
+          this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ENABLED, 'true')
+        }
+        if (isEarlyFlakeDetectionFaulty) {
+          this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ABORT_REASON, 'faulty')
+        }
+        if (status === 'fail' && this.numFailedSuites > 0) {
+          let errorMessage = `Test suites failed: ${this.numFailedSuites}.`
+          if (this.numFailedTests > 0) {
+            errorMessage += ` Tests failed: ${this.numFailedTests}`
+          }
+          const error = new Error(errorMessage)
+          this.testModuleSpan.setTag('error', error)
+          this.testSessionSpan.setTag('error', error)
         }
-        const error = new Error(errorMessage)
-        this.testModuleSpan.setTag('error', error)
-        this.testSessionSpan.setTag('error', error)
-      }
 
-      if (isTestManagementTestsEnabled) {
-        this.testSessionSpan.setTag(TEST_MANAGEMENT_ENABLED, 'true')
+        if (isTestManagementTestsEnabled) {
+          this.testSessionSpan.setTag(TEST_MANAGEMENT_ENABLED, 'true')
+        }
+
+        this.testModuleSpan.finish()
+        this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
+        this.testSessionSpan.finish()
+        this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'session')
+        finishAllTraceSpans(this.testSessionSpan)
+        this.telemetry.count(TELEMETRY_TEST_SESSION, {
+          provider: this.ciProviderName,
+          autoInjected: !!this._tracerConfig.testOptimization.DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER,
+        })
+        appClosingTelemetry()
+        this.tracer._exporter.flush(onDone)
+        this.numFailedTests = 0
+        this.numFailedSuites = 0
+        this.finishSession = undefined
       }
 
-      this.testModuleSpan.finish()
-      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
-      this.testSessionSpan.finish()
-      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'session')
-      finishAllTraceSpans(this.testSessionSpan)
-      this.telemetry.count(TELEMETRY_TEST_SESSION, {
-        provider: this.ciProviderName,
-        autoInjected: !!this._tracerConfig.testOptimization.DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER,
-      })
-      appClosingTelemetry()
-      this.tracer._exporter.flush(onDone)
-      this.numFailedTests = 0
-      this.numFailedSuites = 0
+      if (this.pendingTestFinishes > 0) {
+        this.finishSession = finishSession
+      } else {
+        finishSession()
+      }
     })
 
     this.addBind('ci:playwright:test-suite:start', (ctx) => {
@@ -178,42 +238,17 @@ class PlaywrightPlugin extends CiPlugin {
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
     })
 
-    this.addSub('ci:playwright:test:page-goto', ({
-      isRumActive,
-      page,
-    }) => {
-      const store = storage('legacy').getStore()
-      const span = store && store.span
-      if (!span) {
+    this.addSub('ci:playwright:test:page-goto', (ctx) => {
+      const activeSpan = storage('legacy').getStore()?.span
+      if (!setRumTestCorrelation(ctx, activeSpan)) {
         log.error('ci:playwright:test:page-goto: test span not found')
-        return
-      }
-
-      if (isRumActive) {
-        span.setTag(TEST_IS_RUM_ACTIVE, 'true')
-
-        if (page) {
-          const browserVersion = page.context().browser().version()
-
-          if (browserVersion) {
-            span.setTag(TEST_BROWSER_VERSION, browserVersion)
-          }
-
-          const url = page.url()
-          const domain = new URL(url).hostname
-          page.context().addCookies([{
-            name: 'datadog-ci-visibility-test-execution-id',
-            value: span.context().toTraceId(),
-            domain,
-            path: '/',
-          }])
-        }
       }
     })
 
-    this.addSub('ci:playwright:worker:report', (serializedTraces) => {
+    this.addSub('ci:playwright:worker:report', ({ serializedTraces, screenshots }) => {
       const traces = JSON.parse(serializedTraces)
       const formattedTraces = []
+      let formattedTestSpan
 
       for (const trace of traces) {
         const formattedTrace = []
@@ -228,6 +263,7 @@ class PlaywrightPlugin extends CiPlugin {
             formattedSpan.meta[TEST_HAS_DYNAMIC_NAME] = 'true'
           }
           if (span.name === 'playwright.test') {
+            formattedTestSpan = formattedSpan
             // TODO: remove this comment
             // TODO: Let's pass rootDir, repositoryRoot, command, session id and module id as env vars
             // so we don't need this re-serialization logic. This can be passed just once, since they're unique
@@ -262,9 +298,36 @@ class PlaywrightPlugin extends CiPlugin {
         formattedTraces.push(formattedTrace)
       }
 
-      for (const trace of formattedTraces) {
-        this.tracer._exporter.export(trace)
+      const exportTraces = () => {
+        for (const trace of formattedTraces) {
+          this.tracer._exporter.export(trace)
+        }
       }
+
+      if (!formattedTestSpan || !screenshots) {
+        exportTraces()
+        return
+      }
+
+      this.pendingTestFinishes++
+      const uploadStarted = this.uploadTestScreenshots({
+        screenshots,
+        traceId: formattedTestSpan.trace_id.toString(10),
+      }, (screenshotUploadResult) => {
+        const screenshotUploadTag = getScreenshotUploadTag(screenshotUploadResult)
+        if (screenshotUploadTag) {
+          formattedTestSpan.meta[screenshotUploadTag] = 'true'
+        }
+        exportTraces()
+        this.pendingTestFinishes--
+        if (this.pendingTestFinishes === 0 && this.finishSession) {
+          this.finishSession()
+        }
+      })
+      if (uploadStarted) return
+
+      this.pendingTestFinishes--
+      exportTraces()
     })
 
     this.addBind('ci:playwright:test:start', (ctx) => {
@@ -480,6 +543,56 @@ class PlaywrightPlugin extends CiPlugin {
     })
   }
 
+  /**
+   * Uploads automatic failure screenshots for a Playwright test attempt.
+   *
+   * @param {object} options - Upload options
+   * @param {Array<object>} options.screenshots - Playwright test attachments
+   * @param {string} options.traceId - Test trace id used as the screenshot key
+   * @param {(result: string|undefined) => void} onDone - Completion callback
+   * @returns {boolean} Whether at least one upload was started
+   */
+  uploadTestScreenshots ({ screenshots, traceId }, onDone) {
+    const exporter = this.tracer?._exporter
+    if (!Array.isArray(screenshots) || !screenshots.length ||
+      !exporter?.canUploadTestScreenshots?.() ||
+      !exporter.uploadTestScreenshot) {
+      return false
+    }
+
+    const screenshotPaths = new Set()
+    for (const screenshot of screenshots) {
+      if (isPlaywrightFailureScreenshot(screenshot)) {
+        screenshotPaths.add(screenshot.path)
+      }
+    }
+    if (!screenshotPaths.size) return false
+
+    const uploadResults = new Array(screenshotPaths.size)
+    let pendingUploads = screenshotPaths.size
+    let index = 0
+    for (const filePath of screenshotPaths) {
+      const resultIndex = index++
+      exporter.uploadTestScreenshot({
+        filePath,
+        traceId,
+        idempotencyKey: `${traceId}:${basename(filePath)}`,
+        capturedAtMs: getScreenshotCapturedAtMs(filePath, filePath),
+      }, (error, uploaded = true) => {
+        if (uploaded) {
+          uploadResults[resultIndex] = error
+            ? SCREENSHOT_UPLOAD_RESULT_ERROR
+            : SCREENSHOT_UPLOAD_RESULT_UPLOADED
+        }
+        pendingUploads--
+        if (pendingUploads === 0) {
+          onDone(getScreenshotUploadResult(uploadResults))
+        }
+      })
+    }
+    return true
+  }
+
   // TODO: this runs both in worker and main process (main process: skipped tests that do not go through _runTest)
   startTestSpan (
     testName,

package/packages/datadog-plugin-router/src/index.js

@@ -24,7 +24,7 @@ class RouterPlugin extends WebPlugin {
       let childOf
       if (context !== undefined) {
         const middleware = context.middleware
-        childOf = middleware.length === 0 ? context.span : middleware[middleware.length - 1]
+        childOf = middleware.length === 0 ? context.span : middleware.at(-1)
       } else if (store) {
         childOf = store.span
       }
@@ -75,12 +75,21 @@ class RouterPlugin extends WebPlugin {
       const context = this.#contexts.get(req)
       if (!context) return
       const middleware = context.middleware
-      const span = middleware.length === 0 ? context.span : middleware[middleware.length - 1]
+      const span = middleware.length === 0 ? context.span : middleware.at(-1)
       if (!span) return
 
       span.setTag('error', error)
     })
 
+    this.addSub(`apm:${this.constructor.id}:middleware:repeat`, ({ req, name, error }) => {
+      // The middleware span already finished on the first `next`, so record the
+      // repeat on the still-live request span instead of a finished one.
+      web.root(req)?.addEvent('middleware.next_called_again', {
+        'middleware.name': name || '<anonymous>',
+        with_error: Boolean(error && error !== 'route' && error !== 'router'),
+      })
+    })
+
     this.addSub('apm:http:server:request:finish', ({ req }) => {
       const context = this.#contexts.get(req)