dd-trace 2.2.0 → 2.2.1

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

@@ -1,35 +1,53 @@
 'use strict'
 
-/**
- * @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'
-}
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
+
+class SharedbPlugin extends Plugin {
+  static get name () {
+    return 'sharedb'
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub(`apm:sharedb:request:start`, ({ actionName, request }) => {
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
+      const span = this.tracer.startSpan('sharedb.request', {
+        childOf,
+        tags: {
+          'service.name': this.config.service || this.tracer._service,
+          'span.kind': 'server',
+          'sharedb.action': actionName,
+          'resource.name': getReadableResourceName(actionName, request.c, request.q)
+        }
+      })
+
+      if (this.config.hooks && this.config.hooks.receive) {
+        this.config.hooks.receive(span, request)
+      }
 
-function getReadableActionName (action) {
-  const actionName = READABLE_ACTION_NAMES[action]
-  if (actionName === undefined) {
-    return action
+      this.enter(span, store)
+    })
+
+    this.addSub(`apm:sharedb:request:end`, () => {
+      this.exit()
+    })
+
+    this.addSub(`apm:sharedb:request:error`, err => {
+      const span = storage.getStore().span
+      span.setTag('error', err)
+    })
+
+    this.addSub(`apm:sharedb:request:async-end`, ({ request, res }) => {
+      const span = storage.getStore().span
+      if (this.config.hooks && this.config.hooks.reply) {
+        this.config.hooks.reply(span, request, res)
+      }
+      span.finish()
+    })
   }
-  return actionName
 }
 
 function getReadableResourceName (readableActionName, collection, query) {
@@ -60,62 +78,4 @@ function isObject (val) {
   return typeof val === 'object' && val !== null && !(val instanceof Array)
 }
 
-function wrapCallback (config, tracer, request, span, done) {
-  return tracer.scope().bind((err, res) => {
-    if (err) {
-      span.setTag('error', err)
-    }
-
-    if (config.hooks && config.hooks.reply) {
-      config.hooks.reply(span, request, res)
-    }
-
-    span.finish()
-
-    if (done) {
-      done(err, res)
-    }
-  })
-}
-
-function createAgentWrapHandle (tracer, config) {
-  return function wrapHandleMessage (origHandleMessageFn) { // called once
-    return function handleMessageWithTrace (request, callback) { // called for each trigger
-      const action = request.a
-
-      const actionName = getReadableActionName(action)
-
-      const scope = tracer.scope()
-      const childOf = scope.active()
-      const span = tracer.startSpan('sharedb.request', {
-        childOf,
-        tags: {
-          'service.name': config.service || tracer._service,
-          'span.kind': 'server',
-          'sharedb.action': actionName,
-          'resource.name': getReadableResourceName(actionName, request.c, request.q)
-        }
-      })
-
-      if (config.hooks && config.hooks.receive) {
-        config.hooks.receive(span, request)
-      }
-
-      arguments[1] = wrapCallback(config, tracer, request, span, callback)
-
-      return tracer.scope().bind(origHandleMessageFn, span).apply(this, arguments)
-    }
-  }
-}
-
-module.exports = {
-  name: 'sharedb',
-  versions: ['>=1'],
-  file: 'lib/agent.js',
-  patch (Agent, tracer, config) {
-    this.wrap(Agent.prototype, '_handleMessage', createAgentWrapHandle(tracer, config))
-  },
-  unpatch (Agent) {
-    this.unwrap(Agent.prototype, '_handleMessage')
-  }
-}
+module.exports = SharedbPlugin

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

@@ -1,118 +1,10 @@
 'use strict'
 
-const { LOG } = require('../../../ext/formats')
+const LogPlugin = require('../../dd-trace/src/plugins/log_plugin')
 
-const hasOwn = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop)
-
-function chunkProxy (chunk, holder) {
-  return new Proxy(chunk, {
-    get (target, p, receiver) {
-      switch (p) {
-        case Symbol.toStringTag:
-          return Object.prototype.toString.call(target).slice(8, -1)
-        case 'dd':
-          return holder.dd
-        default:
-          return Reflect.get(target, p, receiver)
-      }
-    },
-    ownKeys (target) {
-      const ownKeys = Reflect.ownKeys(target)
-      return hasOwn(target, 'dd') ? ownKeys : ['dd', ...ownKeys]
-    },
-    getOwnPropertyDescriptor (target, p) {
-      return Reflect.getOwnPropertyDescriptor(p === 'dd' ? holder : target, p)
-    }
-  })
-}
-
-function createWrapWrite (tracer, config) {
-  return function wrapWrite (write) {
-    return function writeWithTrace (chunk, encoding, callback) {
-      const span = tracer.scope().active()
-
-      const holder = {}
-      tracer.inject(span, LOG, holder)
-      arguments[0] = chunkProxy(chunk, holder)
-
-      return write.apply(this, arguments)
-    }
+class WinstonPlugin extends LogPlugin {
+  static get name () {
+    return 'winston'
   }
 }
-
-function createWrapMethod (tracer, config) {
-  return function wrapMethod (method) {
-    return function methodWithTrace () {
-      const result = method.apply(this, arguments)
-
-      for (const name in this.transports) {
-        const transport = this.transports[name]
-
-        if (transport._dd_patched || typeof transport.log !== 'function') continue
-
-        transport.log = createWrapLog(tracer, config)(transport.log)
-        transport._dd_patched = true
-      }
-
-      return result
-    }
-  }
-}
-
-function createWrapLog (tracer, config) {
-  return function wrapLog (log) {
-    return function logWithTrace (level, msg, meta, callback) {
-      const span = tracer.scope().active()
-
-      meta = meta || {}
-
-      const holder = {}
-      tracer.inject(span, LOG, holder)
-
-      arguments[2] = chunkProxy(meta, holder)
-
-      return log.apply(this, arguments)
-    }
-  }
-}
-
-module.exports = [
-  {
-    name: 'winston',
-    file: 'lib/winston/logger.js',
-    versions: ['>=3'],
-    patch (Logger, tracer, config) {
-      if (!tracer._logInjection) return
-      this.wrap(Logger.prototype, 'write', createWrapWrite(tracer, config))
-    },
-    unpatch (Logger) {
-      this.unwrap(Logger.prototype, 'write')
-    }
-  },
-  {
-    name: 'winston',
-    file: 'lib/winston/logger.js',
-    versions: ['2'],
-    patch (logger, tracer, config) {
-      if (!tracer._logInjection) return
-      this.wrap(logger.Logger.prototype, 'configure', createWrapMethod(tracer, config))
-      this.wrap(logger.Logger.prototype, 'add', createWrapMethod(tracer, config))
-    },
-    unpatch (logger) {
-      this.unwrap(logger.Logger.prototype, 'configure')
-      this.unwrap(logger.Logger.prototype, 'add')
-    }
-  },
-  {
-    name: 'winston',
-    file: 'lib/winston/logger.js',
-    versions: ['1'],
-    patch (logger, tracer, config) {
-      if (!tracer._logInjection) return
-      this.wrap(logger.Logger.prototype, 'add', createWrapMethod(tracer, config))
-    },
-    unpatch (logger) {
-      this.unwrap(logger.Logger.prototype, 'add')
-    }
-  }
-]
+module.exports = WinstonPlugin

package/packages/datadog-shimmer/src/shimmer.js

@@ -132,7 +132,7 @@ function assertFunction (target) {
 }
 
 function assertNotClass (target) {
-  if (target.toString && target.toString().startsWith('class')) {
+  if (Function.prototype.toString.call(target).startsWith('class')) {
     throw new Error('Target is a native class constructor and cannot be wrapped.')
   }
 }

package/packages/dd-trace/lib/version.js

@@ -1 +1 @@
-module.exports = '2.2.0'
+module.exports = '2.2.1'

package/packages/dd-trace/src/appsec/index.js

@@ -7,6 +7,7 @@ const { incomingHttpRequestStart, incomingHttpRequestEnd } = require('./gateway/
 const Gateway = require('./gateway/engine')
 const addresses = require('./addresses')
 const Reporter = require('./reporter')
+const web = require('../plugins/util/web')
 
 function enable (config) {
   try {
@@ -39,7 +40,7 @@ function enable (config) {
 
 function incomingHttpStartTranslator (data) {
   // TODO: get span from datadog-core storage instead
-  const topSpan = data.req._datadog && data.req._datadog.span
+  const topSpan = web.root(data.req)
   if (topSpan) {
     topSpan.addTags({
       '_dd.appsec.enabled': 1,

package/packages/dd-trace/src/appsec/reporter.js

@@ -2,6 +2,7 @@
 
 const addresses = require('./addresses')
 const Limiter = require('../rate_limiter')
+const web = require('../plugins/util/web')
 
 // default limiter, configurable with setRateLimit()
 let limiter = new Limiter(100)
@@ -83,7 +84,7 @@ function formatHeaderName (name) {
 
 function reportAttack (attackData, store) {
   const req = store && store.get('req')
-  const topSpan = req && req._datadog && req._datadog.span
+  const topSpan = web.root(req)
   if (!topSpan) return false
 
   const currentTags = topSpan.context()._tags
@@ -129,7 +130,7 @@ function reportAttack (attackData, store) {
 }
 
 function finishAttacks (req, context) {
-  const topSpan = req && req._datadog && req._datadog.span
+  const topSpan = web.root(req)
   if (!topSpan || !context) return false
 
   const resolvedResponse = resolveHTTPResponse(context)

package/packages/dd-trace/src/constants.js

@@ -8,10 +8,5 @@ module.exports = {
   SAMPLING_RULE_DECISION: '_dd.rule_psr',
   SAMPLING_LIMIT_DECISION: '_dd.limit_psr',
   SAMPLING_AGENT_DECISION: '_dd.agent_psr',
-  SAMPLING_MECHANISM_DEFAULT: 0,
-  SAMPLING_MECHANISM_AGENT: 1,
-  SAMPLING_MECHANISM_RULE: 3,
-  SAMPLING_MECHANISM_MANUAL: 4,
-  DATADOG_LAMBDA_EXTENSION_PATH: '/opt/extensions/datadog-agent',
-  UPSTREAM_SERVICES_KEY: '_dd.p.upstream_services'
+  DATADOG_LAMBDA_EXTENSION_PATH: '/opt/extensions/datadog-agent'
 }

package/packages/dd-trace/src/opentracing/propagation/text_map.js

@@ -11,7 +11,6 @@ const traceKey = 'x-datadog-trace-id'
 const spanKey = 'x-datadog-parent-id'
 const originKey = 'x-datadog-origin'
 const samplingKey = 'x-datadog-sampling-priority'
-const tagsKey = 'x-datadog-tags'
 const baggagePrefix = 'ot-baggage-'
 const b3TraceKey = 'x-b3-traceid'
 const b3TraceExpr = /^([0-9a-f]{16}){1,2}$/i
@@ -41,7 +40,6 @@ class TextMapPropagator {
     this._injectSamplingPriority(spanContext, carrier)
     this._injectBaggageItems(spanContext, carrier)
     this._injectB3(spanContext, carrier)
-    this._injectTags(spanContext, carrier)
 
     log.debug(() => `Inject into carrier: ${JSON.stringify(pick(carrier, logKeys))}.`)
   }
@@ -78,25 +76,6 @@ class TextMapPropagator {
     })
   }
 
-  _injectTags (spanContext, carrier) {
-    const trace = spanContext._trace
-    const tags = []
-
-    for (const key in trace.tags) {
-      if (!key.startsWith('_dd.p.')) continue
-
-      tags.push(`${key}=${trace.tags[key]}`)
-    }
-
-    const header = tags.join(',')
-
-    if (header.length <= 512) {
-      carrier[tagsKey] = header
-    } else {
-      trace.tags['_dd.propagation_error:max_size'] = 1
-    }
-  }
-
   _injectB3 (spanContext, carrier) {
     if (!this._config.experimental.b3) return
 
@@ -124,7 +103,6 @@ class TextMapPropagator {
       this._extractOrigin(carrier, spanContext)
       this._extractBaggageItems(carrier, spanContext)
       this._extractSamplingPriority(carrier, spanContext)
-      this._extractTags(carrier, spanContext)
     }
 
     return spanContext
@@ -262,18 +240,6 @@ class TextMapPropagator {
     }
   }
 
-  _extractTags (carrier, spanContext) {
-    if (!carrier[tagsKey]) return
-
-    const pairs = carrier[tagsKey].split(',')
-
-    for (const pair of pairs) {
-      const [key, value] = pair.split('=')
-
-      spanContext._trace.tags[key] = value
-    }
-  }
-
   _getPriority (sampled, debug) {
     if (debug) {
       return USER_KEEP

package/packages/dd-trace/src/plugins/index.js

@@ -15,7 +15,6 @@ module.exports = {
   'express': require('../../../datadog-plugin-express/src'),
   'fastify': require('../../../datadog-plugin-fastify/src'),
   'fs': require('../../../datadog-plugin-fs/src'),
-  'generic-pool': require('../../../datadog-plugin-generic-pool/src'),
   'google-cloud-pubsub': require('../../../datadog-plugin-google-cloud-pubsub/src'),
   'graphql': require('../../../datadog-plugin-graphql/src'),
   'grpc': require('../../../datadog-plugin-grpc/src'),
@@ -33,7 +32,6 @@ module.exports = {
   'mocha': require('../../../datadog-plugin-mocha/src'),
   'moleculer': require('../../../datadog-plugin-moleculer/src'),
   'mongodb-core': require('../../../datadog-plugin-mongodb-core/src'),
-  'mongoose': require('../../../datadog-plugin-mongoose/src'),
   'mysql': require('../../../datadog-plugin-mysql/src'),
   'mysql2': require('../../../datadog-plugin-mysql2/src'),
   'net': require('../../../datadog-plugin-net/src'),

package/packages/dd-trace/src/plugins/log_plugin.js

@@ -0,0 +1,44 @@
+'use strict'
+
+const { LOG } = require('../../../../ext/formats')
+const Plugin = require('./plugin')
+const { storage } = require('../../../datadog-core')
+
+const hasOwn = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop)
+
+function messageProxy (message, holder) {
+  return new Proxy(message, {
+    get (target, p, receiver) {
+      switch (p) {
+        case Symbol.toStringTag:
+          return Object.prototype.toString.call(target).slice(8, -1)
+        case 'dd':
+          return holder.dd
+        default:
+          return Reflect.get(target, p, receiver)
+      }
+    },
+    ownKeys (target) {
+      const ownKeys = Reflect.ownKeys(target)
+      return hasOwn(target, 'dd') ? ownKeys : ['dd', ...ownKeys]
+    },
+    getOwnPropertyDescriptor (target, p) {
+      return Reflect.getOwnPropertyDescriptor(p === 'dd' ? holder : target, p)
+    }
+  })
+}
+
+module.exports = class LogPlugin extends Plugin {
+  constructor (...args) {
+    super(...args)
+    this.addSub(`apm:${this.constructor.name}:log`, (arg) => {
+      // TODO rather than checking this every time, setting it ought to enable/disable any plugin
+      // extending from this one
+      if (this.tracer._logInjection) {
+        const holder = {}
+        this.tracer.inject(storage.getStore().span, LOG, holder)
+        arg.message = messageProxy(arg.message, holder)
+      }
+    })
+  }
+}

package/packages/dd-trace/src/plugins/plugin.js

@@ -42,6 +42,13 @@ module.exports = class Plugin {
     storage.enterWith({ ...store, span })
   }
 
+  /** Prevents creation of spans here and for all async descendants. */
+  skip () {
+    const store = storage.getStore()
+    this._storeStack.push(store)
+    storage.enterWith({ noop: true })
+  }
+
   exit () {
     storage.enterWith(this._storeStack.pop())
   }