dd-trace 5.124.0 → 5.125.0

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

@@ -1,31 +1,52 @@
 'use strict'
 
+const { AsyncResource } = require('node:async_hooks')
+
 const dc = require('dc-polyfill')
 
 const { storage } = require('../../datadog-core')
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
 const GraphQLParsePlugin = require('./parse')
-const { extractErrorIntoSpanEvent, getOperation, getSignature, isApolloHealthCheck } = require('./utils')
+const { recordResolveError } = require('./resolve-error')
+const {
+  extractErrorIntoSpanEvent,
+  getBaseTypeName,
+  getOperation,
+  getSignature,
+  isApolloHealthCheck,
+  refineRequestSpanMetadata,
+} = require('./utils')
+
+/**
+ * @typedef {import('../../dd-trace/src/opentracing/span')} DatadogSpan
+ * @typedef {import('../../datadog-instrumentations/src/helpers/graphql-jit-runtime').JitFieldDescriptor} JitDescriptor
+ * @typedef {import('graphql').GraphQLFieldResolver<unknown, unknown>} GraphQLFieldResolver
+ * @typedef {Parameters<GraphQLFieldResolver> & { [index: number]: unknown, length: number }} ArgumentsList
+ * @typedef {{
+ *   schema?: import('graphql').GraphQLSchema,
+ *   document?: import('graphql').DocumentNode,
+ *   rootValue?: unknown,
+ *   contextValue?: unknown,
+ *   variableValues?: Record<string, unknown>,
+ *   operationName?: string | null,
+ *   fieldResolver?: GraphQLFieldResolver
+ * }} ExecutionArguments
+ * @typedef {(value: unknown) => unknown} ThenableCallback
+ * @typedef {{ then: (onFulfilled?: ThenableCallback, onRejected?: ThenableCallback) => unknown }} Thenable
+ * @typedef {import('../../datadog-instrumentations/src/helpers/graphql-jit-runtime').ArgumentFactory} ArgumentFactory
+ */
 
 const legacyStorage = storage('legacy')
 
 const iastResolveCh = dc.channel('apm:graphql:resolve:start')
 const resolverStartCh = dc.channel('datadog:graphql:resolver:start')
-const updateFieldCh = dc.channel('apm:graphql:resolve:updateField')
-
-// AppSec/WAF abort gate. Published synchronously from bindStart with a
-// payload carrying the abortController; subscribers that call
-// `payload.abortController.abort()` signal a pre-execute abort. bindStart
-// observes the aborted signal by replacing `ctx.arguments[0]` with a Proxy
-// whose getters throw AbortError — the orchestrion-emitted wrapper's
-// `try { __apm$traced() } catch { ...; throw err }` block then propagates
-// the AbortError to the caller of graphql.execute.
-const startExecuteCh = dc.channel('apm:graphql:execute:start')
 
 const contexts = new WeakMap()
 const instrumentedArgs = new WeakSet()
 
 const patchedResolvers = new WeakSet()
+const jitResolvers = new WeakMap()
+const originalResolvers = new WeakMap()
 
 // Visited types per caller-owned schema. The walk reaches union members and
 // interface implementations through the schema (`getTypes`/`getPossibleTypes`),
@@ -44,6 +65,18 @@ let depthDisabled = false
 // operation's variableValues is undefined.
 const NO_VARIABLES_CACHED = Symbol('noVariablesCached')
 
