dd-trace 6.15.0 → 6.16.0

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

@@ -8,46 +8,28 @@ const ch = dc.tracingChannel('apm:openai:request')
 const onStreamedChunkCh = dc.channel('apm:openai:request:chunk')
 const responsePromiseContexts = new WeakMap()
 
-// Provider lifecycle channels. Payloads stay OpenAI-native:
-// before { args, parentSpan, abortController, pending }
-// after  { args, body, parentSpan, abortController, pending }
-const chatCompletionsBeforeChannel = dc.channel('dd-trace:openai:chat.completions:before')
-const chatCompletionsAfterChannel = dc.channel('dd-trace:openai:chat.completions:after')
-const responsesBeforeChannel = dc.channel('dd-trace:openai:responses:before')
-const responsesAfterChannel = dc.channel('dd-trace:openai:responses:after')
-
-const LIFECYCLE_CHANNELS = {
-  'chat.completions': {
-    before: chatCompletionsBeforeChannel,
-    after: chatCompletionsAfterChannel,
-  },
-  responses: {
-    before: responsesBeforeChannel,
-    after: responsesAfterChannel,
-  },
-}
+// Published synchronously with the native call data. A subscriber may set either callback and
+// this instrumentation applies it, so the wrapping stays here and only the policy lives outside:
+//   beforeResult () => Promise<void>|undefined   holds the result back until it settles
+//   onResult (body) => unknown|Promise<unknown>  inspects or replaces the delivered body
+const chatCompletionsInterceptChannel = dc.channel('dd-trace:openai:chat.completions:intercept')
+const responsesInterceptChannel = dc.channel('dd-trace:openai:responses:intercept')
 
 /**
- * Publishes a provider-native lifecycle payload to a cancelable lifecycle channel.
- *
- * Subscribers push async work into `pending` synchronously during publication and
- * abort `abortController` with an error before the pushed promise resolves to block.
+ * Returns `promise`, but not before `settled` settles, so a rejection from an interceptor
+ * reaches the caller instead of the SDK's value.
  *
- * @param {object} channel
- * @param {object} payload
- * @returns {Promise<void>}
+ * @template T
+ * @param {Promise<T>} promise
+ * @param {Promise<void>|undefined} settled
+ * @returns {Promise<T>}
  */
