dd-trace 6.1.0 → 6.3.0

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

@@ -105,6 +105,7 @@ const efdStartedOriginalTestKeys = new Set()
 const efdSlowAbortedTests = new Set()
 const ddPropertiesByTestId = new Map()
 const ddPropertiesRequestsByTestId = new Map()
+const disabledTestIds = new Set()
 let rootDir = ''
 let sessionProjects = []
 
@@ -113,6 +114,8 @@ const EFD_RETRY_COUNT_REQUEST = 'ddEfdRetryCountRequest'
 const EFD_RETRY_COUNT_RESPONSE = 'ddEfdRetryCountResponse'
 const DD_PROPERTIES_REQUEST = 'ddPropertiesRequest'
 const DD_PROPERTIES_RESPONSE = 'ddProperties'
+const kDdPlaywrightDisabledTestIds = Symbol('ddPlaywrightDisabledTestIds')
+const kDdPlaywrightWorkerHostInstrumented = Symbol('ddPlaywrightWorkerHostInstrumented')
 const kDdPlaywrightWorkerInstrumented = Symbol('ddPlaywrightWorkerInstrumented')
 
 function isValidKnownTests (receivedKnownTests) {
@@ -991,14 +994,36 @@ function onDispatcherCreateWorker (dispatcher, worker) {
   const projects = getProjectsFromDispatcher(dispatcher)
   sessionProjects = projects
 
+  if (disabledTestIds.size && !worker[kDdPlaywrightWorkerHostInstrumented] &&
+      typeof worker.runTestGroup === 'function') {
+    Object.defineProperty(worker, kDdPlaywrightWorkerHostInstrumented, { value: true })
+    shimmer.wrap(worker, 'runTestGroup', runTestGroup => function (runPayload) {
+      // Serial retries can restore disabled tests that were filtered from the initial dispatcher groups.
+      let disabledIds
+      for (const { testId } of runPayload.entries) {
+        if (disabledTestIds.has(testId)) {
+          disabledIds ??= []
+          disabledIds.push(testId)
+        }
+      }
+      if (disabledIds) {
+        runPayload._ddDisabledTestIds = disabledIds
+      }
+      return runTestGroup.apply(this, arguments)
+    })
+  }
+
   worker.on('testBegin', ({ testId }) => {
     const test = getTestByTestId(dispatcher, testId)
+    if (!test) return
+
     const browser = getBrowserNameFromProjects(projects, test)
     const shouldCreateTestSpan = test.expectedStatus === 'skipped'
     testBeginHandler(test, browser, shouldCreateTestSpan)
   })
   worker.on('testEnd', ({ testId, status, errors, annotations }) => {
     const test = getTestByTestId(dispatcher, testId)
+    if (!test) return
 
     const isTimeout = status === 'timedOut'
     const testStatus = STATUS_TO_TEST_STATUS[status]
@@ -1308,6 +1333,7 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
     efdSlowAbortedTests.clear()
     ddPropertiesByTestId.clear()
     ddPropertiesRequestsByTestId.clear()
+    disabledTestIds.clear()
 
     // TODO: we can trick playwright into thinking the session passed by returning
     // 'passed' here. We might be able to use this for both EFD and Test Management tests.
@@ -1552,6 +1578,7 @@ function processRootSuite (createRootSuiteReturnValue) {
       if (testProperties.disabled) {
         test._ddIsDisabled = true
         if (!testProperties.attemptToFix) {
+          disabledTestIds.add(test.id)
           test.expectedStatus = 'skipped'
           // setting test.expectedStatus to 'skipped' does not work for every case,
           // so we need to filter out disabled tests in dispatcherRunWrapperNew,
@@ -1795,7 +1822,17 @@ function instrumentWorkerMainMethods (workerMain) {
   let steps = []
   const stepInfoByStepId = {}
 
+  shimmer.wrap(workerMain, 'runTestGroup', runTestGroup => function (runPayload) {
+    const disabledIds = runPayload._ddDisabledTestIds
+    this[kDdPlaywrightDisabledTestIds] = disabledIds ? new Set(disabledIds) : undefined
+    return runTestGroup.apply(this, arguments)
+  })
+
   shimmer.wrap(workerMain, '_runTest', _runTest => async function (test) {
+    if (this[kDdPlaywrightDisabledTestIds]?.has(test.id)) {
+      test._ddIsDisabled = true
+      test.expectedStatus = 'skipped'
+    }
     await waitForEfdRetryCount(test)
     if (shouldSkipEfdRetry(test)) {
       test._ddShouldSkipEfdRetry = true
@@ -2042,9 +2079,9 @@ function generateSummaryWrapper (generateSummary) {
   return function (...args) {
     for (const test of this.suite.allTests()) {
       // https://github.com/microsoft/playwright/blob/bf92ffecff6f30a292b53430dbaee0207e0c61ad/packages/playwright/src/reporters/base.ts#L279
-      const didNotRun = test.outcome() === 'skipped' &&
-        (!test.results.length || test.expectedStatus !== 'skipped')
-      if (didNotRun && !testsReportedInGenerateSummary.has(test)) {
+      const shouldReportAsSkipped = test.outcome() === 'skipped' &&
+        (disabledTestIds.has(test.id) || !test.results.length || test.expectedStatus !== 'skipped')
+      if (shouldReportAsSkipped && !testsReportedInGenerateSummary.has(test)) {
         testsReportedInGenerateSummary.add(test)
         const {
           _requireFile: testSuiteAbsolutePath,

package/packages/datadog-instrumentations/src/vitest-main.js

@@ -457,7 +457,6 @@ async function runMainProcessSetup (ctx, frameworkVersion, testSpecifications, s
       testCommand,
       repositoryRoot: receivedRepositoryRoot,
       codeOwnersEntries,
-      testEnvironmentMetadata,
     } = testSessionConfiguration
     repositoryRoot = receivedRepositoryRoot || repositoryRoot
     if (!shouldInstallNoWorkerInit) {
@@ -467,7 +466,6 @@ async function runMainProcessSetup (ctx, frameworkVersion, testSpecifications, s
         _ddTestCommand: testCommand,
         _ddRepositoryRoot: repositoryRoot,
         _ddCodeOwnersEntries: codeOwnersEntries,
-        _ddTestEnvironmentMetadata: testEnvironmentMetadata,
       }, 'Could not send test session configuration to workers.')
     }
   }

package/packages/datadog-instrumentations/src/vitest-util.js

@@ -116,7 +116,6 @@ function getProvidedContext () {
       _ddTestCommand: testCommand,
       _ddRepositoryRoot: repositoryRoot,
       _ddCodeOwnersEntries: codeOwnersEntries,
-      _ddTestEnvironmentMetadata: testEnvironmentMetadata,
     } = globalThis.__vitest_worker__.providedContext
 
     return {
@@ -138,7 +137,6 @@ function getProvidedContext () {
       testCommand,
       repositoryRoot,
       codeOwnersEntries,
-      testEnvironmentMetadata,
     }
   } catch {
     log.error('Vitest workers could not parse provided context, so some features will not work.')
@@ -161,7 +159,6 @@ function getProvidedContext () {
       testCommand: undefined,
       repositoryRoot: undefined,
       codeOwnersEntries: undefined,
-      testEnvironmentMetadata: undefined,
     }
   }
 }

package/packages/datadog-instrumentations/src/vitest-worker.js

@@ -657,7 +657,6 @@ addHook({
       testCommand: providedContext.testCommand,
       repositoryRoot: providedContext.repositoryRoot,
       codeOwnersEntries: providedContext.codeOwnersEntries,
-      testEnvironmentMetadata: providedContext.testEnvironmentMetadata,
     }
     testSuiteStartCh.runStores(testSuiteCtx, () => {})
     const startTestsResponse = await startTests.apply(this, arguments)

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

@@ -65,6 +65,7 @@ class AzureFunctionsPlugin extends TracingPlugin {
         service: this.serviceName(),
         type: 'serverless',
         meta,
+        childOf: null,
       }, ctx)
 
       if (isMessagingService) {
@@ -142,7 +143,7 @@ function mapTriggerTag (methodName) {
 // 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 cardinality = ctx.invocationContext.options.trigger.cardinality ?? 'one'
   const triggerMetadata = ctx.invocationContext.triggerMetadata
   const isServiceBus = triggerType === 'ServiceBus'
 

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

@@ -5,12 +5,10 @@ const dc = require('dc-polyfill')
 const { storage } = require('../../datadog-core')
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
 const GraphQLParsePlugin = require('./parse')
-const { extractErrorIntoSpanEvent, getSignature } = require('./utils')
+const { extractErrorIntoSpanEvent, getOperation, getSignature } = require('./utils')
 
 const legacyStorage = storage('legacy')
 
-const types = new Set(['query', 'mutation', 'subscription'])
-
 const iastResolveCh = dc.channel('apm:graphql:resolve:start')
 const resolverStartCh = dc.channel('datadog:graphql:resolver:start')
 const updateFieldCh = dc.channel('apm:graphql:resolve:updateField')
@@ -115,9 +113,11 @@ class GraphQLExecutePlugin extends TracingPlugin {
 
     ctx.collapse = this.config.collapse
 
+    const signature = getSignature(document, name, type, this.config.signature)
+
     const span = this.startSpan(this.operationName(), {
       service: this.config.service || this.serviceName(),
-      resource: getSignature(document, name, type, this.config.signature),
+      resource: signature,
       kind: this.constructor.kind,
       type: this.constructor.type,
       meta: {
@@ -669,17 +669,6 @@ function defaultFieldResolver (source, args, contextValue, info) {
   }
 }
 
-function getOperation (document, operationName) {
-  if (!document || !Array.isArray(document.definitions)) return
-
-  for (const definition of document.definitions) {
-    if (definition && types.has(definition.operation) &&
-        (!operationName || definition.name?.value === operationName)) {
-      return definition
-    }
-  }
-}
-
 function addVariableTags (config, span, variableValues) {
   if (!variableValues || !config.variables) return
 

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

@@ -6,6 +6,7 @@ const CompositePlugin = require('../../dd-trace/src/plugins/composite')
 const log = require('../../dd-trace/src/log')
 const GraphQLExecutePlugin = require('./execute')
 const GraphQLParsePlugin = require('./parse')
+const GraphQLRequestPlugin = require('./request')
 const GraphQLValidatePlugin = require('./validate')
 
 class GraphQLPlugin extends CompositePlugin {
@@ -14,6 +15,11 @@ class GraphQLPlugin extends CompositePlugin {
     return {
       execute: GraphQLExecutePlugin,
       parse: GraphQLParsePlugin,
+      // Top-level request span for drivers (mercurius) that funnel through a
+      // single entry point and parse/execute internally. graphql-js, apollo,
+      // and yoga produce no such channel, so the plugin simply never fires for
+      // them.
+      request: GraphQLRequestPlugin,
       validate: GraphQLValidatePlugin,
       // resolve plugin is absorbed into execute: per-field data is recorded
       // synchronously in wrapResolve, and all graphql.resolve spans are

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

@@ -0,0 +1,104 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+const { extractErrorIntoSpanEvent, getCachedRequestOperation } = require('./utils')
+
+// Top-level GraphQL request span for drivers that funnel every operation
+// through a single entry point but parse/validate/execute internally (mercurius
+// today). It parents the `graphql.parse`/`graphql.validate`/`graphql.execute`
+// (or JIT) sub-spans and carries the request text + operation name/type, which
+// otherwise have no home when the query is JIT-compiled and `graphql.execute`
+// never fires.
+//
+// The entry boundary only hands us the raw `source` (string or pre-parsed AST)
+// and `operationName`; the parsed document — and therefore the precise
+// operation signature — is only known once mercurius parses internally. On the
+// cold path the `validate` sub-plugin refines the resource/operation tags onto
+// this span via `ctx.currentStore.graphqlRequestSpan` once the document is
+// available, so we never re-parse on the hot path. On the JIT warm path no
+// sub-span fires, so we recover the same tags from the cache the cold path
+// populated, keyed by source + operationName.
+class GraphQLRequestPlugin extends TracingPlugin {
+  static id = 'graphql'
+  static operation = 'request'
+  static type = 'graphql'
+  static kind = 'server'
+  static prefix = 'tracing:orchestrion:mercurius:apm:graphql:request'
+
+  bindStart (ctx) {
+    // fastifyGraphQl(source, context, variables, operationName)
+    const source = ctx.arguments?.[0]
+    const operationName = ctx.arguments?.[3]
+
+    // `source` is the request text on the common path, but mercurius also
+    // accepts a pre-parsed document AST; only a string is the query text, and
+    // `graphql.source` carries only the text form.
+    const docSource = typeof source === 'string' ? source : undefined
+
+    // Warm (JIT-compiled) path: execute never fires, so recover the operation
+    // signature/type the cold path cached, keyed by source + operationName —
+    // by query text for a string, by document identity for a pre-parsed AST.
+    // Empty on the cold path — validate hasn't refined yet — where the request
+    // span is refined from the parsed document instead.
+    const cached = getCachedRequestOperation(source, operationName)
+
+    const span = this.startSpan(this.operationName({ id: 'request' }), {
+      service: this.config.service || this.serviceName(),
+      // The cached signature is the precise resource; otherwise provisional and
+      // refined by the validate sub-plugin once the document is parsed.
+      // `operationName` is the best name at the boundary; falls back to the
+      // operation signature once validate sees the document.
+      resource: cached?.signature || operationName || undefined,
+      kind: this.constructor.kind,
+      type: this.constructor.type,
+      meta: {
+        'graphql.operation.type': cached?.type,
+        'graphql.operation.name': cached?.name || operationName,
+        'graphql.source': this.config.source ? docSource : undefined,
+      },
+    }, ctx)
+
+    // Hand the span, the requested operation name, and the raw source to the
+    // validate sub-plugin running inside this store so it can refine the
+    // resource + operation tags from the parsed document (validate is the first
+    // boundary that has it) and cache them keyed by the source the request
+    // boundary saw. The raw source is the cache key — validate sees mercurius's
+    // internally parsed document, not the caller's source, and for a pre-parsed
+    // AST the two are different objects.
+    ctx.currentStore.graphqlRequestSpan = span
+    ctx.currentStore.graphqlRequestOperationName = operationName
+    ctx.currentStore.graphqlRequestSource = source
+
+    return ctx.currentStore
+  }
+
+  asyncEnd (ctx) {
+    /* istanbul ignore next: currentStore is populated for the request lifecycle; activeSpan is base-plugin fallback. */
+    const span = ctx?.currentStore?.span || this.activeSpan
+    /* istanbul ignore if: startSpan always populates currentStore for the request lifecycle. */
+    if (!span) return ctx.parentStore
+
+    const result = ctx.result
+    if (result?.errors?.length) {
+      span.setTag('error', result.errors[0])
+      for (const error of result.errors) {
+        extractErrorIntoSpanEvent(this.config, span, error)
+      }
+    }
+
+    span.finish()
+
+    return ctx.parentStore
+  }
+
+  error (ctx) {
+    /* istanbul ignore next: currentStore is populated for request errors; activeSpan is base-plugin fallback. */
+    const span = ctx?.currentStore?.span || this.activeSpan
+    /* istanbul ignore else: errors are only routed after the request span has started. */
+    if (span && ctx?.error) {
+      span.setTag('error', ctx.error)
+    }
+  }
+}
+
+module.exports = GraphQLRequestPlugin

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

@@ -1,5 +1,179 @@
 'use strict'
 
+const { LRUCache } = require('../../../vendor/dist/lru-cache')
+
+/**
+ * @typedef {{ signature?: string, type?: string, name?: string }} RequestOperation
+ */
+
+const operationTypes = new Set(['query', 'mutation', 'subscription'])
+
+// Mercurius funnels every operation through `fastifyGraphQl`, but the parsed
+// document — and therefore the operation signature/type/name — is only known
+// once mercurius parses internally. The top-level request span opens before
+// that, and on the JIT warm path neither parse/validate nor execute fires, so
+// the span would otherwise be left with only the provisional resource. The cold
+// path caches the computed metadata; the request boundary reads it back on the
+// warm path. Bounded so a flood of distinct queries can't grow it without limit.
+//
+// The key is the operation name plus the raw query text, not the source alone:
+// mercurius keys its document LRU by source but compiles the JIT for a single
+// `operationName`, and the compiled query then serves that operation for every
+// later request that shares the source — regardless of the `operationName` those
+// requests ask for. A source-only key would hand a warm request for operation B
+// the metadata of whichever operation was cached last for that source (A),
+// mislabeling the span. Operation names cannot contain a newline, so it is a
+// safe separator that keeps the two parts from colliding.
+const requestOperationCache = new LRUCache({ max: 500 })
+
+// Mercurius also accepts a pre-parsed document AST as the source, which reaches
+// the request boundary as an object rather than query text — so there is no
+// string to key the LRU by. Mercurius keys its own document LRU by that source
+// object's identity, and the same object reaches the boundary on the warm path,
+// so a WeakMap keyed by the caller-owned document recovers the metadata without
+// mutating the document and releases with it. The value carries the requested
+// operation name so a JIT-only sibling selection is not handed another
+// operation's metadata (same reason the string cache keys by operation name).
+/** @type {WeakMap<object, Map<string | undefined, RequestOperation>>} */
+const documentOperationCache = new WeakMap()
+
+/**
+ * @param {string} source - The raw query text; the same key mercurius uses.
+ * @param {string | undefined} operationName - The requested operation name.
+ * @returns {string}
+ */
+function requestOperationKey (source, operationName) {
+  return `${operationName ?? ''}\n${source}`
+}
+
+/**
+ * @param {unknown} source - Query text on the common path; a pre-parsed
+ *   document AST otherwise. Any other shape (mercurius rejects it before
+ *   execute) has no cache entry and yields undefined.
+ * @param {string | undefined} operationName - The requested operation name.
+ * @returns {RequestOperation | undefined}
+ */
+function getCachedRequestOperation (source, operationName) {
+  if (typeof source === 'string') {
+    return requestOperationCache.get(requestOperationKey(source, operationName))
+  }
+  if (source === null || typeof source !== 'object') return
+  return documentOperationCache.get(source)?.get(operationName)
+}
+
+/**
+ * A string source keys the text LRU; a document AST keys the WeakMap. Any other
+ * shape has no usable key — mercurius rejects it before execute, so the warm
+ * path never reaches the request span for it either.
+ *
+ * @param {unknown} source
+ * @returns {source is string | object}
+ */
+function isCacheableSource (source) {
+  return typeof source === 'string' || (source !== null && typeof source === 'object')
+}
+
+/**
+ * Select the operation definition matching `operationName`, or the first one
+ * when no name is given (graphql/mercurius default selection).
+ *
+ * @param {import('graphql').DocumentNode | undefined} document
+ * @param {string | undefined} operationName
+ * @returns {import('graphql').OperationDefinitionNode | undefined}
+ */
+function getOperation (document, operationName) {
+  /* istanbul ignore if: validate/execute only call this with a parsed GraphQL document. */
+  if (!document || !Array.isArray(document.definitions)) return
+
+  for (const definition of document.definitions) {
+    if (operationTypes.has(definition?.operation) &&
+        (!operationName || definition.name?.value === operationName)) {
+      return definition
+    }
+  }
+}
+
+/**
+ * Refine the top-level graphql.request span (mercurius) from the parsed
+ * document and cache the metadata so the JIT warm path — where no sub-span
+ * fires — can recover the same tags at the request boundary.
+ *
+ * This runs at the first boundary that has the document (validate on the cold
+ * path, which also precedes a pre-execute validation failure). It is idempotent
+ * across the later execute boundary via the `ddRequestRefined` flag, and a
+ * no-op for graphql-js/apollo/yoga, which never open a request span.
+ *
+ * Every named operation in the document is cached, not just the selected one:
+ * a multi-operation document parses once, and a later request may select a
+ * sibling operation that mercurius then serves exclusively through its JIT path
+ * (no execute span), so its metadata has to be ready before that happens.
+ *
+ * @param {import('../../dd-trace/src/opentracing/span') | undefined} requestSpan
+ * @param {import('graphql').DocumentNode | undefined} document
+ * @param {unknown} requestSource - The raw source the request boundary saw:
+ *   query text on the common path, a pre-parsed document AST otherwise. The
+ *   cache is keyed by it, not by the parsed document, so the request boundary
+ *   recovers the metadata on the warm path from the same value mercurius keys
+ *   its own document LRU by. Any other shape has no usable key and is not
+ *   cached (the warm path never reaches this span for it either).
+ * @param {string | undefined} operationName - The requested operation name.
+ * @param {boolean} calculateSignature - The graphql plugin's `signature` config.
+ */
+function refineRequestSpan (requestSpan, document, requestSource, operationName, calculateSignature) {
+  /* istanbul ignore if: validate only refines after the request span and parsed document exist. */
+  if (!requestSpan || requestSpan.ddRequestRefined || !document) return
+  requestSpan.ddRequestRefined = true
+
+  const operation = getOperation(document, operationName)
+  const type = operation?.operation
+  const name = operation?.name?.value
+  const signature = getSignature(document, name, type, calculateSignature)
+
+  if (signature) requestSpan.setTag('resource.name', signature)
+  if (type) requestSpan.setTag('graphql.operation.type', type)
+  if (name) requestSpan.setTag('graphql.operation.name', name)
+
+  if (!isCacheableSource(requestSource)) return
+
+  // Cache the selected operation under the requested name (undefined selects
+  // the document's first operation, so it shares the entry with that name).
+  cacheRequestOperation(requestSource, operationName, { signature, type, name })
+
+  // Cache every named operation so a JIT-only sibling selection is labeled from
+  // this single parse instead of falling back to a bare operation name.
+  for (const definition of document.definitions) {
+    const definitionName = definition?.name?.value
+    if (definitionName === undefined || !operationTypes.has(definition.operation)) continue
+    if (definitionName === operationName) continue
+
+    cacheRequestOperation(requestSource, definitionName, {
+      signature: getSignature(document, definitionName, definition.operation, calculateSignature),
+      type: definition.operation,
+      name: definitionName,
+    })
+  }
+}
+
+/**
+ * @param {string | import('graphql').DocumentNode} source - Query text keys the
+ *   text LRU; a caller-owned document AST keys the WeakMap (never mutated).
+ * @param {string | undefined} operationName - The requested operation name.
+ * @param {RequestOperation} operation
+ */
+function cacheRequestOperation (source, operationName, operation) {
+  if (typeof source === 'string') {
+    requestOperationCache.set(requestOperationKey(source, operationName), operation)
+    return
+  }
+
+  let operations = documentOperationCache.get(source)
+  if (operations === undefined) {
+    operations = new Map()
+    documentOperationCache.set(source, operations)
+  }
+  operations.set(operationName, operation)
+}
+
 /**
  * @param {{ errorExtensions?: string[] }} config Resolved plugin config; `errorExtensions` lists the
  *   GraphQL error `extensions` keys to copy onto the span event.
@@ -84,5 +258,8 @@ function getSignature (document, operationName, operationType, calculate) {
 
 module.exports = {
   extractErrorIntoSpanEvent,
+  getCachedRequestOperation,
+  getOperation,
   getSignature,
+  refineRequestSpan,
 }

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

@@ -1,8 +1,11 @@
 'use strict'
 
+const { storage } = require('../../datadog-core')
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
 const GraphQLParsePlugin = require('./parse')
-const { extractErrorIntoSpanEvent } = require('./utils')
+const { extractErrorIntoSpanEvent, refineRequestSpan } = require('./utils')
+
+const legacyStorage = storage('legacy')
 
 class GraphQLValidatePlugin extends TracingPlugin {
   static id = 'graphql'
@@ -15,6 +18,26 @@ class GraphQLValidatePlugin extends TracingPlugin {
     const docSource = document ? GraphQLParsePlugin.documentSources.get(document) : undefined
     const source = this.config.source && document && docSource
 
+    // Refine the top-level graphql.request span (mercurius) from the parsed
+    // document. validate is the first boundary that has it and precedes both
+    // execute and any pre-execute rejection (unknown field, GET mutation), so a
+    // failing request still ends up with a resource and operation tags. The
+    // request span, its operation name, and the raw source ride the active
+    // store the request boundary entered (validate's own `ctx.currentStore` is
+    // not populated yet). The cache is keyed by that raw source, not the parsed
+    // document — for a pre-parsed AST mercurius validates a structuredClone, so
+    // the document here is a different object from the one the boundary saw and
+    // recovers on the warm path. No-op for graphql-js/apollo/yoga, which never
+    // open a request span.
+    const requestStore = legacyStorage.getStore()
+    refineRequestSpan(
+      requestStore?.graphqlRequestSpan,
+      document,
+      requestStore?.graphqlRequestSource,
+      requestStore?.graphqlRequestOperationName,
+      this.config.signature
+    )
+
     this.startSpan('graphql.validate', {
       service: this.config.service,
       type: 'graphql',