dd-trace 3.3.1 → 3.12.1

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

@@ -1,104 +1,19 @@
 'use strict'
 
-const Plugin = require('../../dd-trace/src/plugins/plugin')
-const { storage } = require('../../datadog-core')
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-
-const messageSpans = new WeakMap()
-class GoogleCloudPubsubPlugin extends Plugin {
-  static get name () {
-    return 'google-cloud-pubsub'
-  }
-
-  constructor (...args) {
-    super(...args)
-
-    this.addSub(`apm:google-cloud-pubsub:request:start`, ({ cfg, projectId, messages }) => {
-      const store = storage.getStore()
-      const childOf = store ? store.span : store
-      const topic = getTopic(cfg)
-      const tags = {
-        component: '@google-cloud/pubsub',
-        'resource.name': [cfg.method, topic].filter(x => x).join(' '),
-        'service.name': this.config.service || `${this.tracer._service}-pubsub`,
-        'span.kind': 'client',
-        'pubsub.method': cfg.method,
-        'gcloud.project_id': projectId,
-        'pubsub.topic': topic
-      }
-      if (cfg.method === 'publish') {
-        tags['span.kind'] = 'producer'
-      }
-      const span = this.tracer.startSpan('pubsub.request', {
-        childOf,
-        tags
-      })
-
-      analyticsSampler.sample(span, this.config.measured)
-      this.enter(span, store)
-
-      for (const msg of messages) {
-        if (!msg.attributes) {
-          msg.attributes = {}
-        }
-        this.tracer.inject(span, 'text_map', msg.attributes)
-      }
-    })
-
-    this.addSub(`apm:google-cloud-pubsub:receive:start`, ({ message }) => {
-      const store = storage.getStore()
-      const subscription = message._subscriber._subscription
-      const topic = subscription.metadata && subscription.metadata.topic
-      const childOf = this.tracer.extract('text_map', message.attributes)
-      const tags = {
-        component: '@google-cloud/pubsub',
-        'resource.name': topic,
-        'service.name': this.config.service || this.tracer._service,
-        'gcloud.project_id': subscription.pubsub.projectId,
-        'pubsub.topic': topic,
-        'span.kind': 'consumer',
-        'span.type': 'worker'
-      }
-
-      const span = this.tracer.startSpan('pubsub.receive', {
-        childOf,
-        tags
-      })
-
-      analyticsSampler.sample(span, this.config.measured, true)
-      this.enter(span, store)
-
-      messageSpans.set(message, span)
-    })
-
-    this.addSub(`apm:google-cloud-pubsub:request:error`, err => {
-      const span = storage.getStore().span
-      span.setTag('error', err)
-    })
-
-    this.addSub(`apm:google-cloud-pubsub:request:finish`, () => {
-      const span = storage.getStore().span
-      span.finish()
-    })
-
-    this.addSub(`apm:google-cloud-pubsub:receive:error`, ({ err, message }) => {
-      const span = messageSpans.get(message)
-      if (!span) return undefined
-      span.setTag('error', err)
-    })
-
-    this.addSub(`apm:google-cloud-pubsub:receive:finish`, ({ message }) => {
-      const span = messageSpans.get(message)
-      if (!span) return
-      span.setTag('pubsub.ack', message._handled ? 1 : 0)
-      span.finish()
-    })
-  }
-}
-
-function getTopic (cfg) {
-  if (cfg.reqOpts) {
-    return cfg.reqOpts[cfg.method === 'createTopic' ? 'name' : 'topic']
+const ProducerPlugin = require('./producer')
+const ConsumerPlugin = require('./consumer')
+const ClientPlugin = require('./client')
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+
+// TODO: Consider splitting channels for publish/receive in the instrumentation.
+class GoogleCloudPubsubPlugin extends CompositePlugin {
+  static get name () { return 'google-cloud-pubsub' }
+  static get plugins () {
+    return {
+      producer: ProducerPlugin,
+      consumer: ConsumerPlugin,
+      client: ClientPlugin
+    }
   }
 }
 

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

@@ -0,0 +1,33 @@
+'use strict'
+
+const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
+
+class GoogleCloudPubsubProducerPlugin extends ProducerPlugin {
+  static get name () { return 'google-cloud-pubsub' }
+  static get operation () { return 'request' }
+
+  start ({ cfg, projectId, messages }) {
+    if (cfg.method !== 'publish') return
+
+    const topic = cfg.reqOpts.topic
+    const span = this.startSpan('pubsub.request', { // TODO: rename
+      service: this.config.service || `${this.tracer._service}-pubsub`,
+      resource: `${cfg.method} ${topic}`,
+      kind: 'producer',
+      meta: {
+        'gcloud.project_id': projectId,
+        'pubsub.method': cfg.method, // TODO: remove
+        'pubsub.topic': topic
+      }
+    })
+
+    for (const msg of messages) {
+      if (!msg.attributes) {
+        msg.attributes = {}
+      }
+      this.tracer.inject(span, 'text_map', msg.attributes)
+    }
+  }
+}
+
+module.exports = GoogleCloudPubsubProducerPlugin

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

@@ -0,0 +1,73 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+
+let tools
+
+class GraphQLExecutePlugin extends TracingPlugin {
+  static get name () { return 'graphql' }
+  static get operation () { return 'execute' }
+
+  start ({ operation, args, docSource }) {
+    const type = operation && operation.operation
+    const name = operation && operation.name && operation.name.value
+    const document = args.document
+    const source = this.config.source && document && docSource
+
+    const span = this.startSpan('graphql.execute', {
+      service: this.config.service,
+      resource: getSignature(document, name, type, this.config.signature),
+      kind: 'server',
+      type: 'graphql',
+      meta: {
+        'graphql.operation.type': type,
+        'graphql.operation.name': name,
+        'graphql.source': source
+      }
+    })
+
+    addVariableTags(this.config, span, args.variableValues)
+  }
+
+  finish ({ res, args }) {
+    const span = this.activeSpan
+    this.config.hooks.execute(span, args, res)
+    span.finish()
+  }
+}
+
+// span-related
+
+function addVariableTags (config, span, variableValues) {
+  const tags = {}
+
+  if (variableValues && config.variables) {
+    const variables = config.variables(variableValues)
+    for (const param in variables) {
+      tags[`graphql.variables.${param}`] = variables[param]
+    }
+  }
+
+  span.addTags(tags)
+}
+
+function getSignature (document, operationName, operationType, calculate) {
+  if (calculate !== false && tools !== false) {
+    try {
+      try {
+        tools = tools || require('./tools')
+      } catch (e) {
+        tools = false
+        throw e
+      }
+
+      return tools.defaultEngineReportingSignature(document, operationName)
+    } catch (e) {
+      // safety net
+    }
+  }
+
+  return [operationType, operationName].filter(val => val).join(' ')
+}
+
+module.exports = GraphQLExecutePlugin

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

@@ -1,111 +1,25 @@
 'use strict'
 
-const Plugin = require('../../dd-trace/src/plugins/plugin')
-const { storage } = require('../../datadog-core')
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
 const log = require('../../dd-trace/src/log')
+const GraphQLExecutePlugin = require('./execute')
+const GraphQLParsePlugin = require('./parse')
+const GraphQLValidatePlugin = require('./validate')
 const GraphQLResolvePlugin = require('./resolve')
 
-let tools
-class GraphQLPlugin extends Plugin {
-  static get name () {
-    return 'graphql'
-  }
-
-  constructor (...args) {
-    super(...args)
-
-    /** Execute Subs */
-
-    // resolve plugin separated for disabling purposes
-    this.resolve = new GraphQLResolvePlugin(...args)
-
-    this.addSub('apm:graphql:execute:start', ({ operation, args, docSource }) => {
-      const store = storage.getStore()
-      const span = startSpan('execute', this.config, this.tracer, store)
-
-      // 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, this.config.measured, true)
-
-      this.enter(span, store)
-    })
-
-    this.addSub('apm:graphql:execute:error', this.addError)
-
-    this.addSub('apm:graphql:execute:finish', ({ res, args }) => {
-      const span = storage.getStore().span
-      this.config.hooks.execute(span, args, res)
-      span.finish()
-    })
-
-    /** Parser Subs */
-
-    this.addSub('apm:graphql:parser:start', () => {
-      const store = storage.getStore()
-      const span = startSpan('parse', this.config, this.tracer, store)
-
-      analyticsSampler.sample(span, this.config.measured, true)
-      this.enter(span, store)
-    })
-
-    this.addSub('apm:graphql:parser:finish', ({ source, document, docSource }) => {
-      const span = storage.getStore().span
-
-      const tags = {}
-      if (this.config.source && document) {
-        tags['graphql.source'] = docSource
-      }
-
-      span.addTags(tags)
-
-      this.config.hooks.parse(span, source, document)
-
-      span.finish()
-    })
-
-    this.addSub('apm:graphql:parser:error', this.addError)
-
-    /** Validate Subs */
-
-    this.addSub('apm:graphql:validate:start', ({ docSource, document }) => {
-      const store = storage.getStore()
-      const span = startSpan('validate', this.config, this.tracer, store)
-
-      analyticsSampler.sample(span, this.config.measured, true)
-
-      if (document && document.loc) {
-        const tags = {}
-        if (this.config.source && document) {
-          tags['graphql.source'] = docSource
-        }
-
-        span.addTags(tags)
-      }
-
-      this.enter(span, store)
-    })
-
-    this.addSub('apm:graphql:validate:finish', ({ document, errors }) => {
-      const span = storage.getStore().span
-      this.config.hooks.validate(span, document, errors)
-      span.finish()
-    })
-
-    this.addSub('apm:graphql:validate:error', this.addError)
+class GraphQLPlugin extends CompositePlugin {
+  static get name () { return 'graphql' }
+  static get plugins () {
+    return {
+      execute: GraphQLExecutePlugin,
+      parse: GraphQLParsePlugin,
+      validate: GraphQLValidatePlugin,
+      resolve: GraphQLResolvePlugin
+    }
   }
 
   configure (config) {
-    const validated = validateConfig(config)
-
-    // this will disable resolve subscribers if `config.depth` is set to 0
-    const resolveConfig = validated.depth === 0 ? false : validated
-    this.resolve.configure(resolveConfig)
-
-    return super.configure(validated)
+    return super.configure(validateConfig(config))
   }
 }
 
@@ -155,80 +69,4 @@ function pick (obj, selectors) {
   return Object.fromEntries(Object.entries(obj).filter(([key]) => selectors.includes(key)))
 }
 
-// span-related
-
-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) {
-  const type = operation && operation.operation
-  const name = operation && operation.name && operation.name.value
-  const tags = {
-    'resource.name': getSignature(document, name, type, config.signature)
-  }
-
-  if (type) {
-    tags['graphql.operation.type'] = type
-  }
-
-  if (name) {
-    tags['graphql.operation.name'] = name
-  }
-
-  span.addTags(tags)
-}
-
-function addDocumentTags (span, document, config, docSource) {
-  const tags = {}
-
-  if (config.source && document) {
-    tags['graphql.source'] = docSource
-  }
-
-  span.addTags(tags)
-}
-
-function addVariableTags (config, span, variableValues) {
-  const tags = {}
-
-  if (variableValues && config.variables) {
-    const variables = config.variables(variableValues)
-    for (const param in variables) {
-      tags[`graphql.variables.${param}`] = variables[param]
-    }
-  }
-
-  span.addTags(tags)
-}
-
-function getSignature (document, operationName, operationType, calculate) {
-  if (calculate !== false && tools !== false) {
-    try {
-      try {
-        tools = tools || require('./tools')
-      } catch (e) {
-        tools = false
-        throw e
-      }
-
-      return tools.defaultEngineReportingSignature(document, operationName)
-    } catch (e) {
-      // safety net
-    }
-  }
-
-  return [operationType, operationName].filter(val => val).join(' ')
-}
-
 module.exports = GraphQLPlugin

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

@@ -0,0 +1,32 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+
+class GraphQLParsePlugin extends TracingPlugin {
+  static get name () { return 'graphql' }
+  static get operation () { return 'parser' }
+
+  start () {
+    this.startSpan('graphql.parse', {
+      service: this.config.service,
+      type: 'graphql',
+      meta: {
+        'graphql.source': ''
+      }
+    })
+  }
+
+  finish ({ source, document, docSource }) {
+    const span = this.activeSpan
+
+    if (this.config.source && document) {
+      span.setTag('graphql.source', docSource)
+    }
+
+    this.config.hooks.parse(span, source, document)
+
+    span.finish()
+  }
+}
+
+module.exports = GraphQLParsePlugin

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

@@ -1,98 +1,92 @@
 'use strict'
 
-const Plugin = require('../../dd-trace/src/plugins/plugin')
-const { storage } = require('../../datadog-core')
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
 
 const collapsedPathSym = Symbol('collapsedPaths')
 
-class GraphQLResolvePlugin extends Plugin {
-  static get name () {
-    return 'graphql'
+class GraphQLResolvePlugin extends TracingPlugin {
+  static get name () { return 'graphql' }
+  static get operation () { return 'resolve' }
+
+  start ({ info, context }) {
+    const path = getPath(info, this.config)
+
+    if (!shouldInstrument(this.config, path)) return
+
+    const computedPathString = path.join('.')
+
+    if (this.config.collapse) {
+      if (!context[collapsedPathSym]) {
+        context[collapsedPathSym] = {}
+      }
+
+      if (context.fields[computedPathString]) return
+      if (context[collapsedPathSym][computedPathString]) return
+
+      context[collapsedPathSym][computedPathString] = true
+    }
+
+    const document = context.source
+    const fieldNode = info.fieldNodes.find(fieldNode => fieldNode.kind === 'Field')
+    const loc = this.config.source && document && fieldNode && fieldNode.loc
+    const source = loc && document.substring(loc.start, loc.end)
+
+    const span = this.startSpan('graphql.resolve', {
+      service: this.config.service,
+      resource: `${info.fieldName}:${info.returnType}`,
+      type: 'graphql',
+      meta: {
+        'graphql.field.name': info.fieldName,
+        'graphql.field.path': computedPathString,
+        'graphql.field.type': info.returnType.name,
+        'graphql.source': source
+      }
+    })
+
+    if (fieldNode && this.config.variables && fieldNode.arguments) {
+      const variables = this.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])
+        })
+    }
+  }
+
+  finish (finishTime) {
+    const span = this.activeSpan
+    span.finish(finishTime)
   }
 
   constructor (...args) {
     super(...args)
 
-    this.addSub('apm:graphql:resolve:start', ({ info, context }) => {
-      const store = storage.getStore()
-      depthPredicate(info, this.config, (computedPath) => {
-        const computedPathString = computedPath.join('.')
-        if ((!this.config.collapse && !context.fields[computedPathString]) ||
-             (!context[collapsedPathSym] || !context[collapsedPathSym][computedPathString])) {
-          // cache the collapsed string here
-          if (this.config.collapse) {
-            if (!context[collapsedPathSym]) context[collapsedPathSym] = {}
-            context[collapsedPathSym][computedPathString] = true
-          }
-
-          const service = this.config.service || this.tracer._service
-          const childOf = store ? store.span : store
-          const span = this.tracer.startSpan(`graphql.resolve`, {
-            childOf: childOf,
-            tags: {
-              'service.name': service,
-              'span.type': 'graphql'
-            }
-          })
-          const document = context.source
-          const fieldNode = info.fieldNodes.find(fieldNode => fieldNode.kind === 'Field')
-
-          analyticsSampler.sample(span, this.config.measured)
-
-          span.addTags({
-            'resource.name': `${info.fieldName}:${info.returnType}`,
-            'graphql.field.name': info.fieldName,
-            'graphql.field.path': computedPathString,
-            'graphql.field.type': info.returnType.name
-          })
-
-          if (fieldNode) {
-            if (this.config.source && document && fieldNode.loc) {
-              span.setTag('graphql.source', document.substring(fieldNode.loc.start, fieldNode.loc.end))
-            }
-
-            if (this.config.variables && fieldNode.arguments) {
-              const variables = this.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])
-                })
-            }
-          }
-          this.enter(span, store)
-        }
-      })
-    })
+    this.addTraceSub('updateField', ({ field, info, err }) => {
+      const path = getPath(info, this.config)
 
-    this.addSub('apm:graphql:resolve:updateField', ({ field, info, err }) => {
-      depthPredicate(info, this.config, () => {
-        const span = storage.getStore().span
-        field.finishTime = span._getTime ? span._getTime() : 0
-        field.error = field.error || err
-      })
-    })
+      if (!shouldInstrument(this.config, path)) return
 
-    this.addSub('apm:graphql:resolve:error', this.addError)
-
-    this.addSub('apm:graphql:resolve:finish', finishTime => {
-      const span = storage.getStore().span
-      span.finish(finishTime)
+      const span = this.activeSpan
+      field.finishTime = span._getTime ? span._getTime() : 0
+      field.error = field.error || err
     })
   }
+
+  configure (config) {
+    // this will disable resolve subscribers if `config.depth` is set to 0
+    super.configure(config.depth === 0 ? false : config)
+  }
 }
 
 // helpers
 
-function depthPredicate (info, config, func) {
-  func = func || (() => {})
-  const path = getPath(info, config)
+function shouldInstrument (config, path) {
   const depth = path.filter(item => typeof item === 'string').length
-  if (config.depth < 0 || config.depth >= depth) func(path)
+
+  return config.depth < 0 || config.depth >= depth
 }
 
 function getPath (info, config) {

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

@@ -0,0 +1,28 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+
+class GraphQLValidatePlugin extends TracingPlugin {
+  static get name () { return 'graphql' }
+  static get operation () { return 'validate' }
+
+  start ({ docSource, document }) {
+    const source = this.config.source && document && docSource
+
+    this.startSpan('graphql.validate', {
+      service: this.config.service,
+      type: 'graphql',
+      meta: {
+        'graphql.source': source
+      }
+    })
+  }
+
+  finish ({ document, errors }) {
+    const span = this.activeSpan
+    this.config.hooks.validate(span, document, errors)
+    span.finish()
+  }
+}
+
+module.exports = GraphQLValidatePlugin