-function publishLifecycle (channel, payload) {
-  const abortController = new AbortController()
-  const ctx = { ...payload, abortController, pending: [] }
+function heldUntil (promise, settled) {
+  if (!settled) return promise
 
-  channel.publish(ctx)
-
-  return Promise.all(ctx.pending).then(() => {
-    if (abortController.signal.aborted) {
-      throw abortController.signal.reason
-    }
-  })
+  // The interceptor's rejection wins over an earlier SDK rejection, so keep that one handled.
+  promise.catch(() => {})
+  return settled.then(() => promise)
 }
 
 const V4_PACKAGE_SHIMS = [
@@ -57,6 +39,7 @@ const V4_PACKAGE_SHIMS = [
     baseResource: 'chat.completions',
     methods: ['create'],
     streamedResponse: true,
+    interceptChannel: chatCompletionsInterceptChannel,
   },
   {
     file: 'resources/completions',
@@ -72,6 +55,7 @@ const V4_PACKAGE_SHIMS = [
     methods: ['create'], // implicitly covers `parse` as well which calls `create` under the hood
     streamedResponse: true,
     versions: ['>=4.87.0'],
+    interceptChannel: responsesInterceptChannel,
   },
   {
     file: 'resources/embeddings',
@@ -185,6 +169,7 @@ const V4_PACKAGE_SHIMS = [
     methods: ['create'],
     streamedResponse: true,
     versions: ['>=4.85.0'],
+    interceptChannel: chatCompletionsInterceptChannel,
   },
 ]
 
@@ -287,13 +272,11 @@ for (const extension of extensions) {
         return handleUnwrappedAPIPromise(parsedPromise, state)
       })
 
+      // Raw-response callers bypass `parse`, so run the interceptor here too.
       shimmer.wrap(prototype, 'asResponse', asResponse => function (...args) {
         const state = responsePromiseContexts.get(this.responsePromise)
-        const responsePromise = asResponse.apply(this, args)
-
-        if (!state?.getBeforeVerdict) return responsePromise
 
-        return Promise.all([state.getBeforeVerdict(), responsePromise]).then(([, response]) => response)
+        return heldUntil(asResponse.apply(this, args), state?.interceptCtx?.beforeResult?.())
       })
 
       return exports
@@ -303,7 +286,7 @@ for (const extension of extensions) {
 
 for (const extension of extensions) {
   for (const shim of V4_PACKAGE_SHIMS) {
-    const { file, targetClass, baseResource, methods, versions, streamedResponse } = shim
+    const { file, targetClass, baseResource, methods, versions, streamedResponse, interceptChannel } = shim
     addHook({ name: 'openai', file: file + extension, versions: versions || ['>=4'] }, exports => {
       const targetPrototype = exports[targetClass].prototype
 
@@ -314,10 +297,9 @@ for (const extension of extensions) {
           // chat.completions and completions
           const stream = streamedResponse && getOption(args, 'stream', false)
 
-          const channels = stream ? null : LIFECYCLE_CHANNELS[baseResource]
-          const hasLifecycle = !!channels && (channels.before.hasSubscribers || channels.after.hasSubscribers)
+          const intercepted = !stream && interceptChannel?.hasSubscribers
 
-          if (!ch.start.hasSubscribers && !hasLifecycle) {
+          if (!ch.start.hasSubscribers && !intercepted) {
             return methodFn.apply(this, args)
           }
 
@@ -330,24 +312,21 @@ for (const extension of extensions) {
           }
 
           return ch.start.runStores(ctx, () => {
-            // Capture the parent span explicitly: the _thenUnwrap/parse path decouples
-            // the lazy evaluation from the active scope at call time.
-            const parentSpan = hasLifecycle ? ctx.currentStore?.span : undefined
-
             const apiProm = methodFn.apply(this, args)
 
-            const beforeChannel = hasLifecycle && channels.before.hasSubscribers ? channels.before : null
-            const afterChannel = hasLifecycle && channels.after.hasSubscribers ? channels.after : null
-            let beforeVerdict
-            const getBeforeVerdict = beforeChannel
-              ? function getBeforeVerdict () {
-                beforeVerdict ??= publishLifecycle(beforeChannel, { args, parentSpan })
-                return beforeVerdict
-              }
-              : null
+            let interceptCtx
+            if (intercepted) {
+              interceptCtx = { arguments: args, tracingContext: ctx }
+              interceptChannel.publish(interceptCtx)
+            }
 
-            const state = { ctx, stream, getBeforeVerdict, afterChannel, parentSpan }
-            responsePromiseContexts.set(apiProm.responsePromise, state)
+            // Keyed by the response promise rather than the APIPromise: `_thenUnwrap` builds a new
+            // APIPromise around the same response, which is how `responses.parse` and the
+            // pagination page types reach the prototype wrappers above. A method that resolves to
+            // a plain value has none, and a WeakMap rejects a non-object key.
+            if (apiProm?.responsePromise) {
+              responsePromiseContexts.set(apiProm.responsePromise, { ctx, stream, interceptCtx })
+            }
 
             ch.end.publish(ctx)
 
@@ -361,20 +340,17 @@ for (const extension of extensions) {
 }
 
 function handleUnwrappedAPIPromise (apiProm, state) {
-  const { ctx, stream, getBeforeVerdict, afterChannel, parentSpan } = state
-  const gatedApiProm = getBeforeVerdict
-    ? Promise.all([getBeforeVerdict(), apiProm]).then(([, result]) => result)
-    : apiProm
+  const { ctx, stream, interceptCtx } = state
 
-  return gatedApiProm
+  return heldUntil(apiProm, interceptCtx?.beforeResult?.())
     .then(([{ response, options }, body]) => {
       if (stream) {
+        const wrapIterator = wrapStreamIterator(response, options, ctx)
+
         if (body.iterator) {
-          shimmer.wrap(body, 'iterator', wrapStreamIterator(response, options, ctx))
+          shimmer.wrap(body, 'iterator', wrapIterator)
         } else {
-          shimmer.wrap(
-            body.response.body, Symbol.asyncIterator, wrapStreamIterator(response, options, ctx)
-          )
+          shimmer.wrap(body.response.body, Symbol.asyncIterator, wrapIterator)
         }
         return body
       }
@@ -388,28 +364,29 @@ function handleUnwrappedAPIPromise (apiProm, state) {
         },
       }
 
-      if (!afterChannel) {
+      if (!interceptCtx?.onResult) {
         finish(ctx, responseData)
         return body
       }
 
-      // Finish after evaluation so a block propagates the error to openai.request
-      // and the span wraps its child instead of closing before it.
-      return publishLifecycle(afterChannel, { args: ctx.args, body, parentSpan }).then(() => {
+      // Finish after the callback settles so a rejection propagates to openai.request and the
+      // span wraps its child instead of closing before it.
+      return Promise.resolve(interceptCtx.onResult(body)).then(deliveredBody => {
         finish(ctx, responseData)
-        return body
+        return deliveredBody
       })
     })
     .catch(error => {
-      // ctx.result is set inside finish(); if absent, finish never ran (sync throw in the success
-      // branch, Before Model block, After Model block, or openai error) — record the error now so
-      // the openai.request span is marked errored. If finish already ran, don't double-publish.
-      if (!ctx.result) finish(ctx, undefined, error)
+      finish(ctx, undefined, error)
       throw error
     })
 }
 
 function finish (ctx, response, error) {
+  // `parse` is re-entered on every await of the same APIPromise, and a stream may be iterated
+  // more than once, so the span must only close once.
+  if (ctx.finished) return
+
   if (error) {
     ctx.error = error
     ch.error.publish(ctx)
@@ -419,6 +396,7 @@ function finish (ctx, response, error) {
   // so we don't want to override it here
   ctx.result ??= {}
   Object.assign(ctx.result, response)
+  ctx.finished = true
 
   ch.asyncEnd.publish(ctx)
 }

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

@@ -718,7 +718,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
     const isAtf = attemptToFixTasks.has(task)
     const isEfd = efdRetryTasks.has(task)
     const shouldTrackStatuses = isEfd || isAtf
-    const shouldFlipStatus = isEfd || isAtf
+    const shouldResetStatus = isEfd || isAtf
     const statuses = isAtf ? attemptToFixTaskToStatuses.get(task) : taskToStatuses.get(task)
 
     // These clauses handle task.repeats, whether EFD is enabled or not
@@ -738,13 +738,10 @@ function wrapVitestTestRunner (VitestTestRunner) {
         if (shouldTrackStatuses && statuses) {
           statuses.push(lastExecutionStatus)
         }
-        if (shouldFlipStatus) {
-          // If we don't "reset" the result.state to "pass", once a repetition fails,
-          // vitest will always consider the test as failed, so we can't read the actual status
-          // This means that we change vitest's behavior:
-          // if the last attempt passes, vitest would consider the test as failed
-          // but after this change, it will consider the test as passed
-          task.result.state = 'pass'
+        if (shouldResetStatus) {
+          // Reset to Vitest's neutral state so a previous failure does not affect the next repetition.
+          // A terminal pass state can leak into reporters before the next repetition determines its status.
+          task.result.state = 'run'
         }
       }
     } else if (numRepetition === task.repeats) {
@@ -759,8 +756,8 @@ function wrapVitestTestRunner (VitestTestRunner) {
       } else {
         testPassCh.publish({ task, ...ctx.currentStore })
       }
-      if (shouldFlipStatus) {
-        task.result.state = 'pass'
+      if (shouldResetStatus) {
+        task.result.state = 'run'
       }
     }
 

package/packages/datadog-plugin-aws-sdk/src/services/bedrockruntime/utils.js

@@ -500,6 +500,8 @@ function extractMessagesFromConverseContent (role, contentBlocks) {
       if (block == null || typeof block !== 'object') continue
       if (typeof block.text === 'string') {
         content += block.text
+      } else if (typeof block.guardContent?.text?.text === 'string') {
+        content += block.guardContent.text.text
       } else if (block.toolUse) {
         toolCalls.push(buildToolCall(block.toolUse))
       } else if (block.toolResult) {
@@ -611,7 +613,11 @@ function extractRequestParamsConverse (params) {
   const prompt = []
   if (params.system) {
     for (const block of params.system) {
-      if (typeof block?.text === 'string') prompt.push({ content: block.text, role: 'system' })
+      if (typeof block?.text === 'string') {
+        prompt.push({ content: block.text, role: 'system' })
+      } else if (typeof block?.guardContent?.text?.text === 'string') {
+        prompt.push({ content: block.guardContent.text.text, role: 'system' })
+      }
     }
   }
   if (params.messages) {

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

@@ -26,7 +26,7 @@ class AzureCosmosPlugin extends DatabasePlugin {
       const result = ctx.result
       if (result?.code) span.setTag('db.response.status_code', (result.code).toString())
       if (result?.substatus) span.setTag('cosmosdb.response.sub_status_code', result.substatus)
-      span.finish()
+      this.finish(ctx)
     }
   }
 

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

@@ -1,6 +1,12 @@
 'use strict'
 
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+const { AUTO_KEEP } = require('../../../ext/priority')
+const { writeTraceparent, writeTracestate } = require('../../dd-trace/src/carrier')
+
+const ORCHESTRATION_FAILURE_END_CHANNEL =
+  'tracing:orchestrion:durable-functions:TaskOrchestrationExecutor_failure:end'
+const ORCHESTRATOR_COMPLETED_EVENT_TYPE = 13
 
 class AzureDurableFunctionsPlugin extends TracingPlugin {
   static get id () { return 'azure-durable-functions' }
@@ -9,9 +15,35 @@ class AzureDurableFunctionsPlugin extends TracingPlugin {
   static get type () { return 'serverless' }
   static get kind () { return 'server' }
 
+  addTraceSubs () {
+    super.addTraceSubs()
+    this.addSub(ORCHESTRATION_FAILURE_END_CHANNEL, this.orchestrationFailure)
+  }
+
   bindStart (ctx) {
+    // Continue the trace propagated by the Durable Functions host (W3C traceparent
+    // supplied on the invocation's traceContext) so activity/entity invocations join
+    // the same trace as the HTTP root instead of each starting a new root.
+    let childOf
+    if (ctx.traceparent) {
+      // extract() returns null when the carrier can't be parsed. Normalize to
+      // undefined so startSpan still falls back to any active in-process parent
+      // rather than being forced to start a brand new root span.
+      const carrier = {}
+
+      writeTraceparent(carrier, ctx.traceparent)
+      if (ctx.tracestate) {
+        writeTracestate(carrier, ctx.tracestate)
+      }
+
+      childOf = this.tracer.extract('text_map', carrier) ?? undefined
+    }
+    const extractedAsDrop = childOf?._sampling.priority < AUTO_KEEP
+
     const span = this.startSpan(this.operationName(), {
-      kind: 'internal',
+      startTime: ctx.startTime,
+      childOf,
+      kind: ctx.trigger === 'Orchestration' ? 'server' : 'internal',
       type: 'serverless',
 
       meta: {
@@ -29,6 +61,19 @@ class AzureDurableFunctionsPlugin extends TracingPlugin {
       )
     }
 
+    // The host clears the W3C sampled flag in traceparent while datadog tracestate
+    // still says keep, so extraction would drop this chunk. Re-apply only the propagated
+    // `s` priority when it indicates keep, preserving the extracted sampling mechanism.
+    if (span._prioritySampler && childOf && extractedAsDrop) {
+      const propagatedPriority = propagatedSamplingPriority(childOf._tracestate)
+      if (propagatedPriority >= AUTO_KEEP) {
+        const spanContext = span.context()
+        if (spanContext._parentId === childOf._spanId) {
+          spanContext._sampling.priority = propagatedPriority
+        }
+      }
+    }
+
     ctx.span = span
     return ctx.currentStore
   }
@@ -44,6 +89,56 @@ class AzureDurableFunctionsPlugin extends TracingPlugin {
   asyncStart (ctx) {
     super.finish(ctx)
   }
+
+  /**
+   * Tags the active initial orchestration span or creates a failure-only span after
+   * a resumed orchestration throws. The executor publishes synchronously before
+   * Durable Functions serializes the error, so this does not add a promise to
+   * orchestration activations.
+   *
+   * @param {{ arguments?: unknown[], error?: unknown }} executorCtx
+   * @returns {void}
+   */
+  orchestrationFailure (executorCtx) {
+    const args = executorCtx?.arguments
+    if (!Array.isArray(args)) return
+
+    const invocationContext = args[0]
+    const history = args[1]
+    if (!Array.isArray(history)) return
+
+    const hasPreviousActivation = history.some(
+      event => event?.EventType === ORCHESTRATOR_COMPLETED_EVENT_TYPE
+    )
+
+    if (!hasPreviousActivation) {
+      this.addError(executorCtx.error)
+      return
+    }
+
+    const traceContext = invocationContext?.traceContext
+    const ctx = {
+      trigger: 'Orchestration',
+      functionName: invocationContext?.functionName,
+      traceparent: traceContext?.traceParent,
+      tracestate: traceContext?.traceState,
+      error: executorCtx.error,
+    }
+
+    this.bindStart(ctx)
+    this.error(ctx)
+    super.finish(ctx)
+  }
+}
+
+// Read the datadog-propagated sampling priority (`dd=...;s:<n>`) from a W3C
+// tracestate. Returns undefined when there is no datadog tracestate or no valid
+// `s` value, so callers can distinguish "no propagated decision" from a drop.
+function propagatedSamplingPriority (tracestate) {
+  return tracestate?.forVendor('dd', state => {
+    const priority = Number(state.get('s'))
+    return Number.isInteger(priority) ? priority : undefined
+  })
 }
 
 module.exports = AzureDurableFunctionsPlugin

package/packages/datadog-plugin-google-cloud-pubsub/src/consumer.js

@@ -2,9 +2,8 @@
 
 const { getMessageSize } = require('../../dd-trace/src/datastreams')
 const ConsumerPlugin = require('../../dd-trace/src/plugins/consumer')
-const SpanContext = require('../../dd-trace/src/opentracing/span_context')
-const id = require('../../dd-trace/src/id')
 const { storage } = require('../../datadog-core')
+const reconstructPubSubRequestContext = require('./pubsub-request-context')
 
 /**
  * PULL SUBSCRIPTION: Service explicitly pulls messages from Pub/Sub and processes them.
@@ -75,27 +74,6 @@ class GoogleCloudPubsubConsumerPlugin extends ConsumerPlugin {
     })
   }
 
-  #reconstructPubSubRequestContext (attrs) {
-    const traceIdLower = attrs['_dd.pubsub_request.trace_id']
-    const spanId = attrs['_dd.pubsub_request.span_id']
-    const traceIdUpper = attrs['_dd.pubsub_request.p.tid']
-
-    if (!traceIdLower || !spanId) return null
-
-    const traceId128 = traceIdUpper ? traceIdUpper + traceIdLower : traceIdLower.padStart(32, '0')
-    const traceId = id(traceId128, 16)
-    const parentId = id(spanId, 16)
-
-    const tags = {}
-    if (traceIdUpper) tags['_dd.p.tid'] = traceIdUpper
-
-    return new SpanContext({
-      traceId,
-      spanId: parentId,
-      tags,
-    })
-  }
-
   start (ctx) {
     if (!this.config.dsmEnabled) return
     const { message } = ctx
@@ -128,7 +106,7 @@ class GoogleCloudPubsubConsumerPlugin extends ConsumerPlugin {
 
     const isFirstMessage = batchIndex === 0
     if (isFirstMessage && batchRequestSpanId) {
-      const pubsubRequestContext = this.#reconstructPubSubRequestContext(message.attributes)
+      const pubsubRequestContext = reconstructPubSubRequestContext(message.attributes)
       if (pubsubRequestContext) {
         childOf = pubsubRequestContext
       }

package/packages/datadog-plugin-google-cloud-pubsub/src/pubsub-push-subscription.js

@@ -1,9 +1,8 @@
 'use strict'
 
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
-const SpanContext = require('../../dd-trace/src/opentracing/span_context')
-const id = require('../../dd-trace/src/id')
 const log = require('../../dd-trace/src/log')
+const reconstructPubSubRequestContext = require('./pubsub-request-context')
 
 // WeakMap to track push receive spans by request
 const pushReceiveSpans = new WeakMap()
@@ -69,7 +68,7 @@ class GoogleCloudPubsubPushSubscriptionPlugin extends TracingPlugin {
     }
 
     const originalContext = this.#extractContext(messageData)
-    const pubsubRequestContext = this.#reconstructPubSubContext(messageData.attrs) || originalContext
+    const pubsubRequestContext = reconstructPubSubRequestContext(messageData.attrs) || originalContext
     const isSameTrace = pubsubRequestContext &&
       originalContext?.toTraceId() === pubsubRequestContext.toTraceId()
 
@@ -109,39 +108,6 @@ class GoogleCloudPubsubPushSubscriptionPlugin extends TracingPlugin {
     return this.tracer.extract('text_map', messageData.attrs)
   }
 
-  #reconstructPubSubContext (attrs) {
-    /**
-     * Reconstruct the batch publish span context from message attributes.
-     *
-     * When a batch is published, the producer injects:
-     * - _dd.pubsub_request.trace_id: lower 64 bits of the batch span's trace ID (hex)
-     * - _dd.pubsub_request.span_id: the batch span's span ID (hex)
-     * - _dd.pubsub_request.p.tid: upper 64 bits of trace ID (hex, optional for 128-bit traces)
-     *
-     * This context represents the "pubsub.request" span on the producer side.
-     * We use it to create span links, connecting each pubsub.push.receive span back to the original batch.
-     */
-    const traceIdLower = attrs['_dd.pubsub_request.trace_id']
-    const spanId = attrs['_dd.pubsub_request.span_id']
-    const traceIdUpper = attrs['_dd.pubsub_request.p.tid']
-
-    if (!traceIdLower || !spanId) return null
-
-    // Reconstruct full 128-bit trace ID (or pad 64-bit to 128-bit)
-    const traceId128 = traceIdUpper ? traceIdUpper + traceIdLower : traceIdLower.padStart(32, '0')
-    const traceId = id(traceId128, 16)
-    const parentId = id(spanId, 16)
-
-    const tags = {}
-    if (traceIdUpper) tags['_dd.p.tid'] = traceIdUpper
-
-    return new SpanContext({
-      traceId,
-      spanId: parentId,
-      tags,
-    })
-  }
-
   #createPushReceiveSpan (messageData, parentContext, linkContext) {
     const { message, subscription, topicName, attrs } = messageData
     const subscriptionName = subscription?.slice(subscription.lastIndexOf('/') + 1) ?? subscription

package/packages/datadog-plugin-google-cloud-pubsub/src/pubsub-request-context.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const SpanContext = require('../../dd-trace/src/opentracing/span_context')
+const id = require('../../dd-trace/src/id')
+
+/**
+ * @param {Record<string, string>} attributes
+ * @returns {import('../../dd-trace/src/opentracing/span_context') | null}
+ */
+function reconstructPubSubRequestContext (attributes) {
+  const traceIdLower = attributes['_dd.pubsub_request.trace_id']
+  const spanId = attributes['_dd.pubsub_request.span_id']
+  const traceIdUpper = attributes['_dd.pubsub_request.p.tid']
+
+  if (!traceIdLower || !spanId) return null
+
+  const traceId128 = traceIdUpper ? traceIdUpper + traceIdLower : traceIdLower.padStart(32, '0')
+  const traceId = id(traceId128, 16)
+  const parentId = id(spanId, 16)
+
+  const tags = {}
+  if (traceIdUpper) tags['_dd.p.tid'] = traceIdUpper
+
+  return new SpanContext({
+    traceId,
+    spanId: parentId,
+    tags,
+  })
+}
+
+module.exports = reconstructPubSubRequestContext

package/packages/datadog-plugin-graphql/src/resolve-error.js

@@ -61,28 +61,50 @@ class GraphQLToolsResolveErrorPlugin extends TracingPlugin {
  * @param {readonly object[]} [fieldNodes]
  */
 function recordResolveErrorForPath (error, path, fieldNodes) {
-  const fieldNode = fieldNodes?.[0]
   const rootCtx = legacyStorage.getStore()?.graphqlRootCtx
-  for (let field = rootCtx?.resolveFields; field; field = field.nextResolveField) {
-    if ((!fieldNode || field.fieldNode === fieldNode) && matchesPath(field.pathString, path)) {
-      recordResolveError(field, error)
-      return
-    }
-  }
+  if (!rootCtx?.config.collapse || !rootCtx.fields) return
+
+  const field = findResolveField(rootCtx.fields, getPathString(path), fieldNodes?.[0])
+  if (field) recordResolveError(field, error)
 }
 
 /**
- * @param {string} fieldPath
  * @param {(string | number)[]} path
- * @returns {boolean}
+ * @returns {string}
  */
-function matchesPath (fieldPath, path) {
+function getPathString (path) {
   let pathString = ''
   for (let index = 0; index < path.length; index++) {
     if (index !== 0) pathString += '.'
     pathString += typeof path[index] === 'number' ? '*' : path[index]
   }
-  return pathString === fieldPath
+  return pathString
+}
+
+/**
+ * @param {Map<unknown, object>} fields
+ * @param {string} pathString
+ * @param {object} [fieldNode]
+ * @returns {object | undefined}
+ */
+function findResolveField (fields, pathString, fieldNode) {
+  const field = fields.get(pathString)
+  if (field === undefined) return
+
+  const parentTypeFields = field.parentTypeFields
+  if (parentTypeFields === undefined) {
+    return fieldNode === undefined || field.fieldNode === fieldNode ? field : undefined
+  }
+  if (parentTypeFields.parentTypeName !== undefined) {
+    if (fieldNode === undefined || parentTypeFields.fieldNode === fieldNode) return parentTypeFields
+    return field.fieldNode === fieldNode ? field : undefined
+  }
+
+  let matchingField
+  for (const candidate of parentTypeFields.values()) {
+    if (fieldNode === undefined || candidate.fieldNode === fieldNode) matchingField = candidate
+  }
+  return matchingField
 }
 
 /**