dd-trace 2.8.0 → 2.10.0

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

@@ -1,260 +1,177 @@
 'use strict'
 
-const pick = require('lodash.pick')
-const log = require('../../dd-trace/src/log')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-
-const contexts = new WeakMap()
-const documentSources = new WeakMap()
-const patchedTypes = new WeakSet()
-const patchedResolvers = new WeakSet()
+const log = require('../../dd-trace/src/log')
+const GraphQLResolvePlugin = require('./resolve')
 
 let tools
+class GraphQLPlugin extends Plugin {
+  static get name () {
+    return 'graphql'
+  }
 
-function createWrapExecute (tracer, config, defaultFieldResolver) {
-  return function wrapExecute (execute) {
-    return function executeWithTrace () {
-      const args = normalizeArgs(arguments, tracer, config, defaultFieldResolver)
-      const schema = args.schema
-      const document = args.document
-      const source = documentSources.get(document)
-      const contextValue = args.contextValue
-      const operation = getOperation(document, args.operationName)
-
-      if (contexts.has(contextValue)) {
-        return execute.apply(this, arguments)
-      }
-
-      if (schema) {
-        wrapFields(schema._queryType, tracer, config)
-        wrapFields(schema._mutationType, tracer, config)
-      }
-
-      const span = startExecutionSpan(tracer, config, operation, args)
-      const context = { source, span, fields: {} }
+  constructor (...args) {
+    super(...args)
 
-      contexts.set(contextValue, context)
+    /** Execute Subs */
 
-      return call(execute, span, this, arguments, (err, res) => {
-        finishResolvers(context)
+    // resolve plugin separated for disabling purposes
+    this.resolve = new GraphQLResolvePlugin(...args)
 
-        setError(span, err || (res && res.errors && res.errors[0]))
-        config.hooks.execute(span, args, res)
-        finish(span)
-      })
-    }
-  }
-}
+    this.addSub('apm:graphql:execute:start', ({ operation, args, docSource }) => {
+      const store = storage.getStore()
+      const span = startSpan('execute', this.config, this.tracer, store)
 
-function createWrapParse (tracer, config) {
-  return function wrapParse (parse) {
-    return function parseWithTrace (source) {
-      const span = startSpan(tracer, config, 'parse')
+      // process add tags
+      addExecutionTags(span, this.config, operation, args.document)
+      addDocumentTags(span, args.document, this.config, docSource)
+      addVariableTags(this.config, span, args.variableValues)
 
-      analyticsSampler.sample(span, config.measured, true)
+      analyticsSampler.sample(span, this.config.measured, true)
 
-      let document
-      try {
-        document = parse.apply(this, arguments)
-        const operation = getOperation(document)
+      this.enter(span, store)
+    })
 
-        if (!operation) return document // skip schema parsing
+    this.addSub('apm:graphql:execute:error', this.addError)
 
-        if (source) {
-          documentSources.set(document, source.body || source)
-        }
+    this.addSub('apm:graphql:execute:finish', ({ res, args }) => {
+      const span = storage.getStore().span
+      this.config.hooks.execute(span, args, res)
+      span.finish()
+    })
 
-        addDocumentTags(span, document, config)
+    /** Parser Subs */
 
-        return document
-      } catch (e) {
-        setError(span, e)
-        throw e
-      } finally {
-        config.hooks.parse(span, source, document)
-        finish(span)
-      }
-    }
-  }
-}
+    this.addSub('apm:graphql:parser:start', () => {
+      const store = storage.getStore()
+      const span = startSpan('parse', this.config, this.tracer, store)
 
-function createWrapValidate (tracer, config) {
-  return function wrapValidate (validate) {
-    return function validateWithTrace (schema, document, rules, typeInfo) {
-      const span = startSpan(tracer, config, 'validate')
+      analyticsSampler.sample(span, this.config.measured, true)
+      this.enter(span, store)
+    })
 
-      analyticsSampler.sample(span, config.measured, true)
+    this.addSub('apm:graphql:parser:finish', ({ source, document, docSource }) => {
+      const span = storage.getStore().span
 
-      // skip for schema stitching nested validation
-      if (document && document.loc) {
-        addDocumentTags(span, document, config)
+      const tags = {}
+      if (this.config.source && document) {
+        tags['graphql.source'] = docSource
       }
 
-      let errors
-      try {
-        errors = validate.apply(this, arguments)
+      span.addTags(tags)
 
-        setError(span, errors && errors[0])
+      this.config.hooks.parse(span, source, document)
 
-        return errors
-      } catch (e) {
-        setError(span, e)
-        throw e
-      } finally {
-        config.hooks.validate(span, document, errors)
-        finish(span)
-      }
-    }
-  }
-}
+      span.finish()
+    })
 
-function wrapFields (type, tracer, config) {
-  if (!type || !type._fields || patchedTypes.has(type)) {
-    return
-  }
+    this.addSub('apm:graphql:parser:error', this.addError)
 
-  patchedTypes.add(type)
+    /** Validate Subs */
 
-  Object.keys(type._fields).forEach(key => {
-    const field = type._fields[key]
+    this.addSub('apm:graphql:validate:start', ({ docSource, document }) => {
+      const store = storage.getStore()
+      const span = startSpan('validate', this.config, this.tracer, store)
 
-    wrapFieldResolve(field, tracer, config)
-    wrapFieldType(field, tracer, config)
-  })
-}
+      analyticsSampler.sample(span, this.config.measured, true)
 
-function wrapFieldResolve (field, tracer, config) {
-  if (!field || !field.resolve) return
+      if (document && document.loc) {
+        const tags = {}
+        if (this.config.source && document) {
+          tags['graphql.source'] = docSource
+        }
 
-  field.resolve = wrapResolve(field.resolve, tracer, config)
-}
+        span.addTags(tags)
+      }
 
-function wrapFieldType (field, tracer, config) {
-  if (!field || !field.type) return
+      this.enter(span, store)
+    })
 
-  let unwrappedType = field.type
+    this.addSub('apm:graphql:validate:finish', ({ document, errors }) => {
+      const span = storage.getStore().span
+      this.config.hooks.validate(span, document, errors)
+      span.finish()
+    })
 
-  while (unwrappedType.ofType) {
-    unwrappedType = unwrappedType.ofType
+    this.addSub('apm:graphql:validate:error', this.addError)
   }
 
-  wrapFields(unwrappedType, tracer, config)
-}
-
-function wrapResolve (resolve, tracer, config) {
-  if (typeof resolve !== 'function' || patchedResolvers.has(resolve)) return resolve
+  configure (config) {
+    const validated = validateConfig(config)
 
-  const responsePathAsArray = config.collapse
-    ? withCollapse(pathToArray)
-    : pathToArray
+    // this will disable resolve subscribers if `config.depth` is set to 0
+    const resolveConfig = validated.depth === 0 ? false : validated
+    this.resolve.configure(resolveConfig)
 
-  function resolveWithTrace (source, args, contextValue, info) {
-    const context = contexts.get(contextValue)
-
-    if (!context) return resolve.apply(this, arguments)
-
-    const path = responsePathAsArray(info && info.path)
-
-    if (config.depth >= 0) {
-      const depth = path.filter(item => typeof item === 'string').length
-
-      if (config.depth < depth) {
-        const parent = getParentField(tracer, context, path)
-
-        return call(resolve, parent.span, this, arguments)
-      }
-    }
-
-    const field = assertField(tracer, config, context, info, path)
-
-    return call(resolve, field.span, this, arguments, err => updateField(field, err))
+    return super.configure(validated)
   }
-
-  patchedResolvers.add(resolveWithTrace)
-
-  return resolveWithTrace
 }
 
-function call (fn, span, thisArg, args, callback) {
-  const scope = span.tracer().scope()
-
-  callback = callback || (() => {})
+// config validator helpers
 
-  try {
-    const result = scope.activate(span, () => fn.apply(thisArg, args))
-
-    if (result && typeof result.then === 'function') {
-      result.then(
-        res => callback(null, res),
-        err => callback(err)
-      )
-    } else {
-      callback(null, result)
-    }
-
-    return result
-  } catch (e) {
-    callback(e)
-    throw e
-  }
+function validateConfig (config) {
+  return Object.assign({}, config, {
+    depth: getDepth(config),
+    variables: getVariablesFilter(config),
+    collapse: config.collapse === undefined || !!config.collapse,
+    hooks: getHooks(config)
+  })
 }
 
-function getParentField (tracer, context, path) {
-  for (let i = path.length - 1; i > 0; i--) {
-    const field = getField(context, path.slice(0, i))
-
-    if (field) {
-      return field
-    }
-  }
-
-  return {
-    span: context.span
+function getDepth (config) {
+  if (typeof config.depth === 'number') {
+    return config.depth
+  } else if (config.hasOwnProperty('depth')) {
+    log.error('Expected `depth` to be a integer.')
   }
+  return -1
 }
 
-function getField (context, path) {
-  return context.fields[path.join('.')]
+function getVariablesFilter (config) {
+  if (typeof config.variables === 'function') {
+    return config.variables
+  } else if (config.variables instanceof Array) {
+    return variables => pick(variables, config.variables)
+  } else if (config.hasOwnProperty('variables')) {
+    log.error('Expected `variables` to be an array or function.')
+  }
+  return null
 }
 
-function normalizeArgs (args, tracer, config, defaultFieldResolver) {
-  if (args.length !== 1) return normalizePositional(args, tracer, config, defaultFieldResolver)
-
-  args[0].contextValue = args[0].contextValue || {}
-  args[0].fieldResolver = wrapResolve(args[0].fieldResolver || defaultFieldResolver, tracer, config)
-
-  return args[0]
-}
+function getHooks (config) {
+  const noop = () => { }
+  const execute = (config.hooks && config.hooks.execute) || noop
+  const parse = (config.hooks && config.hooks.parse) || noop
+  const validate = (config.hooks && config.hooks.validate) || noop
 
-function normalizePositional (args, tracer, config, defaultFieldResolver) {
-  args[3] = args[3] || {} // contextValue
-  args[6] = wrapResolve(args[6] || defaultFieldResolver, tracer, config) // fieldResolver
-  args.length = Math.max(args.length, 7)
-
-  return {
-    schema: args[0],
-    document: args[1],
-    rootValue: args[2],
-    contextValue: args[3],
-    variableValues: args[4],
-    operationName: args[5],
-    fieldResolver: args[6]
-  }
+  return { execute, parse, validate }
 }
 
-function startExecutionSpan (tracer, config, operation, args) {
-  const span = startSpan(tracer, config, 'execute')
+// non-lodash pick
 
-  addExecutionTags(span, config, operation, args.document, args.operationName)
-  addDocumentTags(span, args.document, config)
-  addVariableTags(tracer, config, span, args.variableValues)
+function pick (obj, selectors) {
+  return Object.fromEntries(Object.entries(obj).filter(([key]) => selectors.includes(key)))
+}
 
-  analyticsSampler.sample(span, config.measured, true)
+// span-related
 
-  return span
+function startSpan (name, conf, tracer, store, options) {
+  const service = conf.service || tracer._service
+  const childOf = store ? store.span : store
+  options = options || {}
+  return tracer.startSpan(`graphql.${name}`, {
+    childOf: options.childOf || childOf,
+    startTime: options.startTime,
+    tags: {
+      'service.name': service,
+      'span.type': 'graphql'
+    }
+  })
 }
 
-function addExecutionTags (span, config, operation, document, operationName) {
+function addExecutionTags (span, config, operation, document) {
   const type = operation && operation.operation
   const name = operation && operation.name && operation.name.value
   const tags = {
@@ -272,17 +189,17 @@ function addExecutionTags (span, config, operation, document, operationName) {
   span.addTags(tags)
 }
 
-function addDocumentTags (span, document, config) {
+function addDocumentTags (span, document, config, docSource) {
   const tags = {}
 
   if (config.source && document) {
-    tags['graphql.source'] = documentSources.get(document)
+    tags['graphql.source'] = docSource
   }
 
   span.addTags(tags)
 }
 
-function addVariableTags (tracer, config, span, variableValues) {
+function addVariableTags (config, span, variableValues) {
   const tags = {}
 
   if (variableValues && config.variables) {
@@ -295,155 +212,6 @@ function addVariableTags (tracer, config, span, variableValues) {
   span.addTags(tags)
 }
 
-function startSpan (tracer, config, name, options) {
-  options = options || {}
-
-  return tracer.startSpan(`graphql.${name}`, {
-    childOf: options.childOf || tracer.scope().active(),
-    startTime: options.startTime,
-    tags: {
-      'service.name': getService(tracer, config),
-      'span.type': 'graphql'
-    }
-  })
-}
-
-function startResolveSpan (tracer, config, childOf, path, info, { source }) {
-  const span = startSpan(tracer, config, 'resolve', { childOf })
-  const document = source
-  const fieldNode = info.fieldNodes.find(fieldNode => fieldNode.kind === 'Field')
-
-  analyticsSampler.sample(span, config.measured)
-
-  span.addTags({
-    'resource.name': `${info.fieldName}:${info.returnType}`,
-    'graphql.field.name': info.fieldName,
-    'graphql.field.path': path.join('.'),
-    'graphql.field.type': info.returnType.name
-  })
-
-  if (fieldNode) {
-    if (config.source && document && fieldNode.loc) {
-      span.setTag('graphql.source', document.substring(fieldNode.loc.start, fieldNode.loc.end))
-    }
-
-    if (config.variables && fieldNode.arguments) {
-      const variables = config.variables(info.variableValues)
-
-      fieldNode.arguments
-        .filter(arg => arg.value && arg.value.kind === 'Variable')
-        .filter(arg => arg.value.name && variables[arg.value.name.value])
-        .map(arg => arg.value.name.value)
-        .forEach(name => {
-          span.setTag(`graphql.variables.${name}`, variables[name])
-        })
-    }
-  }
-
-  return span
-}
-
-function setError (span, error) {
-  if (error) {
-    span.setTag('error', error)
-  }
-}
-
-function finish (span, finishTime) {
-  span.finish(finishTime)
-}
-
-function finishResolvers ({ fields }) {
-  Object.keys(fields).reverse().forEach(key => {
-    const field = fields[key]
-
-    setError(field.span, field.error)
-    finish(field.span, field.finishTime)
-  })
-}
-
-function updateField (field, error) {
-  // TODO: update this to also work with no-op spans without a hack
-  field.finishTime = field.span._getTime ? field.span._getTime() : 0
-  field.error = field.error || error
-}
-
-function withCollapse (responsePathAsArray) {
-  return function () {
-    return responsePathAsArray.apply(this, arguments)
-      .map(segment => typeof segment === 'number' ? '*' : segment)
-  }
-}
-
-function assertField (tracer, config, context, info, path) {
-  const pathString = path.join('.')
-  const fields = context.fields
-
-  let field = fields[pathString]
-
-  if (!field) {
-    const parent = getParentField(tracer, context, path)
-
-    field = fields[pathString] = {
-      parent,
-      span: startResolveSpan(tracer, config, parent.span, path, info, context),
-      error: null
-    }
-  }
-
-  return field
-}
-
-function getService (tracer, config) {
-  return config.service || tracer._service
-}
-
-function getOperation (document, operationName) {
-  if (!document || !Array.isArray(document.definitions)) {
-    return
-  }
-
-  const definitions = document.definitions.filter(def => def)
-  const types = ['query', 'mutation', 'subscription']
-
-  if (operationName) {
-    return definitions
-      .filter(def => types.indexOf(def.operation) !== -1)
-      .find(def => operationName === (def.name && def.name.value))
-  } else {
-    return definitions.find(def => types.indexOf(def.operation) !== -1)
-  }
-}
-
-function validateConfig (config) {
-  return Object.assign({}, config, {
-    depth: getDepth(config),
-    variables: getVariablesFilter(config),
-    collapse: config.collapse === undefined || !!config.collapse,
-    hooks: getHooks(config)
-  })
-}
-
-function getDepth (config) {
-  if (typeof config.depth === 'number') {
-    return config.depth
-  } else if (config.hasOwnProperty('depth')) {
-    log.error('Expected `depth` to be a integer.')
-  }
-  return -1
-}
-
-function getVariablesFilter (config) {
-  if (typeof config.variables === 'function') {
-    return config.variables
-  } else if (config.variables instanceof Array) {
-    return variables => pick(variables, config.variables)
-  } else if (config.hasOwnProperty('variables')) {
-    log.error('Expected `variables` to be an array or function.')
-  }
-  return null
-}
-
 function getSignature (document, operationName, operationType, calculate) {
   if (calculate !== false && tools !== false) {
     try {
@@ -463,61 +231,4 @@ function getSignature (document, operationName, operationType, calculate) {
   return [operationType, operationName].filter(val => val).join(' ')
 }
 
-function pathToArray (path) {
-  const flattened = []
-  let curr = path
-  while (curr) {
-    flattened.push(curr.key)
-    curr = curr.prev
-  }
-  return flattened.reverse()
-}
-
-function getHooks (config) {
-  const noop = () => {}
-  const execute = (config.hooks && config.hooks.execute) || noop
-  const parse = (config.hooks && config.hooks.parse) || noop
-  const validate = (config.hooks && config.hooks.validate) || noop
-
-  return { execute, parse, validate }
-}
-
-module.exports = [
-  {
-    name: 'graphql',
-    file: 'execution/execute.js',
-    versions: ['>=0.10'],
-    patch (execute, tracer, config) {
-      this.wrap(execute, 'execute', createWrapExecute(
-        tracer,
-        validateConfig(config),
-        execute.defaultFieldResolver
-      ))
-    },
-    unpatch (execute) {
-      this.unwrap(execute, 'execute')
-    }
-  },
-  {
-    name: 'graphql',
-    file: 'language/parser.js',
-    versions: ['>=0.10'],
-    patch (parser, tracer, config) {
-      this.wrap(parser, 'parse', createWrapParse(tracer, validateConfig(config)))
-    },
-    unpatch (parser) {
-      this.unwrap(parser, 'parse')
-    }
-  },
-  {
-    name: 'graphql',
-    file: 'validation/validate.js',
-    versions: ['>=0.10'],
-    patch (validate, tracer, config) {
-      this.wrap(validate, 'validate', createWrapValidate(tracer, validateConfig(config)))
-    },
-    unpatch (validate) {
-      this.unwrap(validate, 'validate')
-    }
-  }
-]
+module.exports = GraphQLPlugin