dd-trace 2.12.0 → 2.13.0

package/packages/dd-trace/src/opentracing/span.js

@@ -1,11 +1,9 @@
 'use strict'
 
 // TODO (new internal tracer): use DC events for lifecycle metrics and test them
-
-const opentracing = require('opentracing')
-const now = require('performance-now')
+const now = require('perf_hooks').performance.now
+const dateNow = Date.now
 const semver = require('semver')
-const Span = opentracing.Span
 const SpanContext = require('./span_context')
 const id = require('../id')
 const tagger = require('../tagger')
@@ -21,10 +19,8 @@ const {
 const unfinishedRegistry = createRegistry('unfinished')
 const finishedRegistry = createRegistry('finished')
 
-class DatadogSpan extends Span {
+class DatadogSpan {
   constructor (tracer, processor, prioritySampler, fields, debug) {
-    super()
-
     const operationName = fields.operationName
     const parent = fields.parent || null
     const tags = Object.assign({}, fields.tags)
@@ -70,66 +66,45 @@ class DatadogSpan extends Span {
     return `Span${json}`
   }
 
-  _createContext (parent) {
-    let spanContext
-
-    if (parent) {
-      spanContext = new SpanContext({
-        traceId: parent._traceId,
-        spanId: id(),
-        parentId: parent._spanId,
-        sampling: parent._sampling,
-        baggageItems: Object.assign({}, parent._baggageItems),
-        trace: parent._trace
-      })
-    } else {
-      const spanId = id()
-      spanContext = new SpanContext({
-        traceId: spanId,
-        spanId
-      })
-    }
-
-    spanContext._trace.started.push(this)
-    spanContext._trace.startTime = spanContext._trace.startTime || Date.now()
-    spanContext._trace.ticks = spanContext._trace.ticks || now()
-
-    return spanContext
-  }
-
-  _getTime () {
-    const { startTime, ticks } = this._spanContext._trace
-
-    return startTime + now() - ticks
-  }
-
-  _context () {
+  context () {
     return this._spanContext
   }
 
-  _tracer () {
+  tracer () {
     return this._parentTracer
   }
 
-  _setOperationName (name) {
+  setOperationName (name) {
     this._spanContext._name = name
+    return this
   }
 
-  _setBaggageItem (key, value) {
+  setBaggageItem (key, value) {
     this._spanContext._baggageItems[key] = value
+    return this
   }
 
-  _getBaggageItem (key) {
+  getBaggageItem (key) {
     return this._spanContext._baggageItems[key]
   }
 
-  _addTags (keyValuePairs) {
-    tagger.add(this._spanContext._tags, keyValuePairs)
+  setTag (key, value) {
+    this._addTags({ [key]: value })
+    return this
+  }
 
-    this._prioritySampler.sample(this, false)
+  addTags (keyValueMap) {
+    this._addTags(keyValueMap)
+    return this
+  }
+
+  log () {
+    return this
   }
 
-  _finish (finishTime) {
+  logEvent () {}
+
+  finish (finishTime) {
     if (this._duration !== undefined) {
       return
     }
@@ -157,6 +132,45 @@ class DatadogSpan extends Span {
     this._spanContext._isFinished = true
     this._processor.process(this)
   }
+
+  _createContext (parent) {
+    let spanContext
+
+    if (parent) {
+      spanContext = new SpanContext({
+        traceId: parent._traceId,
+        spanId: id(),
+        parentId: parent._spanId,
+        sampling: parent._sampling,
+        baggageItems: Object.assign({}, parent._baggageItems),
+        trace: parent._trace
+      })
+    } else {
+      const spanId = id()
+      spanContext = new SpanContext({
+        traceId: spanId,
+        spanId
+      })
+    }
+
+    spanContext._trace.started.push(this)
+    spanContext._trace.startTime = spanContext._trace.startTime || dateNow()
+    spanContext._trace.ticks = spanContext._trace.ticks || now()
+
+    return spanContext
+  }
+
+  _getTime () {
+    const { startTime, ticks } = this._spanContext._trace
+
+    return startTime + now() - ticks
+  }
+
+  _addTags (keyValuePairs) {
+    tagger.add(this._spanContext._tags, keyValuePairs)
+
+    this._prioritySampler.sample(this, false)
+  }
 }
 
 function createRegistry (type) {

package/packages/dd-trace/src/opentracing/span_context.js

@@ -1,11 +1,7 @@
 'use strict'
 
-const SpanContext = require('opentracing').SpanContext
-
-class DatadogSpanContext extends SpanContext {
+class DatadogSpanContext {
   constructor (props) {
-    super()
-
     props = props || {}
 
     this._traceId = props.traceId

package/packages/dd-trace/src/opentracing/tracer.js

@@ -1,11 +1,7 @@
 'use strict'
 
-const opentracing = require('opentracing')
 const os = require('os')
-const Tracer = opentracing.Tracer
-const Reference = opentracing.Reference
 const Span = require('./span')
-const SpanContext = require('./span_context')
 const SpanProcessor = require('../span_processor')
 const PrioritySampler = require('../priority_sampler')
 const TextMapPropagator = require('./propagation/text_map')
@@ -17,14 +13,13 @@ const formats = require('../../../../ext/formats')
 const log = require('../log')
 const metrics = require('../metrics')
 const getExporter = require('../exporter')
+const SpanContext = require('./span_context')
 
-const REFERENCE_CHILD_OF = opentracing.REFERENCE_CHILD_OF
-const REFERENCE_FOLLOWS_FROM = opentracing.REFERENCE_FOLLOWS_FROM
+const REFERENCE_CHILD_OF = 'child_of'
+const REFERENCE_FOLLOWS_FROM = 'follows_from'
 
-class DatadogTracer extends Tracer {
+class DatadogTracer {
   constructor (config) {
-    super()
-
     const Exporter = getExporter(config.experimental.exporter)
 
     this._service = config.service
@@ -49,32 +44,34 @@ class DatadogTracer extends Tracer {
     }
   }
 
-  _startSpan (name, fields) {
-    const reference = getParent(fields.references)
-    const parent = reference && reference.referencedContext()
-    return this._startSpanInternal(name, fields, parent)
-  }
+  startSpan (name, options = {}) {
+    const parent = options.childOf
+      ? getContext(options.childOf)
+      : getParent(options.references)
 
-  _startSpanInternal (name, fields = {}, parent) {
     const tags = {
       'service.name': this._service
     }
 
     const span = new Span(this, this._processor, this._prioritySampler, {
-      operationName: fields.operationName || name,
+      operationName: options.operationName || name,
       parent,
       tags,
-      startTime: fields.startTime,
+      startTime: options.startTime,
       hostname: this._hostname
     }, this._debug)
 
     span.addTags(this._tags)
-    span.addTags(fields.tags)
+    span.addTags(options.tags)
 
     return span
   }
 
-  _inject (spanContext, format, carrier) {
+  inject (spanContext, format, carrier) {
+    if (spanContext instanceof Span) {
+      spanContext = spanContext.context()
+    }
+
     try {
       this._prioritySampler.sample(spanContext)
       this._propagators[format].inject(spanContext, carrier)
@@ -82,11 +79,9 @@ class DatadogTracer extends Tracer {
       log.error(e)
       metrics.increment('datadog.tracer.node.inject.errors', true)
     }
-
-    return this
   }
 
-  _extract (format, carrier) {
+  extract (format, carrier) {
     try {
       return this._propagators[format].extract(carrier)
     } catch (e) {
@@ -97,31 +92,31 @@ class DatadogTracer extends Tracer {
   }
 }
 
+function getContext (spanContext) {
+  if (spanContext instanceof Span) {
+    spanContext = spanContext.context()
+  }
+
+  if (!(spanContext instanceof SpanContext)) {
+    spanContext = null
+  }
+
+  return spanContext
+}
+
 function getParent (references = []) {
   let parent = null
 
   for (let i = 0; i < references.length; i++) {
     const ref = references[i]
-
-    if (!(ref instanceof Reference)) {
-      log.error(() => `Expected ${ref} to be an instance of opentracing.Reference`)
-      continue
-    }
-
-    const spanContext = ref.referencedContext()
     const type = ref.type()
 
-    if (spanContext && !(spanContext instanceof SpanContext)) {
-      log.error(() => `Expected ${spanContext} to be an instance of SpanContext`)
-      continue
-    }
-
     if (type === REFERENCE_CHILD_OF) {
-      parent = ref
+      parent = ref.referencedContext()
       break
     } else if (type === REFERENCE_FOLLOWS_FROM) {
       if (!parent) {
-        parent = ref
+        parent = ref.referencedContext()
       }
     }
   }

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

@@ -1,112 +1,142 @@
 'use strict'
 
-const { isTrue } = require('./util')
+const { channel } = require('diagnostics_channel')
+const { isFalse } = require('./util')
 const plugins = require('./plugins')
 const log = require('./log')
 
+const loadChannel = channel('dd-trace:instrumentation:load')
+
 // instrument everything that needs Plugin System V2 instrumentation
 require('../../datadog-instrumentations')
 
-// TODO this is shared w/ instrumenter. DRY up.
-function getConfig (name, config = {}) {
-  const enabled = process.env[`DD_TRACE_${name.toUpperCase()}_ENABLED`.replace(/[^a-z0-9_]/ig, '_')]
-  if (enabled !== undefined) {
-    config.enabled = isTrue(enabled)
-  }
+const { DD_TRACE_DISABLED_PLUGINS } = process.env
 
-  // TODO is this the best/correct place for this default?
-  if (!('enabled' in config)) {
-    config.enabled = true
-  }
+const disabledPlugins = new Set(
+  DD_TRACE_DISABLED_PLUGINS && DD_TRACE_DISABLED_PLUGINS.split(',').map(plugin => plugin.trim())
+)
 
-  return config
-}
+// TODO actually ... should we be looking at envrionment variables this deep down in the code?
 
-// TODO: maybe needs to DRY up as well, but depending on how the remaining old plugins
-// are migrated to the new system, can stay here for now, since this is the level
-// this check maybe should be happening on, even if it deals with env variabls
-const disabledPlugins = process.env.DD_TRACE_DISABLED_PLUGINS
+const pluginClasses = {}
 
-const collectDisabledPlugins = () => {
-  return new Set(disabledPlugins && disabledPlugins.split(',').map(plugin => plugin.trim()))
-}
+loadChannel.subscribe(({ name }) => {
+  const Plugin = plugins[name]
 
-// TODO actually ... should we be looking at envrionment variables this deep down in the code?
+  if (!Plugin || typeof Plugin !== 'function') return
+  if (!pluginClasses[Plugin.name]) {
+    const envName = `DD_TRACE_${Plugin.name.toUpperCase()}_ENABLED`
+    const enabled = process.env[envName.replace(/[^a-z0-9_]/ig, '_')]
+
+    // TODO: remove the need to load the plugin class in order to disable the plugin
+    if (isFalse(enabled) || disabledPlugins.has(Plugin.name)) {
+      log.debug(`Plugin "${Plugin.name}" was disabled via configuration option.`)
+
+      pluginClasses[Plugin.name] = null
+    } else {
+      pluginClasses[Plugin.name] = Plugin
+    }
+  }
+})
 
 // TODO this must always be a singleton.
 module.exports = class PluginManager {
   constructor (tracer) {
     this._tracer = tracer
+    this._tracerConfig = null
     this._pluginsByName = {}
     this._configsByName = {}
-    this._disabledPlugins = collectDisabledPlugins()
+
+    this._loadedSubscriber = ({ name }) => {
+      const Plugin = plugins[name]
+
+      if (!Plugin || typeof Plugin !== 'function') return
+
+      this.loadPlugin(Plugin.name)
+    }
+
+    loadChannel.subscribe(this._loadedSubscriber)
   }
 
-  // like instrumenter.use()
-  configurePlugin (name, pluginConfig) {
-    if (typeof pluginConfig === 'boolean') {
-      pluginConfig = { enabled: pluginConfig }
+  loadPlugin (name) {
+    const Plugin = pluginClasses[name]
+
+    if (!Plugin) return
+    if (!this._pluginsByName[name]) {
+      this._pluginsByName[name] = new Plugin(this._tracer)
     }
-    if (!pluginConfig) {
-      pluginConfig = { enabled: true }
+    if (!this._tracerConfig) return // TODO: don't wait for tracer to be initialized
+
+    const pluginConfig = this._configsByName[name] || {
+      enabled: this._tracerConfig.plugins !== false
     }
 
-    this._configsByName[name] = {
-      ...this._configsByName[name],
+    this._pluginsByName[name].configure({
+      ...this._getSharedConfig(name),
       ...pluginConfig
-    }
+    })
+  }
 
-    if (this._pluginsByName[name]) {
-      this._pluginsByName[name].configure(getConfig(name, this._configsByName[name]))
+  // TODO: merge config instead of replacing
+  configurePlugin (name, pluginConfig) {
+    const enabled = this._isEnabled(pluginConfig)
+
+    this._configsByName[name] = {
+      ...pluginConfig,
+      enabled
     }
+
+    this.loadPlugin(name)
   }
 
   // like instrumenter.enable()
   configure (config = {}) {
-    const { logInjection, serviceMapping, experimental } = config
-
-    for (const PluginClass of Object.values(plugins)) {
-      const name = PluginClass.name
+    this._tracerConfig = config
 
-      if (this._disabledPlugins.has(name)) {
-        log.debug(`Plugin "${name}" was disabled via configuration option.`)
-        continue
-      }
+    for (const name in pluginClasses) {
+      this.loadPlugin(name)
+    }
+  }
 
-      if (typeof PluginClass !== 'function') continue
+  // This is basically just for testing. like intrumenter.disable()
+  destroy () {
+    for (const name in this._pluginsByName) {
+      this._pluginsByName[name].configure({ enabled: false })
+    }
 
-      this._pluginsByName[name] = new PluginClass(this._tracer)
+    loadChannel.unsubscribe(this._loadedSubscriber)
+  }
 
-      if (config.plugins === false) continue
+  _isEnabled (pluginConfig) {
+    if (typeof pluginConfig === 'boolean') return pluginConfig
+    if (!pluginConfig) return true
 
-      const pluginConfig = {
-        ...this._configsByName[name]
-      }
+    return pluginConfig.enabled !== false
+  }
 
-      if (logInjection !== undefined) {
-        pluginConfig.logInjection = logInjection
-      }
+  // TODO: figure out a better way to handle this
+  _getSharedConfig (name) {
+    const {
+      logInjection,
+      serviceMapping,
+      experimental
+    } = this._tracerConfig
 
-      // TODO: update so that it's available for every CI Visibility's plugin
-      if (name === 'mocha') {
-        pluginConfig.isAgentlessEnabled = experimental && experimental.exporter === 'datadog'
-      }
+    const sharedConfig = {}
 
-      if (serviceMapping && serviceMapping[name]) {
-        pluginConfig.service = serviceMapping[name]
-      }
+    if (logInjection !== undefined) {
+      sharedConfig.logInjection = logInjection
+    }
 
-      this.configurePlugin(name, pluginConfig)
+    // TODO: update so that it's available for every CI Visibility's plugin
+    if (name === 'mocha') {
+      sharedConfig.isAgentlessEnabled = experimental && experimental.exporter === 'datadog'
     }
-  }
 
-  // This is basically just for testing. like intrumenter.disable()
-  destroy () {
-    for (const name in this._pluginsByName) {
-      this._pluginsByName[name].configure({ enabled: false })
+    if (serviceMapping && serviceMapping[name]) {
+      sharedConfig.service = serviceMapping[name]
     }
 
-    this._pluginsByName = {}
-    this._configsByName = {}
+    return sharedConfig
   }
 }

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

@@ -1,49 +1,61 @@
 'use strict'
 
 module.exports = {
-  'amqp10': require('../../../datadog-plugin-amqp10/src'),
-  'amqplib': require('../../../datadog-plugin-amqplib/src'),
-  'aws-sdk': require('../../../datadog-plugin-aws-sdk/src'),
-  'bunyan': require('../../../datadog-plugin-bunyan/src'),
-  'cassandra-driver': require('../../../datadog-plugin-cassandra-driver/src'),
-  'connect': require('../../../datadog-plugin-connect/src'),
-  'couchbase': require('../../../datadog-plugin-couchbase/src'),
-  'cucumber': require('../../../datadog-plugin-cucumber/src'),
-  'cypress': require('../../../datadog-plugin-cypress/src'),
-  'dns': require('../../../datadog-plugin-dns/src'),
-  'elasticsearch': require('../../../datadog-plugin-elasticsearch/src'),
-  'express': require('../../../datadog-plugin-express/src'),
-  'fastify': require('../../../datadog-plugin-fastify/src'),
-  'find-my-way': require('../../../datadog-plugin-find-my-way/src'),
-  'fs': require('../../../datadog-plugin-fs/src'),
-  'google-cloud-pubsub': require('../../../datadog-plugin-google-cloud-pubsub/src'),
-  'graphql': require('../../../datadog-plugin-graphql/src'),
-  'grpc': require('../../../datadog-plugin-grpc/src'),
-  'hapi': require('../../../datadog-plugin-hapi/src'),
-  'http': require('../../../datadog-plugin-http/src'),
-  'http2': require('../../../datadog-plugin-http2/src'),
-  'ioredis': require('../../../datadog-plugin-ioredis/src'),
-  'jest': require('../../../datadog-plugin-jest/src'),
-  'koa': require('../../../datadog-plugin-koa/src'),
-  'kafkajs': require('../../../datadog-plugin-kafkajs/src'),
-  'memcached': require('../../../datadog-plugin-memcached/src'),
-  'microgateway-core': require('../../../datadog-plugin-microgateway-core/src'),
-  'mocha': require('../../../datadog-plugin-mocha/src'),
-  'moleculer': require('../../../datadog-plugin-moleculer/src'),
-  'mongodb-core': require('../../../datadog-plugin-mongodb-core/src'),
-  'mysql': require('../../../datadog-plugin-mysql/src'),
-  'mysql2': require('../../../datadog-plugin-mysql2/src'),
-  'net': require('../../../datadog-plugin-net/src'),
-  'next': require('../../../datadog-plugin-next/src'),
-  'oracledb': require('../../../datadog-plugin-oracledb/src'),
-  'paperplane': require('../../../datadog-plugin-paperplane/src'),
-  'pg': require('../../../datadog-plugin-pg/src'),
-  'pino': require('../../../datadog-plugin-pino/src'),
-  'redis': require('../../../datadog-plugin-redis/src'),
-  'restify': require('../../../datadog-plugin-restify/src'),
-  'rhea': require('../../../datadog-plugin-rhea/src'),
-  'router': require('../../../datadog-plugin-router/src'),
-  'sharedb': require('../../../datadog-plugin-sharedb/src'),
-  'tedious': require('../../../datadog-plugin-tedious/src'),
-  'winston': require('../../../datadog-plugin-winston/src')
+  get '@cucumber/cucumber' () { return require('../../../datadog-plugin-cucumber/src') },
+  get '@elastic/elasticsearch' () { return require('../../../datadog-plugin-elasticsearch/src') },
+  get '@elastic/transport' () { return require('../../../datadog-plugin-elasticsearch/src') },
+  get '@google-cloud/pubsub' () { return require('../../../datadog-plugin-google-cloud-pubsub/src') },
+  get '@grpc/grpc-js' () { return require('../../../datadog-plugin-grpc/src') },
+  get '@hapi/hapi' () { return require('../../../datadog-plugin-hapi/src') },
+  get '@koa/router' () { return require('../../../datadog-plugin-koa/src') },
+  get '@node-redis/client' () { return require('../../../datadog-plugin-redis/src') },
+  get 'amqp10' () { return require('../../../datadog-plugin-amqp10/src') },
+  get 'amqplib' () { return require('../../../datadog-plugin-amqplib/src') },
+  get 'aws-sdk' () { return require('../../../datadog-plugin-aws-sdk/src') },
+  get 'bunyan' () { return require('../../../datadog-plugin-bunyan/src') },
+  get 'cassandra-driver' () { return require('../../../datadog-plugin-cassandra-driver/src') },
+  get 'connect' () { return require('../../../datadog-plugin-connect/src') },
+  get 'couchbase' () { return require('../../../datadog-plugin-couchbase/src') },
+  get 'cypress' () { return require('../../../datadog-plugin-cypress/src') },
+  get 'dns' () { return require('../../../datadog-plugin-dns/src') },
+  get 'elasticsearch' () { return require('../../../datadog-plugin-elasticsearch/src') },
+  get 'express' () { return require('../../../datadog-plugin-express/src') },
+  get 'fastify' () { return require('../../../datadog-plugin-fastify/src') },
+  get 'find-my-way' () { return require('../../../datadog-plugin-find-my-way/src') },
+  get 'graphql' () { return require('../../../datadog-plugin-graphql/src') },
+  get 'grpc' () { return require('../../../datadog-plugin-grpc/src') },
+  get 'hapi' () { return require('../../../datadog-plugin-hapi/src') },
+  get 'http' () { return require('../../../datadog-plugin-http/src') },
+  get 'http2' () { return require('../../../datadog-plugin-http2/src') },
+  get 'https' () { return require('../../../datadog-plugin-http/src') },
+  get 'ioredis' () { return require('../../../datadog-plugin-ioredis/src') },
+  get 'jest-environment-node' () { return require('../../../datadog-plugin-jest/src') },
+  get 'jest-environment-jsdom' () { return require('../../../datadog-plugin-jest/src') },
+  get 'jest-jasmine2' () { return require('../../../datadog-plugin-jest/src') },
+  get 'koa' () { return require('../../../datadog-plugin-koa/src') },
+  get 'koa-router' () { return require('../../../datadog-plugin-koa/src') },
+  get 'kafkajs' () { return require('../../../datadog-plugin-kafkajs/src') },
+  get 'memcached' () { return require('../../../datadog-plugin-memcached/src') },
+  get 'microgateway-core' () { return require('../../../datadog-plugin-microgateway-core/src') },
+  get 'mocha' () { return require('../../../datadog-plugin-mocha/src') },
+  get 'mocha-each' () { return require('../../../datadog-plugin-mocha/src') },
+  get 'moleculer' () { return require('../../../datadog-plugin-moleculer/src') },
+  get 'mongodb' () { return require('../../../datadog-plugin-mongodb-core/src') },
+  get 'mongodb-core' () { return require('../../../datadog-plugin-mongodb-core/src') },
+  get 'mysql' () { return require('../../../datadog-plugin-mysql/src') },
+  get 'mysql2' () { return require('../../../datadog-plugin-mysql2/src') },
+  get 'net' () { return require('../../../datadog-plugin-net/src') },
+  get 'next' () { return require('../../../datadog-plugin-next/src') },
+  get 'oracledb' () { return require('../../../datadog-plugin-oracledb/src') },
+  get 'paperplane' () { return require('../../../datadog-plugin-paperplane/src') },
+  get 'pg' () { return require('../../../datadog-plugin-pg/src') },
+  get 'pino' () { return require('../../../datadog-plugin-pino/src') },
+  get 'pino-pretty' () { return require('../../../datadog-plugin-pino/src') },
+  get 'redis' () { return require('../../../datadog-plugin-redis/src') },
+  get 'restify' () { return require('../../../datadog-plugin-restify/src') },
+  get 'rhea' () { return require('../../../datadog-plugin-rhea/src') },
+  get 'router' () { return require('../../../datadog-plugin-router/src') },
+  get 'sharedb' () { return require('../../../datadog-plugin-sharedb/src') },
+  get 'tedious' () { return require('../../../datadog-plugin-tedious/src') },
+  get 'winston' () { return require('../../../datadog-plugin-winston/src') }
 }