dd-trace 5.124.0 → 5.126.0

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

@@ -5,8 +5,10 @@ const { DD_MAJOR } = require('../../../version')
 const CompositePlugin = require('../../dd-trace/src/plugins/composite')
 const log = require('../../dd-trace/src/log')
 const GraphQLExecutePlugin = require('./execute')
+const GraphQLJitExecutePlugin = require('./jit')
 const GraphQLParsePlugin = require('./parse')
 const GraphQLRequestPlugin = require('./request')
+const { GraphQLResolveErrorPlugin, GraphQLToolsResolveErrorPlugin } = require('./resolve-error')
 const GraphQLValidatePlugin = require('./validate')
 
 class GraphQLPlugin extends CompositePlugin {
@@ -14,16 +16,16 @@ class GraphQLPlugin extends CompositePlugin {
   static get plugins () {
     return {
       execute: GraphQLExecutePlugin,
+      jit: GraphQLJitExecutePlugin,
       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,
+      resolveError: GraphQLResolveErrorPlugin,
+      toolsResolveError: GraphQLToolsResolveErrorPlugin,
       validate: GraphQLValidatePlugin,
-      // resolve plugin is absorbed into execute: per-field data is recorded
-      // synchronously in wrapResolve, and all graphql.resolve spans are
-      // materialized at execute end.
     }
   }
 
@@ -93,13 +95,31 @@ const noopHooks = { execute: noop, parse: noop, validate: noop, resolve: undefin
 function getHooks ({ hooks }) {
   if (!hooks) return noopHooks
   return {
-    execute: hooks.execute ?? noop,
-    parse: hooks.parse ?? noop,
-    validate: hooks.validate ?? noop,
+    execute: guardHook('execute', hooks.execute) ?? noop,
+    parse: guardHook('parse', hooks.parse) ?? noop,
+    validate: guardHook('validate', hooks.validate) ?? noop,
     // No noop fallback: `resolve` runs per-field (hot path); the plugin
     // gates with `if (this.config.hooks.resolve)` so the absent-hook case
     // skips both the call and the payload-object allocation.
-    resolve: hooks.resolve,
+    resolve: guardHook('resolve', hooks.resolve),
+  }
+}
+
+/**
+ * @param {'execute' | 'parse' | 'resolve' | 'validate'} name
+ * @param {((...args: unknown[]) => unknown) | undefined} hook
+ * @returns {((...args: unknown[]) => unknown) | undefined}
+ */
+function guardHook (name, hook) {
+  if (typeof hook !== 'function') return
+
+  const errorMessage = `Error in the graphql ${name} hook`
+  return function () {
+    try {
+      return hook.apply(this, arguments)
+    } catch (error) {
+      log.error(errorMessage, error)
+    }
   }
 }
 

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

@@ -0,0 +1,136 @@
+'use strict'
+
+const { storage } = require('../../datadog-core')
+const createGraphqlJitRuntime = require('../../datadog-instrumentations/src/helpers/graphql-jit-runtime')
+const GraphQLExecutePlugin = require('./execute')
+const { getBaseTypeName } = require('./utils')
+
+const {
+  readJitDefaultInScope,
+  recordJitResolverError,
+  resolveCompiledJitField,
+  resolveJitDefaultInvocation,
+  unwrapJitResolve,
+  wrapJitResolve,
+} = GraphQLExecutePlugin
+
+/**
+ * @typedef {import('graphql').ExecutionArgs} ExecutionArguments
+ * @typedef {import('../../datadog-instrumentations/src/helpers/graphql-jit-runtime').JitPlan} JitPlan
+ * @typedef {Record<string, import('graphql').GraphQLFieldResolver<unknown, unknown>>} GraphQLResolverMap
+ * @typedef {{
+ *   arguments: [unknown, unknown, Record<string, unknown> | undefined],
+ *   currentStore: Record<string, unknown>,
+ *   ddArgs?: ExecutionArguments,
+ *   ddDocument: import('graphql').DocumentNode,
+ *   ddOperationName?: string,
+ *   ddPlan?: JitPlan,
+ *   ddResolvers?: GraphQLResolverMap,
+ *   ddSchema: import('graphql').GraphQLSchema
+ * }} JitExecutionContext
+ */
+
+const graphqlJitCompilePrefix = 'tracing:orchestrion:graphql-jit:compile'
+const legacyStorage = storage('legacy')
+const patchedResolverMaps = new WeakSet()
+
+const { configureCompilationContext, runtime: jitRuntime } = createGraphqlJitRuntime({
+  createFieldMetadata,
+  readDefaultInScope: readJitDefaultInScope,
+  recordResolverError: recordJitResolverError,
+  resolveDefaultInvocation: resolveJitDefaultInvocation,
+  resolveField: resolveCompiledJitField,
+  startExecution,
+  unwrapResolver: unwrapJitResolve,
+  wrapResolver: wrapJitResolve,
+})
+
+class GraphQLJitExecutePlugin extends GraphQLExecutePlugin {
+  static prefix = 'tracing:orchestrion:graphql-jit:apm:graphql:execute'
+  static extraPrefixes = []
+
+  addTraceSubs () {
+    super.addTraceSubs()
+    this.addSub(`${graphqlJitCompilePrefix}:end`, configureCompilationContext)
+  }
+
+  /**
+   * @param {JitExecutionContext} ctx
+   * @returns {ExecutionArguments}
+   */
+  readExecutionArgs (ctx) {
+    const [rootValue, contextValue, variableValues] = ctx.arguments
+    return {
+      schema: ctx.ddSchema,
+      document: ctx.ddDocument,
+      rootValue,
+      contextValue,
+      variableValues,
+      operationName: ctx.ddOperationName,
+    }
+  }
+
+  /**
+   * @param {JitExecutionContext} ctx
+   * @param {ExecutionArguments} args
+   */
+  wrapExecutionResolvers (ctx, args) {
+    const { ddResolvers: resolvers } = ctx
+    if (ctx.ddPlan === undefined && resolvers && !patchedResolverMaps.has(resolvers)) {
+      patchedResolverMaps.add(resolvers)
+      for (const name of Object.keys(resolvers)) {
+        resolvers[name] = wrapJitResolve(resolvers[name])
+      }
+    }
+    ctx.ddArgs = args
+  }
+
+  /**
+   * @param {JitExecutionContext} ctx
+   * @param {unknown} _contextValue
+   * @param {object} rootCtx
+   */
+  storeRootContext (ctx, _contextValue, rootCtx) {
+    ctx.currentStore.graphqlRootCtx = rootCtx
+  }
+}
+
+/**
+ * @param {Record<string, unknown> | undefined} variableValues
+ * @returns {object | undefined}
+ */
+function startExecution (variableValues) {
+  const rootCtx = legacyStorage.getStore()?.graphqlRootCtx
+  if (!rootCtx) return
+
+  rootCtx.variableValues = variableValues
+  rootCtx.jitRuntime = jitRuntime
+  return rootCtx
+}
+
+/**
+ * @param {string} parentTypeName
+ * @param {string} fieldName
+ * @param {import('graphql').GraphQLOutputType} returnType
+ * @param {string} collapsedPath
+ * @returns {{
+ *   baseTypeName: string,
+ *   resource: string,
+ *   tags: Record<string, string>
+ * }}
+ */
+function createFieldMetadata (parentTypeName, fieldName, returnType, collapsedPath) {
+  const baseTypeName = getBaseTypeName(returnType)
+  return {
+    baseTypeName,
+    resource: `${fieldName}:${returnType}`,
+    tags: {
+      'graphql.field.coordinates': `${parentTypeName}.${fieldName}`,
+      'graphql.field.name': fieldName,
+      'graphql.field.path': collapsedPath,
+      'graphql.field.type': baseTypeName,
+    },
+  }
+}
+
+module.exports = GraphQLJitExecutePlugin

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

@@ -1,12 +1,20 @@
 'use strict'
 
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
-const { extractErrorIntoSpanEvent, getCachedRequestOperation, isApolloHealthCheckSource } = require('./utils')
+const {
+  extractErrorIntoSpanEvent,
+  getCachedRequestOperation,
+  getRequestCache,
+  isApolloHealthCheckSource,
+} = require('./utils')
+
+/** @typedef {ReturnType<typeof getRequestCache>} RequestCache */
 
 /**
  * @typedef {object} GraphQLRequestStore
  * @property {import('../../dd-trace/src/opentracing/span')} [span]
  * @property {import('../../dd-trace/src/opentracing/span')} [graphqlRequestSpan]
+ * @property {RequestCache} [graphqlRequestCache]
  * @property {string} [graphqlRequestOperationName]
  * @property {unknown} [graphqlRequestSource]
  */
@@ -17,24 +25,25 @@ const { extractErrorIntoSpanEvent, getCachedRequestOperation, isApolloHealthChec
  * @property {GraphQLRequestStore} [currentStore]
  * @property {GraphQLRequestStore} [parentStore]
  * @property {boolean} [ddSkipped]
+ * @property {boolean | number} [ddCacheLimit]
  * @property {{ errors?: import('graphql').GraphQLError[] }} [result]
+ * @property {object} [self]
  */
 
 // 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.
+// otherwise have no home if GraphQL-JIT instrumentation is unavailable.
 //
 // 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.
+// available. The normal and JIT execute plugins use the same refinement path
+// when present. A bounded cache preserves the metadata when a warm JIT query
+// skips validation and GraphQL-JIT instrumentation is unavailable or disabled.
 class GraphQLRequestPlugin extends TracingPlugin {
   static id = 'graphql'
   static operation = 'request'
@@ -55,25 +64,13 @@ class GraphQLRequestPlugin extends TracingPlugin {
     }
 
     const operationName = ctx.arguments?.[3]
+    const requestCache = getRequestCache(ctx.self, ctx.ddCacheLimit)
 
-    // `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 cached = getCachedRequestOperation(source, operationName, this.config.signature, requestCache)
 
     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,
@@ -84,14 +81,8 @@ class GraphQLRequestPlugin extends TracingPlugin {
       },
     }, 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.graphqlRequestCache = requestCache
     ctx.currentStore.graphqlRequestOperationName = operationName
     ctx.currentStore.graphqlRequestSource = source
 

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

@@ -0,0 +1,108 @@
+'use strict'
+
+const { storage } = require('../../datadog-core')
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+
+const legacyStorage = storage('legacy')
+const normalizedFalsyErrors = new WeakSet()
+
+class GraphQLResolveErrorPlugin extends TracingPlugin {
+  static id = 'graphql'
+  static prefix = 'tracing:orchestrion:graphql:apm:graphql:resolve:error'
+
+  /**
+   * @param {{ arguments?: unknown[], result?: unknown }} ctx
+   */
+  start (ctx) {
+    const args = ctx.arguments
+    if (args?.length === 1) return
+
+    const error = args?.[0]
+    const errorPath = error?.path
+    const path = Array.isArray(errorPath) ? errorPath : args?.[2]
+    if (path) {
+      recordResolveErrorForPath(normalizedFalsyErrors.delete(error) ? undefined : error, path, args?.[1])
+    }
+  }
+
+  /**
+   * @param {{ arguments?: unknown[], result?: unknown }} ctx
+   */
+  end (ctx) {
+    const args = ctx.arguments
+    if (args?.length !== 1 || args[0]) return
+
+    const error = ctx.result
+    if (error !== null && typeof error === 'object') normalizedFalsyErrors.add(error)
+  }
+}
+
+class GraphQLToolsResolveErrorPlugin extends TracingPlugin {
+  static id = 'graphql'
+  static prefix = 'tracing:orchestrion:@graphql-tools/executor:apm:graphql:resolve:error'
+
+  /**
+   * @param {{ arguments?: unknown[] }} ctx
+   */
+  start (ctx) {
+    const error = ctx.arguments?.[0]
+    if (error?.path) {
+      recordResolveErrorForPath(error, error.path)
+    }
+  }
+
+  // `start` owns attribution while the normalized error path is available.
+  error () {}
+}
+
+/**
+ * @param {unknown} error
+ * @param {(string | number)[]} path
+ * @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
+    }
+  }
+}
+
+/**
+ * @param {string} fieldPath
+ * @param {(string | number)[]} path
+ * @returns {boolean}
+ */
+function matchesPath (fieldPath, 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
+}
+
+/**
+ * @param {object} field
+ * @param {unknown} error
+ */
+function recordResolveError (field, error) {
+  if (field.error !== undefined) return
+
+  const recordedError = error || new Error('GraphQL resolver rejected without an error')
+  field.error = recordedError
+  field.span.setTag('error', recordedError)
+  if (field.resolveHookContext) {
+    field.resolveHookContext.error = recordedError
+    field.resolveHookContext.result = undefined
+  }
+}
+
+module.exports = {
+  GraphQLResolveErrorPlugin,
+  GraphQLToolsResolveErrorPlugin,
+  recordResolveError,
+}

package/packages/datadog-plugin-graphql/src/tools/signature.js

@@ -6,8 +6,7 @@ const transforms = require('./transforms')
 // Apollo Server / Yoga / Mercurius hand back the same parsed `DocumentNode`
 // from their own document caches per execute, so memoizing the signature on
 // the document keeps the visit/print pipeline off the hot path. The inner
-// Map keys on operationName since `separateOperations` picks a different
-// sub-document for each operation.
+// Map keys on operationName since each operation has a different sub-document.
 const cache = new WeakMap()
 
 function defaultEngineReportingSignature (ast, operationName) {

package/packages/datadog-plugin-graphql/src/tools/transforms.js

@@ -8,11 +8,53 @@ const printer = ddGlobal.graphql_printer
 const utilities = ddGlobal.graphql_utilities
 
 function dropUnusedDefinitions (ast, operationName) {
-  const separated = utilities.separateOperations(ast)[operationName]
-  if (!separated) {
+  const operation = utilities.getOperationAST(ast, operationName)
+  if (!operation) {
     return ast
   }
-  return separated
+
+  const fragments = new Map()
+  for (const definition of ast.definitions) {
+    if (definition.kind === 'FragmentDefinition') {
+      fragments.set(definition.name.value, definition)
+    }
+  }
+
+  const dependencies = new Set()
+  collectFragmentDependencies(operation.selectionSet, fragments, dependencies)
+
+  const definitions = []
+  for (const definition of ast.definitions) {
+    if (definition === operation ||
+        (definition.kind === 'FragmentDefinition' && dependencies.has(definition.name.value))) {
+      definitions.push(definition)
+    }
+  }
+
+  return { kind: ast.kind, definitions }
+}
+
+/**
+ * @param {import('graphql').SelectionSetNode} selectionSet
+ * @param {Map<string, import('graphql').FragmentDefinitionNode>} fragments
+ * @param {Set<string>} dependencies
+ */
+function collectFragmentDependencies (selectionSet, fragments, dependencies) {
+  visitor.visit(selectionSet, {
+    /**
+     * @param {import('graphql').FragmentSpreadNode} node
+     */
+    FragmentSpread (node) {
+      const name = node.name.value
+      if (dependencies.has(name)) return
+
+      dependencies.add(name)
+      const fragment = fragments.get(name)
+      if (fragment) {
+        collectFragmentDependencies(fragment.selectionSet, fragments, dependencies)
+      }
+    },
+  })
 }
 
 // One walk replaces Apollo's `hideLiterals` + `removeAliases` + `sortAST` +