+// `field.endTime` stays numeric: 0 is pending, -1 means a collapsed span was reused,
+// and positive values are exact completion times. Pending and reused spans finish at the execution boundary.
+const PENDING_FIELD_END_TIME = 0
+const REUSED_FIELD_END_TIME = -1
+
+let asyncDisposeSymbol = Symbol.asyncDispose
+// @graphql-tools/executor uses this fallback before Node.js exposes Symbol.asyncDispose.
+/* istanbul ignore if */
+if (asyncDisposeSymbol === undefined) {
+  asyncDisposeSymbol = Symbol.for('asyncDispose')
+}
+
 class AbortError extends Error {
   constructor (message) {
     super(message)
@@ -51,6 +84,58 @@ class AbortError extends Error {
   }
 }
 
+/**
+ * @param {GraphQLExecutePlugin} plugin
+ * @param {DatadogSpan} executeSpan
+ * @param {string | undefined} source
+ * @param {AbortController | undefined} abortController
+ * @param {{ fields: object[] } | undefined} jitPlan
+ * @param {Record<string, unknown> | undefined} variableValues
+ * @returns {object}
+ */
+function createRootContext (plugin, executeSpan, source, abortController, jitPlan, variableValues) {
+  const hasIastSub = iastResolveCh.hasSubscribers
+  const hasResolverSub = abortController !== undefined
+  const traceResolvers = plugin.config.depth !== 0
+
+  // Read by the generated gate in every inlined default field.
+  const traceAll = hasIastSub || hasResolverSub ||
+    (traceResolvers && !plugin.config.collapse)
+
+  const rootCtx = {
+    source,
+    config: plugin.config,
+    abortController,
+    executeSpan,
+    plugin,
+    filteredVariablesKey: NO_VARIABLES_CACHED,
+    filteredVariables: undefined,
+    depthDisabled: !traceResolvers,
+    hasIastSub,
+    hasResolverSub,
+    jitTraceAll: traceAll,
+    jitTraceFirst: !traceAll && traceResolvers && plugin.config.collapse,
+    variableValues,
+  }
+
+  if (jitPlan) {
+    rootCtx.jitPlan = jitPlan
+    if (traceResolvers) {
+      if (plugin.config.collapse) {
+        rootCtx.jitFields = new Array(jitPlan.fields.length)
+      } else {
+        rootCtx.jitFieldsByPath = new Map()
+      }
+    }
+  }
+  if (traceResolvers && (!jitPlan || !plugin.config.collapse)) {
+    rootCtx.fields = new Map()
+    rootCtx.pathCache = new Map()
+  }
+
+  return rootCtx
+}
+
 class GraphQLExecutePlugin extends TracingPlugin {
   static id = 'graphql'
   static operation = 'execute'
@@ -95,10 +180,13 @@ class GraphQLExecutePlugin extends TracingPlugin {
     }
   }
 
-  bindStart (ctx) {
+  /**
+   * @param {object} ctx
+   * @returns {ExecutionArguments | undefined}
+   */
+  readExecutionArgs (ctx) {
     const rawArgs = ctx.arguments
-    const objectForm = isObjectForm(rawArgs)
-    const args = readArgs(rawArgs, objectForm)
+    const args = readArgs(rawArgs, isObjectForm(rawArgs))
 
     // Re-entrant execute() short-circuit (yoga's normalizedExecutor calls
     // execute internally with the same arguments object — without this we'd
@@ -106,36 +194,93 @@ class GraphQLExecutePlugin extends TracingPlugin {
     // check also catches primitive contexts.
     if (instrumentedArgs.has(rawArgs?.[0])) {
       ctx.ddSkipped = true
-      return ctx.currentStore
+      ctx.currentStore = legacyStorage.getStore()
+      return
     }
 
     const { contextValue } = args
     if (contextValue && typeof contextValue === 'object' && contexts.has(contextValue)) {
       ctx.ddSkipped = true
-      return ctx.currentStore
+      return
     }
 
+    return args
+  }
+
+  /**
+   * @param {object} ctx
+   * @param {ExecutionArguments} args
+   */
+  wrapExecutionResolvers (ctx, args) {
+    const rawArgs = ctx.arguments
+    ctx.ddArgs = setWrappedFieldResolver(rawArgs, args, isObjectForm(rawArgs), defaultFieldResolver)
+    if (ctx.ddArgs && typeof ctx.ddArgs === 'object') {
+      instrumentedArgs.add(ctx.ddArgs)
+      ctx.ddInstrumentedArgs = ctx.ddArgs
+    }
+
+    const { schema } = args
+    if (schema) {
+      wrapFields(schema._queryType, schema)
+      wrapFields(schema._mutationType, schema)
+      wrapFields(schema._subscriptionType, schema)
+    }
+  }
+
+  /**
+   * @param {object} ctx
+   * @param {unknown} contextValue
+   * @param {object} rootCtx
+   */
+  storeRootContext (ctx, contextValue, rootCtx) {
+    ctx.currentStore.graphqlRootCtx = rootCtx
+    if (isWeakMapKey(contextValue)) {
+      contexts.set(contextValue, rootCtx)
+      ctx.ddContextValue = contextValue
+    }
+  }
+
+  /**
+   * @param {object} ctx
+   */
+  bindStart (ctx) {
+    const args = this.readExecutionArgs(ctx)
+    if (!args) return ctx.currentStore
+
+    const { contextValue } = args
     const document = args.document
     const docSource = document ? GraphQLParsePlugin.documentSources.get(document) : undefined
     const operation = getOperation(document, args.operationName)
 
     const type = operation?.operation
-    const name = operation?.name?.value
+    const name = operation?.name?.value ?? args.operationName ?? undefined
+    let signature = name ?? ''
     const source = this.config.source && docSource
 
     // Apollo Server may execute a cached document without parsing it first.
     // Match the full gateway operation here so caller-owned AST transformations
     // cannot suppress execute/resolver AppSec and IAST channels.
     if (name === '__ApolloServiceHealthCheck__' &&
-        document.definitions.length === 1 &&
+        document?.definitions?.length === 1 &&
         isApolloHealthCheck(operation)) {
       ctx.ddSkipped = true
       return ctx.currentStore
     }
 
-    ctx.collapse = this.config.collapse
+    const requestStore =
+      /** @type {{ graphqlRequestSpan?: DatadogSpan } | undefined} */ (legacyStorage.getStore())
+    if (type !== undefined) {
+      signature = getSignature(
+        /** @type {import('graphql').DocumentNode} */ (document),
+        name,
+        type,
+        this.config.signature
+      )
+      refineRequestSpanMetadata(requestStore?.graphqlRequestSpan, signature, type, name)
+    }
 
-    const signature = getSignature(document, name, type, this.config.signature)
+    ctx.collapse = this.config.collapse
+    ctx.ddOperationType = type
 
     const span = this.startSpan(this.operationName(), {
       service: this.config.service || this.serviceName(),
@@ -151,71 +296,13 @@ class GraphQLExecutePlugin extends TracingPlugin {
 
     addVariableTags(this.config, span, args.variableValues)
 
-    const abortController = new AbortController()
-
-    // AppSec/WAF synchronous-abort gate. Publish before any resolver-wrapping
-    // work — if a subscriber aborts, none of that work matters because we'll
-    // make execute's body throw AbortError before it reaches any resolvers.
-    // bindStart runs as a bindStore transform on
-    // tracing:orchestrion:graphql:apm:graphql:execute:start, which fires
-    // BEFORE the orchestrion-emitted wrapper publishes its own :start and
-    // BEFORE the wrapped fn runs. The subscriber gets the abortController
-    // synchronously; on return we observe `signal.aborted` and act.
-    if (startExecuteCh.hasSubscribers) {
-      startExecuteCh.publish({ abortController, args })
-      if (abortController.signal.aborted) {
-        // Replace ctx.arguments[0] with a Proxy that throws AbortError on any
-        // property access. The orchestrion wrapper calls
-        // `__apm$wrapped.apply(this, ctx.arguments)`; graphql.execute's body
-        // begins with `const { schema, document, ... } = args` so the
-        // destructure triggers the trap immediately. The wrapper catches and
-        // rethrows, propagating AbortError to graphql.execute's caller.
-        ctx.arguments[0] = new Proxy({}, {
-          get () { throw new AbortError('Aborted') },
-          has () { throw new AbortError('Aborted') },
-        })
-        ctx.ddAborted = true
-        return ctx.currentStore
-      }
-    }
-
-    ctx.ddArgs = setWrappedFieldResolver(rawArgs, args, objectForm, defaultFieldResolver)
-    if (ctx.ddArgs && typeof ctx.ddArgs === 'object') {
-      instrumentedArgs.add(ctx.ddArgs)
-      ctx.ddInstrumentedArgs = ctx.ddArgs
-    }
+    const abortController = resolverStartCh.hasSubscribers ? new AbortController() : undefined
 
-    const schema = args.schema
-    if (schema) {
-      wrapFields(schema._queryType, schema)
-      wrapFields(schema._mutationType, schema)
-      wrapFields(schema._subscriptionType, schema)
-    }
+    this.wrapExecutionResolvers(ctx, args)
 
-    const rootCtx = {
-      source: docSource,
-      config: this.config,
-      fields: new Map(),
-      pathCache: new Map(),
-      abortController,
-      executeSpan: span,
-      plugin: this,
-      // graphql.resolve variable tags: memoize the filtered result for the
-      // last-seen variableValues object (see #filterVariables).
-      filteredVariablesKey: NO_VARIABLES_CACHED,
-      filteredVariables: undefined,
-    }
+    const rootCtx = createRootContext(this, span, docSource, abortController, ctx.ddPlan, args.variableValues)
     ctx.ddRootCtx = rootCtx
-    if (isWeakMapKey(contextValue)) {
-      contexts.set(contextValue, rootCtx)
-      ctx.ddContextValue = contextValue
-    } else {
-      // Primitive / non-keyable contextValue: stash rootCtx on the
-      // orchestrion-scoped store that runStores enters for execute. Wrapped
-      // resolvers read it via legacyStorage.getStore() and it unwinds with the
-      // frame — no enterWith store that leaks past execute.
-      ctx.currentStore.graphqlRootCtx = rootCtx
-    }
+    this.storeRootContext(ctx, contextValue, rootCtx)
 
     return ctx.currentStore
   }
@@ -226,14 +313,14 @@ class GraphQLExecutePlugin extends TracingPlugin {
     const span = ctx?.currentStore?.span || this.activeSpan
     if (!span) return
 
+    if (ctx.ddRootCtx && legacyStorage.getStore() !== ctx.currentStore) {
+      legacyStorage.enterWith(ctx.currentStore)
+    }
+
     // Synchronous execute() throw (e.g. execute(null, doc)) — error handler
     // already tagged the span.
     if (ctx.error) {
-      if (ctx.ddAborted) {
-        span.finish()
-      } else {
-        this.#finishSpan(ctx, span)
-      }
+      this.#finishSpan(ctx, span)
       return ctx.parentStore
     }
 
@@ -242,7 +329,7 @@ class GraphQLExecutePlugin extends TracingPlugin {
     if (typeof result?.then === 'function') {
       result.then(
         (res) => this.#finishSpan(ctx, span, res),
-        (err) => this.#finishSpan(ctx, span, undefined, err)
+        (error) => this.#finishSpan(ctx, span, undefined, error)
       )
     } else {
       this.#finishSpan(ctx, span, result)
@@ -252,9 +339,6 @@ class GraphQLExecutePlugin extends TracingPlugin {
   }
 
   error (ctx) {
-    // Pre-execute WAF abort isn't an error condition — opSpan.error must
-    // stay 0 per master's contract.
-    if (ctx.ddAborted) return
     const span = ctx?.currentStore?.span || this.activeSpan
     if (span && ctx?.error) {
       span.setTag('error', ctx.error)
@@ -266,17 +350,30 @@ class GraphQLExecutePlugin extends TracingPlugin {
    * @param {import('../../dd-trace/src/opentracing/span')} span
    * @param {import('graphql').ExecutionResult} [res]
    * @param {unknown} [error]
+   * @param {boolean} [incrementalComplete]
+   * @param {boolean} [finishPendingFields]
    */
-  #finishSpan (ctx, span, res, error) {
+  #finishSpan (ctx, span, res, error, incrementalComplete = false, finishPendingFields = false) {
+    if (!incrementalComplete && error === undefined && ctx.ddOperationType !== 'subscription') {
+      const iterator = getIncrementalIterator(res)
+      if (iterator) {
+        tagIncrementalResult(this.config, span, res?.initialResult)
+        observeIncrementalIterator(iterator, (result, iteratorError, iteratorCancelled, complete) => {
+          tagIncrementalResult(this.config, span, result)
+          if (complete) {
+            this.#finishSpan(ctx, span, res, iteratorError, true, iteratorCancelled)
+          }
+        })
+        return
+      }
+    }
+
     if (error !== undefined) {
       span.setTag('error', error)
     }
 
     if (res?.errors?.length) {
-      span.setTag('error', res.errors[0])
-      for (const err of res.errors) {
-        extractErrorIntoSpanEvent(this.config, span, err)
-      }
+      tagExecutionErrors(this.config, span, res.errors)
     }
 
     if (ctx.ddContextValue) {
@@ -286,18 +383,33 @@ class GraphQLExecutePlugin extends TracingPlugin {
       instrumentedArgs.delete(ctx.ddInstrumentedArgs)
     }
 
+    const rootCtx = ctx.ddRootCtx
+    const releaseBeforeExecuteHook = rootCtx?.resolveHooksPending === true
+    if (releaseBeforeExecuteHook) {
+      releaseRootContext(rootCtx, finishPendingFields)
+    } else if (rootCtx?.jitResolveHooksPending === true) {
+      runResolveHooks(rootCtx)
+    }
     this.config.hooks.execute(span, ctx.ddArgs, res)
-
+    if (!releaseBeforeExecuteHook) releaseRootContext(rootCtx, finishPendingFields)
     span.finish()
   }
 
   // Public — called from wrapResolve (free function, crosses class boundary).
-  // Resolve-span creation is inline at first-encounter; deferring to a batch
-  // produces a bursty encoder stall when many spans finish together.
-  startResolveSpan (field, rootCtx, executeSpan, startTime) {
-    const { fieldNode, fieldName, returnType, baseTypeName, variableValues, collapsedKey } = field
+  // Resolve-span creation stays inline so child fields can parent immediately.
+  /**
+   * @param {object} field
+   * @param {object} rootCtx
+   * @param {DatadogSpan} executeSpan
+   * @param {number} startTime
+   * @param {Record<string, unknown> | undefined} variableValues
+   * @param {object | null} [parentField]
+   * @returns {DatadogSpan}
+   */
+  startResolveSpan (field, rootCtx, executeSpan, startTime, variableValues, parentField) {
+    const { fieldNode, fieldName, returnType, baseTypeName, collapsedKey } = field
 
-    const parent = getParentField(rootCtx, field)
+    const parent = parentField === undefined ? getParentField(rootCtx, field) : parentField
     const childOf = parent?.span || executeSpan
 
     const document = rootCtx.source
@@ -305,24 +417,29 @@ class GraphQLExecutePlugin extends TracingPlugin {
     const source = loc && document.slice(loc.start, loc.end)
 
     // ctx form: startSpan sets field.currentStore = { ...activeStore, span }
-    // without entering it. Only the field's first resolver call runs in that
-    // store (isFirst check in wrapResolve); siblings use field.parentStore.
+    // without entering it. Collapsed siblings reuse that store until execute
+    // completes and finishes the shared span.
+    const meta = field.tags ?? {
+      'graphql.field.coordinates': `${field.parentTypeName}.${fieldName}`,
+      'graphql.field.name': fieldName,
+      'graphql.field.path': collapsedKey,
+      'graphql.field.type': baseTypeName,
+      'graphql.source': source,
+    }
     const span = this.startSpan('graphql.resolve', {
       service: this.config.service,
-      resource: `${fieldName}:${returnType}`,
+      resource: field.resource ?? `${fieldName}:${returnType}`,
       childOf,
       type: 'graphql',
       startTime,
-      meta: {
-        'graphql.field.coordinates': `${field.parentTypeName}.${fieldName}`,
-        'graphql.field.name': fieldName,
-        'graphql.field.path': collapsedKey,
-        'graphql.field.type': baseTypeName,
-        'graphql.source': source,
-      },
+      meta,
     }, field)
 
     field.span = span
+    if (rootCtx.config.collapse) {
+      field.nextResolveField = rootCtx.resolveFields
+      rootCtx.resolveFields = field
+    }
 
     if (fieldNode && this.config.variables && fieldNode.arguments) {
       const variables = this.#filterVariables(rootCtx, variableValues)
@@ -358,30 +475,83 @@ class GraphQLExecutePlugin extends TracingPlugin {
     return filtered
   }
 
-  // Public — called from wrapResolve. endTime reflects when the resolver
-  // actually completed, not when the field record was created.
-  finishResolveSpan (span, field, error, result, endTime) {
+  /**
+   * @param {object} rootCtx
+   * @param {object} field
+   * @param {unknown} error
+   * @param {unknown} result
+   * @param {boolean} [failed]
+   */
+  completeResolveSpan (rootCtx, field, error, result, failed = false) {
+    if (rootCtx.resolveFields !== undefined) {
+      if (field.endTime !== REUSED_FIELD_END_TIME) {
+        field.endTime = rootCtx.executeSpan._getTime()
+      }
+      if (field.jitPathKey === false) {
+        if (failed) recordResolveError(field, error)
+        if (this.config.hooks.resolve) {
+          field.resolveHookContext = createResolveHookContext(field, field.error, result)
+          rootCtx.resolveHooksPending = true
+        }
+        return
+      }
+      if (field.isSharedJitField) {
+        if (error) recordResolveError(field, error)
+        if (this.config.hooks.resolve) {
+          field.resolveHookContext = createResolveHookContext(field, field.error, result)
+          rootCtx.jitResolveHooksPending = true
+        }
+        return
+      }
+      this.#completeResolveSpan(field, error, result)
+      return
+    }
+
+    this.#finishResolveSpan(field, error, result, rootCtx.executeSpan._getTime())
+  }
+
+  /**
+   * @param {object} field
+   * @param {unknown} error
+   * @param {unknown} result
+   * @param {number} endTime
+   */
+  #finishResolveSpan (field, error, result, endTime) {
+    this.#completeResolveSpan(field, error, result)
+    field.span.finish(endTime)
+  }
+
+  /**
+   * @param {object} field
+   * @param {unknown} error
+   * @param {unknown} result
+   */
+  #completeResolveSpan (field, error, result) {
+    const { span } = field
     if (error) span.setTag('error', error)
 
     if (this.config.hooks.resolve) {
-      this.config.hooks.resolve(span, {
-        fieldName: field.fieldName,
-        path: field.pathString,
-        error: error || null,
-        // Any thenable from any realm — keep undefined so the hook doesn't
-        // accidentally see the unresolved promise.
-        result: typeof result?.then === 'function' ? undefined : result,
-      })
+      this.config.hooks.resolve(span, createResolveHookContext(field, error, result))
     }
-
-    span.finish(endTime)
   }
 }
 
 // --- resolver wrapping --------------------------------------------------------
 
-function wrapResolve (resolve) {
-  if (typeof resolve !== 'function' || patchedResolvers.has(resolve)) return resolve
+/**
+ * @param {GraphQLFieldResolver} resolve
+ * @param {boolean} [isJit]
+ */
+function wrapResolve (resolve, isJit = false) {
+  /* istanbul ignore next: future GraphQL versions may expose a non-callable resolver entry. */
+  if (typeof resolve !== 'function' || (!isJit && patchedResolvers.has(resolve))) return resolve
+
+  // Replace a schema wrapper with the execution-local JIT variant instead of nesting both.
+  resolve = unwrapResolve(resolve)
+  if (isJit) {
+    const jitResolver = jitResolvers.get(resolve)
+    if (jitResolver !== undefined) return jitResolver
+  }
 
   function resolveAsync (source, args, contextValue, info) {
     const hasIastSub = iastResolveCh.hasSubscribers
@@ -390,48 +560,57 @@ function wrapResolve (resolve) {
     // Combined fast-path: depth=0 AND no IAST/AppSec subscriber means nothing
     // to do — skip rootCtx lookup, path walk, publish gates.
     if (depthDisabled && !hasIastSub && !hasResolverSub) {
-      return resolve.apply(this, arguments)
+      return invokeResolver(resolve, this, arguments, isJit)
     }
 
-    const rootCtx = contexts.get(contextValue) ?? legacyStorage.getStore()?.graphqlRootCtx
-    if (!rootCtx) return resolve.apply(this, arguments)
+    const rootCtx = isJit
+      ? legacyStorage.getStore()?.graphqlRootCtx
+      : contexts.get(contextValue) ?? legacyStorage.getStore()?.graphqlRootCtx
+    if (!rootCtx) return invokeResolver(resolve, this, arguments, isJit)
 
     const infoPath = info?.path
     const config = rootCtx.config
+    const traceResolver = !depthDisabled && shouldInstrumentNode(config, infoPath)
 
     // pathString built incrementally off the parent's cached value
     // (rootCtx.pathCache, keyed by path node) — avoids re-walking the whole
     // path linked-list on every resolver call, which is O(depth) per call for
-    // deeply nested resolvers. Shared between the IAST publish and the field
-    // record. Collapse-aware: list-index segments become '*'.
+    // deeply nested resolvers. Collapse-aware: list-index segments become '*'.
     let pathString
     let collapsedKey
-    if (infoPath) {
-      pathString = buildCachedPathString(infoPath, rootCtx.pathCache, config.collapse)
+    if (infoPath && traceResolver) {
+      const pathCache = rootCtx.pathCache ??= new Map()
+      pathString = buildCachedPathString(infoPath, pathCache, config.collapse)
       if (config.collapse) collapsedKey = pathString
     }
 
     // IAST and AppSec subscribers see EVERY resolver call, regardless of
     // depth or collapse. The depth knob caps span creation only.
     if (hasIastSub) {
-      iastResolveCh.publish({ rootCtx, args, info, path: pathToArray(infoPath), pathString })
+      iastResolveCh.publish({ rootCtx, args })
     }
     if (hasResolverSub) {
       resolverStartCh.publish({
         abortController: rootCtx.abortController,
-        resolverInfo: getResolverInfo(info, args),
+        createResolverInfo,
+        info,
+        args,
       })
     }
 
-    if (depthDisabled || !shouldInstrumentNode(config, infoPath)) {
-      if (rootCtx.abortController?.signal.aborted) {
-        throw new AbortError('Aborted')
-      }
+    if (rootCtx.abortController?.signal.aborted) {
+      throw new AbortError('Aborted')
+    }
 
-      return resolve.apply(this, arguments)
+    if (!traceResolver) {
+      return invokeResolver(resolve, this, arguments, isJit)
     }
 
-    const fieldKey = config.collapse ? pathString : infoPath
+    // Compilations performed while tracing is disabled have no static JIT
+    // descriptor. Their resolver-info path nodes are recreated for each
+    // resolver, so use the stable path string to preserve span parenting.
+    const useStringKey = config.collapse || isJit
+    const fieldKey = useStringKey ? pathString : infoPath
     const parentTypeName = info.parentType.name
     let field = rootCtx.fields.get(fieldKey)
     const collapsedField = field
@@ -457,14 +636,13 @@ function wrapResolve (resolve) {
         parentTypeName,
         returnType: info.returnType,
         baseTypeName: getBaseTypeName(info.returnType),
-        variableValues: info.variableValues,
-        args,
+        endTime: PENDING_FIELD_END_TIME,
         infoPath,
+        jitPathKey: isJit,
         pathString,
         collapsedKey: collapsedKey ?? pathString,
         span: null,
-        // Set by startResolveSpan; currentStore is used by the first resolver
-        // call only, siblings use parentStore (see the isFirst check below).
+        // Set by startResolveSpan; collapsed siblings reuse currentStore.
         parentStore: null,
         currentStore: null,
       }
@@ -487,38 +665,355 @@ function wrapResolve (resolve) {
       } else {
         rootCtx.fields.set(fieldKey, field)
       }
-    }
-
-    // Collapsed siblings still publish updateField (master's contract: one
-    // publish per resolver call, even when the span is collapsed) and route
-    // through callInAsyncScope so the abort signal stops them mid-flight. They
-    // run in the parent store, not field.currentStore: the first sibling's
-    // synchronous resolver already finished the shared graphql.resolve span, so
-    // re-entering its store would parent user spans to a closed span.
-    // eslint-disable-next-line unicorn/prefer-else-if -- Keep sibling early return outside first-field setup.
-    if (!isFirst) {
-      return callInAsyncScope(resolve, this, arguments, rootCtx.abortController, field.parentStore, (err) => {
-        if (updateFieldCh.hasSubscribers) {
-          updateFieldCh.publish({ rootCtx, field, error: err, pathString: field.pathString })
-        }
-      })
+    } else {
+      field.endTime = REUSED_FIELD_END_TIME
+      return callInCollapsedScope(
+        resolve,
+        this,
+        arguments,
+        field,
+        isJit
+      )
     }
 
     const executeSpan = rootCtx.executeSpan
     const startTime = executeSpan._getTime()
-    const span = rootCtx.plugin.startResolveSpan(field, rootCtx, executeSpan, startTime)
+    rootCtx.plugin.startResolveSpan(field, rootCtx, executeSpan, startTime, info.variableValues)
+
+    /**
+     * @param {unknown} error
+     * @param {unknown} res
+     * @param {boolean} failed
+     */
+    const finishField = (error, res, failed) => {
+      rootCtx.plugin?.completeResolveSpan(rootCtx, field, error, res, failed)
+    }
+    return callInAsyncScope(resolve, this, arguments, field.currentStore, finishField, isJit)
+  }
 
-    return callInAsyncScope(resolve, this, arguments, rootCtx.abortController, field.currentStore, (err, res) => {
-      const endTime = executeSpan._getTime()
-      rootCtx.plugin.finishResolveSpan(span, field, err, res, endTime || startTime)
-      if (updateFieldCh.hasSubscribers) {
-        updateFieldCh.publish({ rootCtx, field, error: err, pathString: field.pathString })
-      }
+  if (isJit) {
+    jitResolvers.set(resolve, resolveAsync)
+  } else {
+    patchedResolvers.add(resolveAsync)
+  }
+  originalResolvers.set(resolveAsync, resolve)
+  return resolveAsync
+}
+
+/**
+ * @param {GraphQLFieldResolver} resolve
+ * @returns {GraphQLFieldResolver}
+ */
+function unwrapResolve (resolve) {
+  return originalResolvers.get(resolve) ?? resolve
+}
+
+/**
+ * @param {object} rootCtx
+ * @param {number} descriptorId
+ * @param {GraphQLFieldResolver} resolve
+ * @param {unknown} self
+ * @param {unknown} source
+ * @param {Record<string, unknown>} args
+ * @param {unknown} contextValue
+ * @param {import('graphql').GraphQLResolveInfo} info
+ * @returns {unknown}
+ */
+function resolveCompiledJitField (rootCtx, descriptorId, resolve, self, source, args, contextValue, info) {
+  const descriptor = rootCtx.jitPlan.fields[descriptorId]
+  const config = rootCtx.config
+
+  if (rootCtx.hasIastSub) {
+    iastResolveCh.publish({ rootCtx, args })
+  }
+  if (rootCtx.hasResolverSub) {
+    resolverStartCh.publish({
+      abortController: rootCtx.abortController,
+      createResolverInfo,
+      info,
+      args,
     })
   }
 
-  patchedResolvers.add(resolveAsync)
-  return resolveAsync
+  if (rootCtx.abortController?.signal.aborted) {
+    throw new AbortError('Aborted')
+  }
+
+  const depth = config.countListIndices ? descriptor.pathDepth : descriptor.selectionDepth
+  if (rootCtx.depthDisabled || (config.depth >= 0 && config.depth < depth)) {
+    return resolve.call(self, source, args, contextValue, info)
+  }
+
+  const path = config.collapse ? undefined : pathToArray(info.path)
+  const pathString = path ? path.join('.') : descriptor.collapsedPath
+  let field
+  if (config.collapse) {
+    field = rootCtx.jitFields[descriptor.id]
+  } else {
+    const fieldKey = `${descriptor.id}:${pathString}`
+    field = rootCtx.jitFieldsByPath.get(fieldKey)
+  }
+  if (field) {
+    field.endTime = REUSED_FIELD_END_TIME
+    if (legacyStorage.getStore() !== field.currentStore) {
+      legacyStorage.enterWith(field.currentStore)
+    }
+    return resolve.call(self, source, args, contextValue, info)
+  }
+
+  field = startJitField(
+    rootCtx,
+    descriptor,
+    pathString,
+    path ?? descriptor.collapsedPathSegments,
+    info.variableValues,
+    info.path
+  )
+
+  /**
+   * @param {unknown} error
+   * @param {unknown} result
+   */
+  const finishField = (error, result) => {
+    rootCtx.plugin?.completeResolveSpan(rootCtx, field, error, result)
+  }
+  return callCompiledJitInAsyncScope(
+    resolve,
+    self,
+    source,
+    args,
+    contextValue,
+    info,
+    field.currentStore,
+    finishField
+  )
+}
+
+/**
+ * @param {object} rootCtx
+ * @param {JitDescriptor} descriptor
+ * @param {string} pathString
+ * @param {(string | number)[]} path
+ * @param {Record<string, unknown> | undefined} variableValues
+ * @param {object | undefined} [infoPath]
+ * @returns {object}
+ */
+function startJitField (rootCtx, descriptor, pathString, path, variableValues, infoPath) {
+  const field = {
+    fieldNode: descriptor.fieldNode,
+    fieldName: descriptor.fieldName,
+    parentTypeName: descriptor.parentTypeName,
+    returnType: descriptor.returnType,
+    baseTypeName: descriptor.baseTypeName,
+    endTime: PENDING_FIELD_END_TIME,
+    infoPath,
+    pathString,
+    collapsedKey: pathString,
+    resource: descriptor.resource,
+    span: null,
+    parentStore: null,
+    currentStore: null,
+    isSharedJitField: rootCtx.config.collapse && descriptor.pathDepth !== descriptor.selectionDepth,
+    tags: rootCtx.config.collapse && !rootCtx.config.source ? descriptor.tags : undefined,
+  }
+  if (rootCtx.config.collapse) {
+    rootCtx.jitFields[descriptor.id] = field
+  } else {
+    rootCtx.jitFieldsByPath.set(`${descriptor.id}:${pathString}`, field)
+  }
+
+  let parentField = null
+  if (descriptor.parentId !== undefined) {
+    if (rootCtx.config.collapse) {
+      parentField = rootCtx.jitFields[descriptor.parentId]
+    } else {
+      const parentPath = path.slice(0, -1)
+      while (typeof parentPath.at(-1) === 'number') parentPath.pop()
+      parentField = rootCtx.jitFieldsByPath.get(`${descriptor.parentId}:${parentPath.join('.')}`)
+    }
+  }
+  const executeSpan = rootCtx.executeSpan
+  rootCtx.plugin.startResolveSpan(field, rootCtx, executeSpan, executeSpan._getTime(), variableValues, parentField)
+  return field
+}
+
+/**
+ * @param {object} rootCtx
+ * @param {number} descriptorId
+ * @param {unknown} error
+ */
+function recordJitResolverError (rootCtx, descriptorId, error) {
+  const field = rootCtx?.jitFields?.[descriptorId]
+  if (!field?.isSharedJitField) return
+
+  recordResolveError(field, error)
+}
+
+/**
+ * @param {object} rootCtx
+ * @param {number} descriptorId
+ * @param {Record<string, unknown>} source
+ * @param {(string | number)[] | undefined} path
+ * @returns {unknown}
+ */
+function resolveJitDefault (rootCtx, descriptorId, source, path) {
+  const descriptor = rootCtx.jitPlan.fields[descriptorId]
+  const pathString = path ? path.join('.') : descriptor.collapsedPath
+  const field = startJitField(
+    rootCtx,
+    descriptor,
+    pathString,
+    path ?? descriptor.collapsedPathSegments,
+    rootCtx.variableValues
+  )
+  if (rootCtx.config.collapse && descriptor.pathDepth !== descriptor.selectionDepth) {
+    field.endTime = REUSED_FIELD_END_TIME
+  }
+
+  let result
+  try {
+    result = legacyStorage.run(field.currentStore, () => source[descriptor.fieldName])
+  } catch (error) {
+    rootCtx.plugin.completeResolveSpan(rootCtx, field, error)
+    throw error
+  }
+
+  rootCtx.plugin.completeResolveSpan(rootCtx, field, undefined, result)
+  return result
+}
+
+/**
+ * @param {object} rootCtx
+ * @param {number} descriptorId
+ * @param {Record<string, unknown>} source
+ * @param {(string | number)[] | undefined} path
+ * @returns {unknown}
+ */
+function readJitDefaultInScope (rootCtx, descriptorId, source, path) {
+  const descriptor = rootCtx.jitPlan.fields[descriptorId]
+  const field = rootCtx.config.collapse
+    ? rootCtx.jitFields?.[descriptorId]
+    : rootCtx.jitFieldsByPath?.get(`${descriptorId}:${path.join('.')}`)
+  if (!field) return source[descriptor.fieldName]
+
+  if (legacyStorage.getStore() !== field.currentStore) {
+    legacyStorage.enterWith(field.currentStore)
+  }
+  return source[descriptor.fieldName]
+}
+
+/**
+ * @param {object} rootCtx
+ * @param {number} descriptorId
+ * @param {Record<string, unknown>} source
+ * @param {(string | number)[] | undefined} path
+ * @param {ArgumentFactory | undefined} argumentFactory
+ * @returns {unknown}
+ */
+function resolveJitDefaultInvocation (rootCtx, descriptorId, source, path, argumentFactory) {
+  const descriptor = rootCtx.jitPlan.fields[descriptorId]
+  if (rootCtx.hasIastSub || rootCtx.hasResolverSub) {
+    if (rootCtx.hasIastSub) {
+      iastResolveCh.publish({
+        rootCtx,
+        args: getJitDefaultArguments(rootCtx, descriptor, argumentFactory, true),
+      })
+    }
+    if (rootCtx.hasResolverSub) {
+      resolverStartCh.publish({
+        abortController: rootCtx.abortController,
+        createResolverInfo: createJitDefaultResolverInfo,
+        rootCtx,
+        descriptor,
+        argumentFactory,
+      })
+    }
+  }
+  if (rootCtx.abortController?.signal.aborted) {
+    throw new AbortError('Aborted')
+  }
+
+  const depth = rootCtx.config.countListIndices ? descriptor.pathDepth : descriptor.selectionDepth
+  if (rootCtx.depthDisabled || (rootCtx.config.depth >= 0 && rootCtx.config.depth < depth)) {
+    if (!rootCtx.depthDisabled && rootCtx.config.collapse) rootCtx.jitFields[descriptorId] = false
+    return source[descriptor.fieldName]
+  }
+
+  const pathString = path ? path.join('.') : descriptor.collapsedPath
+  const field = rootCtx.config.collapse
+    ? rootCtx.jitFields[descriptorId]
+    : rootCtx.jitFieldsByPath.get(`${descriptorId}:${pathString}`)
+  if (field === undefined) {
+    return resolveJitDefault(rootCtx, descriptorId, source, path)
+  }
+  return readJitDefaultInScope(rootCtx, descriptorId, source, path)
+}
+
+/**
+ * @param {object} rootCtx
+ * @param {JitDescriptor} descriptor
+ * @param {ArgumentFactory | undefined} argumentFactory
+ * @param {boolean} mutable
+ * @returns {Record<string, unknown> | undefined}
+ */
+function getJitDefaultArguments (rootCtx, descriptor, argumentFactory, mutable) {
+  if (mutable) {
+    return argumentFactory === undefined
+      ? {}
+      : argumentFactory(rootCtx.variableValues, cloneArgumentValue)
+  }
+  if (descriptor.hasArgumentVariables) {
+    return argumentFactory(rootCtx.variableValues)
+  }
+  return descriptor.staticArguments
+}
+
+/**
+ * @param {unknown} value
+ * @param {WeakMap<object, object>} [clones]
+ * @returns {unknown}
+ */
+function cloneArgumentValue (value, clones) {
+  if (value === null || typeof value !== 'object') return value
+
+  // Lists get their own branch: Object.keys materializes the index strings and
+  // the clone is then filled through them instead of by index.
+  if (Array.isArray(value)) {
+    const { length } = value
+    if (length === 0) return value
+
+    clones ??= new WeakMap()
+    const cached = clones.get(value)
+    if (cached !== undefined) return cached
+
+    const clone = new Array(length)
+    clones.set(value, clone)
+    for (let index = 0; index < length; index++) {
+      clone[index] = cloneArgumentValue(value[index], clones)
+    }
+    return clone
+  }
+
+  const keys = Object.keys(value)
+  if (keys.length === 0) return value
+
+  clones ??= new WeakMap()
+  const cached = clones.get(value)
+  if (cached !== undefined) return cached
+
+  const clone = {}
+  clones.set(value, clone)
+  for (const name of keys) {
+    clone[name] = cloneArgumentValue(value[name], clones)
+  }
+  return clone
+}
+
+/**
+ * @param {GraphQLFieldResolver} resolve
+ */
+function wrapJitResolve (resolve) {
+  return wrapResolve(resolve, true)
 }
 
 function wrapFields (type, schema) {
@@ -575,27 +1070,161 @@ function wrapFieldType (field, schema) {
   wrapFields(unwrapped, schema)
 }
 
-// Runs the resolver inside `store`, including any code after an internal
-// `await`. A `.then()` the caller attaches afterward runs outside `store`.
-function callInAsyncScope (fn, thisArg, args, abortController, store, cb) {
-  if (abortController?.signal.aborted) {
-    cb(null, null)
-    throw new AbortError('Aborted')
+/**
+ * @param {GraphQLFieldResolver} resolve
+ * @param {unknown} self
+ * @param {ArgumentsList} args
+ * @param {boolean} isJit
+ * @returns {unknown}
+ */
+function invokeResolver (resolve, self, args, isJit) {
+  return isJit
+    ? resolve.call(self, args[0], args[1], args[2], args[3])
+    : resolve.apply(self, args)
+}
+
+/**
+ * @param {GraphQLFieldResolver} fn
+ * @param {unknown} thisArg
+ * @param {ArgumentsList} args
+ * @param {object} field
+ * @param {boolean} isJit
+ * @returns {unknown}
+ */
+function callInCollapsedScope (fn, thisArg, args, field, isJit) {
+  if (!isJit) {
+    field.asyncResource ??= legacyStorage.run(field.currentStore, createResolverAsyncResource)
+    return field.asyncResource.runInAsyncScope(invokeResolver, undefined, fn, thisArg, args, false)
   }
 
+  if (legacyStorage.getStore() !== field.currentStore) {
+    legacyStorage.enterWith(field.currentStore)
+  }
+  return invokeResolver(fn, thisArg, args, isJit)
+}
+
+function createResolverAsyncResource () {
+  return new AsyncResource('dd-trace:graphql:resolve', { requireManualDestroy: true })
+}
+
+/**
+ * @param {GraphQLFieldResolver} resolve
+ * @param {unknown} self
+ * @param {unknown} source
+ * @param {Record<string, unknown>} args
+ * @param {unknown} contextValue
+ * @param {import('graphql').GraphQLResolveInfo} info
+ * @returns {unknown}
+ */
+function invokeCompiledJitResolver (resolve, self, source, args, contextValue, info) {
+  return resolve.call(self, source, args, contextValue, info)
+}
+
+/**
+ * @param {GraphQLFieldResolver} resolve
+ * @param {unknown} self
+ * @param {unknown} source
+ * @param {Record<string, unknown>} args
+ * @param {unknown} contextValue
+ * @param {import('graphql').GraphQLResolveInfo} info
+ * @param {object} store
+ * @param {(error: unknown, result?: unknown) => void} callback
+ * @returns {unknown}
+ */
+function callCompiledJitInAsyncScope (resolve, self, source, args, contextValue, info, store, callback) {
   try {
-    const result = legacyStorage.run(store, () => fn.apply(thisArg, args))
-    if (typeof result?.then === 'function') {
-      return result.then(
-        res => { cb(null, res); return res },
-        err => { cb(err); throw err }
-      )
+    const result = legacyStorage.run(
+      store,
+      invokeCompiledJitResolver,
+      resolve,
+      self,
+      source,
+      args,
+      contextValue,
+      info
+    )
+    if (result !== null && typeof result === 'object' && typeof result.then === 'function') {
+      return observeThenable(result, callback)
+    }
+    callback(null, result)
+    return result
+  } catch (error) {
+    callback(error)
+    throw error
+  }
+}
+
+/**
+ * Runs the resolver inside `store`, including any code after an internal
+ * `await`. A `.then()` the caller attaches afterward runs outside `store`.
+ *
+ * @param {GraphQLFieldResolver} fn
+ * @param {unknown} thisArg
+ * @param {ArgumentsList} args
+ * @param {object} store
+ * @param {(error: unknown, result?: unknown, failed?: boolean) => void} callback
+ * @param {boolean} isJit
+ * @returns {unknown}
+ */
+function callInAsyncScope (fn, thisArg, args, store, callback, isJit) {
+  try {
+    const result = legacyStorage.run(store, invokeResolver, fn, thisArg, args, isJit)
+    if (typeof result?.then === 'function' && (!isJit || (result !== null && typeof result === 'object'))) {
+      return observeThenable(result, callback)
     }
-    cb(null, result)
+    callback(null, result)
     return result
-  } catch (err) {
-    cb(err)
-    throw err
+  } catch (error) {
+    callback(error, undefined, true)
+    throw error
+  }
+}
+
+/**
+ * Observes settlement without standing between the consumer and the resolver's
+ * own `then`. Three constraints hold at once, each with its own regression test:
+ * the foreign `then` runs exactly once (`should not re-execute thenables from
+ * resolvers` — a Mongoose `Query` throws on the second call), the return value
+ * stays then-able, and the consumer receives whatever the foreign `then` returned.
+ *
+ * `return thenable.then(onSettled)` satisfies the first two and breaks the third:
+ * only `Promise.prototype.then` is guaranteed to return a promise, and
+ * `await`/`Promise.resolve` discard that return value, so a thenable returning
+ * `this` or a plain value is legal and invisible everywhere except here — see
+ * `CustomThenableSuccess` in jit.spec.js, which resolves with 'actual' but returns
+ * 'wrong'. Forwarding `then` lets the consumer make that single call itself and
+ * get its real return value, while the settlement callbacks pass through us.
+ *
+ * @param {Thenable} thenable
+ * @param {(error: unknown, result?: unknown, failed?: boolean) => void} callback
+ * @returns {Thenable}
+ */
+function observeThenable (thenable, callback) {
+  return {
+    /**
+     * @param {ThenableCallback} [onFulfilled]
+     * @param {ThenableCallback} [onRejected]
+     */
+    // eslint-disable-next-line unicorn/no-thenable -- graphql-jit intentionally consumes this adapter as a thenable.
+    then (onFulfilled, onRejected) {
+      return thenable.then(
+        /**
+         * @param {unknown} result
+         */
+        result => {
+          callback(null, result)
+          return onFulfilled ? onFulfilled(result) : result
+        },
+        /**
+         * @param {unknown} error
+         */
+        error => {
+          callback(error, undefined, true)
+          if (onRejected) return onRejected(error)
+          throw error
+        }
+      )
+    },
   }
 }
 
@@ -670,7 +1299,7 @@ function shouldInstrumentNode (config, path) {
 
 function getParentField (rootCtx, field) {
   for (let curr = field.infoPath?.prev; curr; curr = curr.prev) {
-    const fieldKey = rootCtx.config.collapse ? rootCtx.pathCache.get(curr) : curr
+    const fieldKey = rootCtx.config.collapse || field.jitPathKey ? rootCtx.pathCache.get(curr) : curr
     const innerField = rootCtx.fields.get(fieldKey)
     if (innerField) {
       if (curr.typename === undefined) {
@@ -691,15 +1320,40 @@ function getParentField (rootCtx, field) {
   return null
 }
 
-// Build the resolverInfo payload that AppSec's datadog:graphql:resolver:start
-// subscriber expects: { [fieldName]: { ...args, ...directives } }.
+/**
+ * @param {{ info: import('graphql').GraphQLResolveInfo, args: Record<string, unknown> }} data
+ * @returns {Record<string, Record<string, unknown>> | null}
+ */
+function createResolverInfo ({ info, args }) {
+  return getResolverInfo(info, args)
+}
+
+/**
+ * @param {{
+ *   rootCtx: object,
+ *   descriptor: JitDescriptor,
+ *   argumentFactory: ArgumentFactory | undefined
+ * }} data
+ * @returns {Record<string, Record<string, unknown>> | null}
+ */
+function createJitDefaultResolverInfo ({ rootCtx, descriptor, argumentFactory }) {
+  const args = getJitDefaultArguments(rootCtx, descriptor, argumentFactory, false)
+
+  return getResolverInfo(descriptor, args)
+}
+
+/**
+ * @param {{ fieldName: string, fieldNodes?: readonly import('graphql').FieldNode[] }} info
+ * @param {Record<string, unknown> | undefined} args
+ * @returns {Record<string, Record<string, unknown>> | null}
+ */
 function getResolverInfo (info, args) {
   let resolverVars = args ? { ...args } : undefined
 
   const directives = info.fieldNodes?.[0]?.directives
   if (Array.isArray(directives)) {
     for (const directive of directives) {
-      if (directive.arguments.length === 0) continue
+      if (!directive.arguments?.length) continue
 
       const argList = {}
       for (const argument of directive.arguments) {
@@ -766,12 +1420,154 @@ function isWeakMapKey (value) {
   return value !== null && (typeof value === 'object' || typeof value === 'function')
 }
 
-// Unwrap GraphQL List/NonNull wrappers to get the underlying named type's name.
-// e.g. [Human] → 'Human', [Pet!] → 'Pet', String → 'String'
-function getBaseTypeName (type) {
-  let cursor = type
-  while (cursor && cursor.ofType) cursor = cursor.ofType
-  return cursor?.name
+/**
+ * @param {unknown} result
+ * @returns {object | undefined}
+ */
+function getIncrementalIterator (result) {
+  if (result === null || typeof result !== 'object') return
+
+  if ('initialResult' in result && typeof result.subsequentResults?.next === 'function') {
+    return result.subsequentResults
+  }
+  if (typeof result.next === 'function' && typeof result[Symbol.asyncIterator] === 'function') {
+    return result
+  }
+}
+
+/**
+ * @param {object} iterator
+ * @param {(result?: unknown, error?: unknown, cancelled?: boolean, complete?: boolean) => void} observe
+ */
+function observeIncrementalIterator (iterator, observe) {
+  let activeObserver = observe
+
+  /**
+   * @param {unknown} [result]
+   * @param {unknown} [error]
+   * @param {boolean} [cancelled]
+   * @param {boolean} [complete]
+   */
+  function notify (result, error, cancelled, complete) {
+    if (!activeObserver) return
+
+    const callback = activeObserver
+    if (complete) activeObserver = undefined
+    callback(result, error, cancelled, complete)
+  }
+
+  // Orchestrion cannot reach Promise-resolved or nested iterators. Shimmer adds measurable work to each execution.
+  wrapIteratorMethod(iterator, 'next', false, notify)
+  wrapIteratorMethod(iterator, 'return', true, notify)
+  wrapIteratorMethod(iterator, 'throw', true, notify)
+  wrapIteratorMethod(iterator, asyncDisposeSymbol, true, notify)
+}
+
+/**
+ * @param {object} iterator
+ * @param {string | symbol} name
+ * @param {boolean} terminal
+ * @param {(result?: unknown, error?: unknown, cancelled?: boolean, complete?: boolean) => void} notify
+ */
+function wrapIteratorMethod (iterator, name, terminal, notify) {
+  const method = iterator[name]
+  if (typeof method !== 'function') return
+
+  iterator[name] = function () {
+    const result = method.apply(this, arguments)
+    result.then((value) => {
+      const complete = terminal || value?.done || value?.value?.hasNext === false
+      notify(value?.value, undefined, terminal, complete)
+    }, error => notify(undefined, error, true, true))
+    return result
+  }
+}
+
+/**
+ * @param {object} config
+ * @param {DatadogSpan} span
+ * @param {unknown} result
+ */
+function tagIncrementalResult (config, span, result) {
+  if (result === null || typeof result !== 'object') return
+
+  tagExecutionErrors(config, span, result.errors)
+  if (result.incremental) {
+    for (const entry of result.incremental) {
+      tagExecutionErrors(config, span, entry.errors)
+    }
+  }
+}
+
+/**
+ * @param {object} config
+ * @param {DatadogSpan} span
+ * @param {unknown[] | undefined} errors
+ */
+function tagExecutionErrors (config, span, errors) {
+  if (!errors?.length) return
+
+  if (!span.context().getTag('error')) span.setTag('error', errors[0])
+  for (const error of errors) {
+    extractErrorIntoSpanEvent(config, span, error)
+  }
+}
+
+/**
+ * @param {object} rootCtx
+ * @param {boolean} [finishPendingFields]
+ */
+function releaseRootContext (rootCtx, finishPendingFields) {
+  const endTime = rootCtx.executeSpan._getTime()
+  if (rootCtx.resolveFields !== undefined) {
+    if (rootCtx.resolveHooksPending || rootCtx.jitResolveHooksPending) {
+      runResolveHooks(rootCtx)
+    }
+    for (let field = rootCtx.resolveFields; field; field = field.nextResolveField) {
+      field.asyncResource?.emitDestroy()
+      field.span.finish(field.endTime > PENDING_FIELD_END_TIME ? field.endTime : endTime)
+    }
+  } else if (finishPendingFields && rootCtx.fields !== undefined) {
+    for (const field of rootCtx.fields.values()) {
+      field.span.finish(endTime)
+    }
+  }
+
+  // Resolver-created async resources retain copied stores that all share this owner.
+  for (const key of Object.keys(rootCtx)) {
+    rootCtx[key] = undefined
+  }
+}
+
+/**
+ * @param {object} rootCtx
+ */
+function runResolveHooks (rootCtx) {
+  rootCtx.resolveHooksPending = undefined
+  rootCtx.jitResolveHooksPending = undefined
+
+  for (let field = rootCtx.resolveFields; field; field = field.nextResolveField) {
+    if (field.resolveHookContext === undefined) continue
+
+    rootCtx.config.hooks.resolve(field.span, field.resolveHookContext)
+    field.resolveHookContext = undefined
+  }
+}
+
+/**
+ * @param {object} field
+ * @param {unknown} error
+ * @param {unknown} result
+ * @returns {{ fieldName: string, path: string, error: unknown, result: unknown }}
+ */
+function createResolveHookContext (field, error, result) {
+  return {
+    fieldName: field.fieldName,
+    path: field.pathString,
+    error: error || null,
+    // Any thenable from any realm must stay undefined so the hook does not see an unresolved promise.
+    result: error || typeof result?.then === 'function' ? undefined : result,
+  }
 }
 
 // Fallback resolver used when graphql.execute() is called without an explicit
@@ -801,3 +1597,9 @@ function addVariableTags (config, span, variableValues) {
 }
 
 module.exports = GraphQLExecutePlugin
+module.exports.readJitDefaultInScope = readJitDefaultInScope
+module.exports.recordJitResolverError = recordJitResolverError
+module.exports.resolveCompiledJitField = resolveCompiledJitField
+module.exports.resolveJitDefaultInvocation = resolveJitDefaultInvocation
+module.exports.unwrapJitResolve = unwrapResolve
+module.exports.wrapJitResolve = wrapJitResolve