dd-trace 2.2.0 → 2.3.1

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

@@ -0,0 +1,78 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+/**
+ * @description The enum values in this map are not exposed from ShareDB, so the keys are hard-coded here.
+ * The values were derived from: https://github.com/share/sharedb/blob/master/lib/client/connection.js#L196
+ */
+const READABLE_ACTION_NAMES = {
+  hs: 'handshake',
+  qf: 'query-fetch',
+  qs: 'query-subscribe',
+  qu: 'query-unsubscribe',
+  bf: 'bulk-fetch',
+  bs: 'bulk-subscribe',
+  bu: 'bulk-unsubscribe',
+  f: 'fetch',
+  s: 'subscribe',
+  u: 'unsubscribe',
+  op: 'op',
+  nf: 'snapshot-fetch',
+  nt: 'snapshot-fetch-by-ts',
+  p: 'presence-broadcast',
+  pr: 'presence-request',
+  ps: 'presence-subscribe',
+  pu: 'presence-unsubscribe'
+}
+
+addHook({ name: 'sharedb', versions: ['>=1'], file: 'lib/agent.js' }, Agent => {
+  const startCh = channel('apm:sharedb:request:start')
+  const asyncEndCh = channel('apm:sharedb:request:async-end')
+  const endCh = channel('apm:sharedb:request:end')
+  const errorCh = channel('apm:sharedb:request:error')
+
+  shimmer.wrap(Agent.prototype, '_handleMessage', origHandleMessageFn => function (request, callback) {
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    const action = request.a
+
+    const actionName = getReadableActionName(action)
+
+    startCh.publish({ actionName, request })
+
+    callback = asyncResource.bind(callback)
+
+    arguments[1] = AsyncResource.bind(function (error, res) {
+      if (error) {
+        errorCh.publish(error)
+      }
+      asyncEndCh.publish({ request, res })
+
+      return callback.apply(this, arguments)
+    })
+
+    try {
+      return origHandleMessageFn.apply(this, arguments)
+    } catch (error) {
+      errorCh.publish(error)
+
+      throw error
+    } finally {
+      endCh.publish(undefined)
+    }
+  })
+  return Agent
+})
+
+function getReadableActionName (action) {
+  const actionName = READABLE_ACTION_NAMES[action]
+  if (actionName === undefined) {
+    return action
+  }
+  return actionName
+}

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

@@ -0,0 +1,57 @@
+'use strict'
+
+const {
+  channel,
+  addHook
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const patched = new WeakSet()
+
+addHook({ name: 'winston', file: 'lib/winston/logger.js', versions: ['>=3'] }, Logger => {
+  const logCh = channel('apm:winston:log')
+  shimmer.wrap(Logger.prototype, 'write', write => {
+    return function wrappedWrite (chunk, enc, cb) {
+      if (logCh.hasSubscribers) {
+        const payload = { message: chunk }
+        logCh.publish(payload)
+        arguments[0] = payload.message
+      }
+      return write.apply(this, arguments)
+    }
+  })
+  return Logger
+})
+
+addHook({ name: 'winston', file: 'lib/winston/logger.js', versions: ['1', '2'] }, logger => {
+  const logCh = channel('apm:winston:log')
+  if (logger.Logger.prototype.configure) {
+    shimmer.wrap(logger.Logger.prototype, 'configure', configure => wrapMethod(configure, logCh))
+  }
+  shimmer.wrap(logger.Logger.prototype, 'add', configure => wrapMethod(configure, logCh))
+  return logger
+})
+
+function wrapMethod (method, logCh) {
+  return function methodWithTrace () {
+    const result = method.apply(this, arguments)
+
+    if (logCh.hasSubscribers) {
+      for (const name in this.transports) {
+        const transport = this.transports[name]
+
+        if (patched.has(transport) || typeof transport.log !== 'function') continue
+
+        const log = transport.log
+        transport.log = function wrappedLog (level, msg, meta, callback) {
+          const payload = { message: meta || {} }
+          logCh.publish(payload)
+          arguments[2] = payload.message
+          log.apply(this, arguments)
+        }
+        patched.add(transport)
+      }
+    }
+    return result
+  }
+}

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

@@ -38,8 +38,8 @@ class Sns {
       const ddInfo = {}
       tracer.inject(span, 'text_map', ddInfo)
       injectPath.MessageAttributes._datadog = {
-        DataType: 'String',
-        StringValue: JSON.stringify(ddInfo)
+        DataType: 'Binary',
+        BinaryValue: JSON.stringify(ddInfo) // BINARY types are automatically base64 encoded
       }
     }
   }

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

@@ -1,27 +1,10 @@
 'use strict'
 
-const { LOG } = require('../../../ext/formats')
+const LogPlugin = require('../../dd-trace/src/plugins/log_plugin')
 
-function createWrapEmit (tracer, config) {
-  return function wrapEmit (emit) {
-    return function emitWithTrace (rec, noemit) {
-      const span = tracer.scope().active()
-
-      tracer.inject(span, LOG, rec)
-
-      return emit.apply(this, arguments)
-    }
-  }
-}
-
-module.exports = {
-  name: 'bunyan',
-  versions: ['>=1'],
-  patch (Logger, tracer, config) {
-    if (!tracer._logInjection) return
-    this.wrap(Logger.prototype, '_emit', createWrapEmit(tracer, config))
-  },
-  unpatch (Logger) {
-    this.unwrap(Logger.prototype, '_emit')
+class BunyanPlugin extends LogPlugin {
+  static get name () {
+    return 'bunyan'
   }
 }
+module.exports = BunyanPlugin

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

@@ -1,150 +1,105 @@
-const { SAMPLING_RULE_DECISION } = require('../../dd-trace/src/constants')
+'use strict'
+
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 
 const {
+  CI_APP_ORIGIN,
   TEST_TYPE,
   TEST_NAME,
   TEST_SUITE,
-  TEST_STATUS,
-  TEST_FRAMEWORK_VERSION,
   TEST_SKIP_REASON,
-  CI_APP_ORIGIN,
+  TEST_FRAMEWORK_VERSION,
   ERROR_MESSAGE,
-  getTestEnvironmentMetadata,
+  TEST_STATUS,
   finishAllTraceSpans,
+  getTestEnvironmentMetadata,
   getTestSuitePath
 } = require('../../dd-trace/src/plugins/util/test')
+const { SPAN_TYPE, RESOURCE_NAME } = require('../../../ext/tags')
+const { SAMPLING_RULE_DECISION } = require('../../dd-trace/src/constants')
 
-function setStatusFromResult (span, result, tag) {
-  if (result.status === 1) {
-    span.setTag(tag, 'pass')
-  } else if (result.status === 2) {
-    span.setTag(tag, 'skip')
-  } else if (result.status === 4) {
-    span.setTag(tag, 'skip')
-    span.setTag(TEST_SKIP_REASON, 'not implemented')
-  } else {
-    span.setTag(tag, 'fail')
-    span.setTag(ERROR_MESSAGE, result.message)
+class CucumberPlugin extends Plugin {
+  static get name () {
+    return 'cucumber'
   }
-}
 
-function setStatusFromResultLatest (span, result, tag) {
-  if (result.status === 'PASSED') {
-    span.setTag(tag, 'pass')
-  } else if (result.status === 'SKIPPED' || result.status === 'PENDING') {
-    span.setTag(tag, 'skip')
-  } else if (result.status === 'UNDEFINED') {
-    span.setTag(tag, 'skip')
-    span.setTag(TEST_SKIP_REASON, 'not implemented')
-  } else {
-    span.setTag(tag, 'fail')
-    span.setTag(ERROR_MESSAGE, result.message)
-  }
-}
+  constructor (...args) {
+    super(...args)
 
-function createWrapRun (tracer, testEnvironmentMetadata, sourceRoot, setStatus) {
-  return function wrapRun (run) {
-    return function handleRun () {
-      const testName = this.pickle.name
-      const testSuite = getTestSuitePath(this.pickle.uri, sourceRoot)
-
-      const commonSpanTags = {
-        [TEST_TYPE]: 'test',
-        [TEST_NAME]: testName,
-        [TEST_SUITE]: testSuite,
-        [SAMPLING_RULE_DECISION]: 1,
-        [TEST_FRAMEWORK_VERSION]: tracer._version,
-        ...testEnvironmentMetadata
-      }
+    const testEnvironmentMetadata = getTestEnvironmentMetadata('cucumber', this.config)
+    const sourceRoot = process.cwd()
+
+    this.addSub('ci:cucumber:run:start', ({ pickleName, pickleUri }) => {
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
+      const testSuite = getTestSuitePath(pickleUri, sourceRoot)
 
-      return tracer.trace(
-        'cucumber.test',
-        {
-          type: 'test',
-          resource: testName,
-          tags: commonSpanTags
-        },
-        (testSpan) => {
-          testSpan.context()._trace.origin = CI_APP_ORIGIN
-          const promise = run.apply(this, arguments)
-          promise.then(() => {
-            setStatus(testSpan, this.getWorstStepResult(), TEST_STATUS)
-          }).finally(() => {
-            finishAllTraceSpans(testSpan)
-          })
-          return promise
+      const span = this.tracer.startSpan('cucumber.test', {
+        childOf,
+        tags: {
+          [SPAN_TYPE]: 'test',
+          [RESOURCE_NAME]: pickleName,
+          [TEST_TYPE]: 'test',
+          [TEST_NAME]: pickleName,
+          [TEST_SUITE]: testSuite,
+          [SAMPLING_RULE_DECISION]: 1,
+          [TEST_FRAMEWORK_VERSION]: this.tracer._version,
+          ...testEnvironmentMetadata
         }
-      )
-    }
-  }
-}
+      })
+      span.context()._trace.origin = CI_APP_ORIGIN
+      this.enter(span, store)
+    })
 
-function createWrapRunStep (tracer, getResourceName, setStatus) {
-  return function wrapRunStep (runStep) {
-    return function handleRunStep () {
-      const resource = getResourceName(arguments[0])
-      return tracer.trace(
-        'cucumber.step',
-        { resource, tags: { 'cucumber.step': resource } },
-        (span) => {
-          const promise = runStep.apply(this, arguments)
-          promise.then((result) => {
-            setStatus(span, result, 'step.status')
-          })
-          return promise
+    this.addSub('ci:cucumber:run:end', () => {
+      this.exit()
+    })
+
+    this.addSub('ci:cucumber:run-step:start', ({ resource }) => {
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
+      const span = this.tracer.startSpan('cucumber.step', {
+        childOf,
+        tags: {
+          'cucumber.step': resource,
+          [RESOURCE_NAME]: resource
         }
-      )
-    }
-  }
-}
+      })
+      this.enter(span, store)
+    })
+
+    this.addSub('ci:cucumber:run-step:end', () => {
+      this.exit()
+    })
+
+    this.addSub('ci:cucumber:run:async-end', ({ isStep, status, skipReason, errorMessage }) => {
+      const span = storage.getStore().span
+      const statusTag = isStep ? 'step.status' : TEST_STATUS
+
+      span.setTag(statusTag, status)
 
-module.exports = [
-  {
-    name: '@cucumber/cucumber',
-    versions: ['7.0.0 - 7.2.1'],
-    file: 'lib/runtime/pickle_runner.js',
-    patch (PickleRunner, tracer, config) {
-      const testEnvironmentMetadata = getTestEnvironmentMetadata('cucumber', config)
-      const sourceRoot = process.cwd()
-      const pl = PickleRunner.default
-      this.wrap(
-        pl.prototype,
-        'run',
-        createWrapRun(tracer, testEnvironmentMetadata, sourceRoot, setStatusFromResult)
-      )
-      const getResourceName = (testStep) => {
-        return testStep.isHook ? 'hook' : testStep.pickleStep.text
+      if (skipReason) {
+        span.setTag(TEST_SKIP_REASON, skipReason)
       }
-      this.wrap(pl.prototype, 'runStep', createWrapRunStep(tracer, getResourceName, setStatusFromResult))
-    },
-    unpatch (PickleRunner) {
-      const pl = PickleRunner.default
-      this.unwrap(pl.prototype, 'run')
-      this.unwrap(pl.prototype, 'runStep')
-    }
-  },
-  {
-    name: '@cucumber/cucumber',
-    versions: ['>=7.3.0'],
-    file: 'lib/runtime/test_case_runner.js',
-    patch (TestCaseRunner, tracer, config) {
-      const testEnvironmentMetadata = getTestEnvironmentMetadata('cucumber', config)
-      const sourceRoot = process.cwd()
-      const pl = TestCaseRunner.default
-      this.wrap(
-        pl.prototype,
-        'run',
-        createWrapRun(tracer, testEnvironmentMetadata, sourceRoot, setStatusFromResultLatest)
-      )
-      const getResourceName = (testStep) => {
-        return testStep.text
+
+      if (errorMessage) {
+        span.setTag(ERROR_MESSAGE, errorMessage)
+      }
+
+      span.finish()
+      if (!isStep) {
+        finishAllTraceSpans(span)
       }
-      this.wrap(pl.prototype, 'runStep', createWrapRunStep(tracer, getResourceName, setStatusFromResultLatest))
-    },
-    unpatch (TestCaseRunner) {
-      const pl = TestCaseRunner.default
-      this.unwrap(pl.prototype, 'run')
-      this.unwrap(pl.prototype, 'runStep')
-    }
+    })
+
+    this.addSub('ci:cucumber:error', (err) => {
+      if (err) {
+        const span = storage.getStore().span
+        span.setTag('error', err)
+      }
+    })
   }
-]
+}
+
+module.exports = CucumberPlugin

package/packages/datadog-plugin-fastify/src/find-my-way.js

@@ -10,7 +10,6 @@ function createWrapOn () {
       const wrapper = function (req) {
         web.patch(req)
         web.enterRoute(req, path)
-        req._datadog.routeEntered = true
 
         return handler.apply(this, arguments)
       }

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

@@ -2,6 +2,8 @@
 
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
+const messageSpans = new WeakMap()
+
 function createWrapRequest (tracer, config) {
   return function wrapRequest (request) {
     return function requestWithTrace (cfg = { reqOpts: {} }, cb) {
@@ -45,11 +47,11 @@ function createWrapRequest (tracer, config) {
 function createWrapSubscriptionEmit (tracer, config) {
   return function wrapSubscriptionEmit (emit) {
     return function emitWithTrace (eventName, message) {
-      if (eventName !== 'message' || !message || !message._datadog_span) {
-        return emit.apply(this, arguments)
-      }
+      if (eventName !== 'message' || !message) return emit.apply(this, arguments)
+
+      const span = messageSpans.get(message)
 
-      const span = message._datadog_span
+      if (!span) return emit.apply(this, arguments)
 
       return tracer.scope().activate(span, () => {
         try {
@@ -83,7 +85,7 @@ function createWrapLeaseDispense (tracer, config) {
 
       analyticsSampler.sample(span, config.measured, true)
 
-      message._datadog_span = span
+      messageSpans.set(message, span)
 
       return dispense.apply(this, arguments)
     }
@@ -119,7 +121,7 @@ function getTopic (cfg) {
 }
 
 function finish (message) {
-  const span = message._datadog_span
+  const span = messageSpans.get(message)
 
   if (!span) return
 

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

@@ -4,6 +4,11 @@ const pick = require('lodash.pick')
 const log = require('../../dd-trace/src/log')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
+const contexts = new WeakMap()
+const documentSources = new WeakMap()
+const patchedTypes = new WeakSet()
+const patchedResolvers = new WeakSet()
+
 let tools
 
 function createWrapExecute (tracer, config, defaultFieldResolver) {
@@ -12,11 +17,11 @@ function createWrapExecute (tracer, config, defaultFieldResolver) {
       const args = normalizeArgs(arguments, tracer, config, defaultFieldResolver)
       const schema = args.schema
       const document = args.document
-      const source = document && document._datadog_source
+      const source = documentSources.get(document)
       const contextValue = args.contextValue
       const operation = getOperation(document, args.operationName)
 
-      if (contextValue._datadog_graphql) {
+      if (contexts.has(contextValue)) {
         return execute.apply(this, arguments)
       }
 
@@ -26,11 +31,12 @@ function createWrapExecute (tracer, config, defaultFieldResolver) {
       }
 
       const span = startExecutionSpan(tracer, config, operation, args)
+      const context = { source, span, fields: {} }
 
-      contextValue._datadog_graphql = { source, span, fields: {} }
+      contexts.set(contextValue, context)
 
       return call(execute, span, this, arguments, (err, res) => {
-        finishResolvers(contextValue, config)
+        finishResolvers(context)
 
         setError(span, err || (res && res.errors && res.errors[0]))
         config.hooks.execute(span, args, res)
@@ -55,7 +61,7 @@ function createWrapParse (tracer, config) {
         if (!operation) return document // skip schema parsing
 
         if (source) {
-          document._datadog_source = source.body || source
+          documentSources.set(document, source.body || source)
         }
 
         addDocumentTags(span, document, config)
@@ -103,11 +109,11 @@ function createWrapValidate (tracer, config) {
 }
 
 function wrapFields (type, tracer, config) {
-  if (!type || !type._fields || type._datadog_patched) {
+  if (!type || !type._fields || patchedTypes.has(type)) {
     return
   }
 
-  type._datadog_patched = true
+  patchedTypes.add(type)
 
   Object.keys(type._fields).forEach(key => {
     const field = type._fields[key]
@@ -136,14 +142,16 @@ function wrapFieldType (field, tracer, config) {
 }
 
 function wrapResolve (resolve, tracer, config) {
-  if (resolve._datadog_patched || typeof resolve !== 'function') return resolve
+  if (typeof resolve !== 'function' || patchedResolvers.has(resolve)) return resolve
 
   const responsePathAsArray = config.collapse
     ? withCollapse(pathToArray)
     : pathToArray
 
   function resolveWithTrace (source, args, contextValue, info) {
-    if (!contextValue._datadog_graphql) return resolve.apply(this, arguments)
+    const context = contexts.get(contextValue)
+
+    if (!context) return resolve.apply(this, arguments)
 
     const path = responsePathAsArray(info && info.path)
 
@@ -151,18 +159,18 @@ function wrapResolve (resolve, tracer, config) {
       const depth = path.filter(item => typeof item === 'string').length
 
       if (config.depth < depth) {
-        const parent = getParentField(tracer, contextValue, path)
+        const parent = getParentField(tracer, context, path)
 
         return call(resolve, parent.span, this, arguments)
       }
     }
 
-    const field = assertField(tracer, config, contextValue, info, path)
+    const field = assertField(tracer, config, context, info, path)
 
     return call(resolve, field.span, this, arguments, err => updateField(field, err))
   }
 
-  resolveWithTrace._datadog_patched = true
+  patchedResolvers.add(resolveWithTrace)
 
   return resolveWithTrace
 }
@@ -191,9 +199,9 @@ function call (fn, span, thisArg, args, callback) {
   }
 }
 
-function getParentField (tracer, contextValue, path) {
+function getParentField (tracer, context, path) {
   for (let i = path.length - 1; i > 0; i--) {
-    const field = getField(contextValue, path.slice(0, i))
+    const field = getField(context, path.slice(0, i))
 
     if (field) {
       return field
@@ -201,12 +209,12 @@ function getParentField (tracer, contextValue, path) {
   }
 
   return {
-    span: contextValue._datadog_graphql.span
+    span: context.span
   }
 }
 
-function getField (contextValue, path) {
-  return contextValue._datadog_graphql.fields[path.join('.')]
+function getField (context, path) {
+  return context.fields[path.join('.')]
 }
 
 function normalizeArgs (args, tracer, config, defaultFieldResolver) {
@@ -267,8 +275,8 @@ function addExecutionTags (span, config, operation, document, operationName) {
 function addDocumentTags (span, document, config) {
   const tags = {}
 
-  if (config.source && document && document._datadog_source) {
-    tags['graphql.source'] = document._datadog_source
+  if (config.source && document) {
+    tags['graphql.source'] = documentSources.get(document)
   }
 
   span.addTags(tags)
@@ -300,9 +308,9 @@ function startSpan (tracer, config, name, options) {
   })
 }
 
-function startResolveSpan (tracer, config, childOf, path, info, contextValue) {
+function startResolveSpan (tracer, config, childOf, path, info, { source }) {
   const span = startSpan(tracer, config, 'resolve', { childOf })
-  const document = contextValue._datadog_graphql.source
+  const document = source
   const fieldNode = info.fieldNodes.find(fieldNode => fieldNode.kind === 'Field')
 
   analyticsSampler.sample(span, config.measured)
@@ -345,9 +353,7 @@ function finish (span, finishTime) {
   span.finish(finishTime)
 }
 
-function finishResolvers (contextValue) {
-  const fields = contextValue._datadog_graphql.fields
-
+function finishResolvers ({ fields }) {
   Object.keys(fields).reverse().forEach(key => {
     const field = fields[key]
 
@@ -369,18 +375,18 @@ function withCollapse (responsePathAsArray) {
   }
 }
 
-function assertField (tracer, config, contextValue, info, path) {
+function assertField (tracer, config, context, info, path) {
   const pathString = path.join('.')
-  const fields = contextValue._datadog_graphql.fields
+  const fields = context.fields
 
   let field = fields[pathString]
 
   if (!field) {
-    const parent = getParentField(tracer, contextValue, path)
+    const parent = getParentField(tracer, context, path)
 
     field = fields[pathString] = {
       parent,
-      span: startResolveSpan(tracer, config, parent.span, path, info, contextValue),
+      span: startResolveSpan(tracer, config, parent.span, path, info, context),
       error: null
     }
   }