dd-trace 4.1.1 → 4.3.0

package/packages/dd-trace/src/opentelemetry/context_manager.js

@@ -0,0 +1,74 @@
+'use strict'
+
+const { AsyncLocalStorage } = require('async_hooks')
+const { trace, ROOT_CONTEXT } = require('@opentelemetry/api')
+
+const SpanContext = require('./span_context')
+const tracer = require('../../')
+
+// Horrible hack to acquire the otherwise inaccessible SPAN_KEY so we can redirect it...
+// This is used for getting the current span context in OpenTelemetry, but the SPAN_KEY value is
+// not exposed as it's meant to be read-only from outside the module. We want to hijack this logic
+// so we can instead get the span context from the datadog context manager instead.
+let SPAN_KEY
+trace.getSpan({
+  getValue (key) {
+    SPAN_KEY = key
+  }
+})
+
+// Whenever a value is acquired from the context map we should mostly delegate to the real getter,
+// but when accessing the current span we should hijack that access to instead provide a fake span
+// which we can use to get an OTel span context wrapping the datadog active scope span context.
+function wrappedGetValue (target) {
+  return (key) => {
+    if (key === SPAN_KEY) {
+      return {
+        spanContext () {
+          const activeSpan = tracer.scope().active()
+          const context = activeSpan && activeSpan.context()
+          return new SpanContext(context)
+        }
+      }
+    }
+    return target.getValue(key)
+  }
+}
+
+class ContextManager {
+  constructor () {
+    this._store = new AsyncLocalStorage()
+  }
+
+  active () {
+    const active = this._store.getStore() || ROOT_CONTEXT
+
+    return new Proxy(active, {
+      get (target, key) {
+        return key === 'getValue' ? wrappedGetValue(target) : target[key]
+      }
+    })
+  }
+
+  with (context, fn, thisArg, ...args) {
+    const span = trace.getSpan(context)
+    const ddScope = tracer.scope()
+    return ddScope.activate(span._ddSpan, () => {
+      const cb = thisArg == null ? fn : fn.bind(thisArg)
+      return this._store.run(context, cb, ...args)
+    })
+  }
+
+  bind (context, target) {
+    const self = this
+    return function (...args) {
+      return self.with(context, target, this, ...args)
+    }
+  }
+
+  // Not part of the spec but the Node.js API expects these
+  enable () {}
+  disable () {}
+}
+
+module.exports = ContextManager

package/packages/dd-trace/src/opentelemetry/sampler.js

@@ -0,0 +1,18 @@
+'use strict'
+
+// This isn't used yet. We currently delegate to dd-trace core for sampling decisions.
+// Leaving here for future use.
+class Sampler {
+  shouldSample (context, traceId, spanName, spanKind, attributes, links) {
+    // 0 = no, 1 = record, 2 = record and sample
+    // TODO: Make this actually do sampling...
+    return { decision: 2 }
+  }
+
+  /** Returns the sampler name or short description with the configuration. */
+  toString () {
+    return 'DatadogSampler'
+  }
+}
+
+module.exports = Sampler

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

@@ -0,0 +1,151 @@
+'use strict'
+
+const api = require('@opentelemetry/api')
+
+const { performance } = require('perf_hooks')
+const { timeOrigin } = performance
+
+const { timeInputToHrTime } = require('@opentelemetry/core')
+
+const tracer = require('../../')
+const DatadogSpan = require('../opentracing/span')
+const { ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK } = require('../constants')
+
+const SpanContext = require('./span_context')
+
+// The one built into OTel rounds so we lose sub-millisecond precision.
+function hrTimeToMilliseconds (time) {
+  return time[0] * 1e3 + time[1] / 1e6
+}
+
+class Span {
+  constructor (
+    parentTracer,
+    context,
+    spanName,
+    spanContext,
+    kind,
+    links = [],
+    timeInput
+  ) {
+    const { _tracer } = tracer
+
+    const hrStartTime = timeInputToHrTime(timeInput || (performance.now() + timeOrigin))
+    const startTime = hrTimeToMilliseconds(hrStartTime)
+
+    this._ddSpan = new DatadogSpan(_tracer, _tracer._processor, _tracer._prioritySampler, {
+      operationName: spanName,
+      context: spanContext._ddContext,
+      startTime,
+      hostname: _tracer._hostname,
+      tags: {
+        'service.name': _tracer._service
+      }
+    }, _tracer._debug)
+
+    this._parentTracer = parentTracer
+    this._context = context
+
+    this._hasStatus = false
+
+    // NOTE: Need to grab the value before setting it on the span because the
+    // math for computing opentracing timestamps is apparently lossy...
+    this.startTime = hrStartTime
+    this.kind = kind
+    this.links = links
+    this._spanProcessor.onStart(this, context)
+  }
+
+  get parentSpanId () {
+    const { _parentId } = this._ddSpan.context()
+    return _parentId && _parentId.toString(16)
+  }
+
+  // Expected by OTel
+  get resource () {
+    return this._parentTracer.resource
+  }
+  get instrumentationLibrary () {
+    return this._parentTracer.instrumentationLibrary
+  }
+  get _spanProcessor () {
+    return this._parentTracer.getActiveSpanProcessor()
+  }
+
+  get name () {
+    return this._ddSpan.context()._name
+  }
+
+  spanContext () {
+    return new SpanContext(this._ddSpan.context())
+  }
+
+  setAttribute (key, value) {
+    this._ddSpan.setTag(key, value)
+    return this
+  }
+
+  setAttributes (attributes) {
+    this._ddSpan.addTags(attributes)
+    return this
+  }
+
+  addEvent (name, attributesOrStartTime, startTime) {
+    api.diag.warn('Events not supported')
+    return this
+  }
+
+  setStatus ({ code, message }) {
+    if (!this.ended && !this._hasStatus && code) {
+      this._hasStatus = true
+      if (code === 2) {
+        this._ddSpan.addTags({
+          [ERROR_MESSAGE]: message
+        })
+      }
+    }
+    return this
+  }
+
+  updateName (name) {
+    if (!this.ended) {
+      this._ddSpan.setOperationName(name)
+    }
+    return this
+  }
+
+  end (timeInput) {
+    if (this.ended) {
+      api.diag.error('You can only call end() on a span once.')
+      return
+    }
+
+    const hrEndTime = timeInputToHrTime(timeInput || (performance.now() + timeOrigin))
+    const endTime = hrTimeToMilliseconds(hrEndTime)
+
+    this._ddSpan.finish(endTime)
+    this._spanProcessor.onEnd(this)
+  }
+
+  isRecording () {
+    return this.ended === false
+  }
+
+  recordException (exception) {
+    this._ddSpan.addTags({
+      [ERROR_TYPE]: exception.name,
+      [ERROR_MESSAGE]: exception.message,
+      [ERROR_STACK]: exception.stack
+    })
+  }
+
+  get duration () {
+    return this._ddSpan._duration
+  }
+
+  get ended () {
+    return typeof this.duration !== 'undefined'
+  }
+}
+
+module.exports = Span

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

@@ -0,0 +1,44 @@
+'use strict'
+
+const api = require('@opentelemetry/api')
+const { AUTO_KEEP } = require('../../../../ext/priority')
+const DatadogSpanContext = require('../opentracing/span_context')
+const id = require('../id')
+
+function newContext () {
+  const spanId = id()
+  return new DatadogSpanContext({
+    traceId: spanId,
+    spanId
+  })
+}
+
+class SpanContext {
+  constructor (context) {
+    if (!(context instanceof DatadogSpanContext)) {
+      context = context
+        ? new DatadogSpanContext(context)
+        : newContext()
+    }
+    this._ddContext = context
+  }
+
+  get traceId () {
+    return this._ddContext._traceId.toString(16)
+  }
+
+  get spanId () {
+    return this._ddContext._spanId.toString(16)
+  }
+
+  get traceFlags () {
+    return this._ddContext._sampling.priority >= AUTO_KEEP ? 1 : 0
+  }
+
+  get traceState () {
+    const ts = this._ddContext._tracestate
+    return api.createTraceState(ts ? ts.toString() : '')
+  }
+}
+
+module.exports = SpanContext

package/packages/dd-trace/src/opentelemetry/span_processor.js

@@ -0,0 +1,50 @@
+'use strict'
+
+class NoopSpanProcessor {
+  forceFlush () {
+    return Promise.resolve()
+  }
+
+  onStart (span, context) { }
+  onEnd (span) { }
+
+  shutdown () {
+    return Promise.resolve()
+  }
+}
+
+class MultiSpanProcessor extends NoopSpanProcessor {
+  constructor (spanProcessors) {
+    super()
+    this._processors = spanProcessors
+  }
+
+  forceFlush () {
+    return Promise.all(
+      this._processors.map(p => p.forceFlush())
+    )
+  }
+
+  onStart (span, context) {
+    for (const processor of this._processors) {
+      processor.onStart(span, context)
+    }
+  }
+
+  onEnd (span) {
+    for (const processor of this._processors) {
+      processor.onEnd(span)
+    }
+  }
+
+  shutdown () {
+    return Promise.all(
+      this._processors.map(p => p.shutdown())
+    )
+  }
+}
+
+module.exports = {
+  MultiSpanProcessor,
+  NoopSpanProcessor
+}

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

@@ -0,0 +1,124 @@
+'use strict'
+
+const api = require('@opentelemetry/api')
+const { sanitizeAttributes } = require('@opentelemetry/core')
+
+const Sampler = require('./sampler')
+const Span = require('./span')
+const id = require('../id')
+const SpanContext = require('./span_context')
+
+class Tracer {
+  constructor (library, config, tracerProvider) {
+    this._sampler = new Sampler()
+    this._config = config
+    this._tracerProvider = tracerProvider
+    // Is there a reason this is public?
+    this.instrumentationLibrary = library
+  }
+
+  get resource () {
+    return this._tracerProvider.resource
+  }
+
+  startSpan (name, options = {}, context = api.context.active()) {
+    // remove span from context in case a root span is requested via options
+    if (options.root) {
+      context = api.trace.deleteSpan(context)
+    }
+    const parentSpan = api.trace.getSpan(context)
+    const parentSpanContext = parentSpan && parentSpan.spanContext()
+
+    let spanContext
+    // TODO: Need a way to get 128-bit trace IDs for the validity check API to work...
+    // if (parent && api.trace.isSpanContextValid(parent)) {
+    if (parentSpanContext && parentSpanContext.traceId) {
+      const parent = parentSpanContext._ddContext
+      spanContext = new SpanContext({
+        traceId: parent._traceId,
+        spanId: id(),
+        parentId: parent._spanId,
+        sampling: parent._sampling,
+        baggageItems: Object.assign({}, parent._baggageItems),
+        trace: parent._trace,
+        tracestate: parent._tracestate
+      })
+    } else {
+      spanContext = new SpanContext()
+    }
+
+    const spanKind = options.kind || api.SpanKind.INTERNAL
+    const links = (options.links || []).map(link => {
+      return {
+        context: link.context,
+        attributes: sanitizeAttributes(link.attributes)
+      }
+    })
+    const attributes = sanitizeAttributes(options.attributes)
+
+    // TODO: sampling API is not yet supported
+    // // make sampling decision
+    // const samplingResult = this._sampler.shouldSample(
+    //   context,
+    //   spanContext.traceId,
+    //   name,
+    //   spanKind,
+    //   attributes,
+    //   links
+    // )
+
+    // // Should use new span context
+    // spanContext._ddContext._sampling.priority =
+    //   samplingResult.decision === api.SamplingDecision.RECORD_AND_SAMPLED
+    //     ? AUTO_KEEP
+    //     : AUTO_REJECT
+
+    // if (samplingResult.decision === api.SamplingDecision.NOT_RECORD) {
+    //   api.diag.debug('Recording is off, propagating context in a non-recording span')
+    //   return api.trace.wrapSpanContext(spanContext)
+    // }
+
+    const span = new Span(
+      this,
+      context,
+      name,
+      spanContext,
+      spanKind,
+      links,
+      options.startTime
+    )
+    // Set initial span attributes. The attributes object may have been mutated
+    // by the sampler, so we sanitize the merged attributes before setting them.
+    const initAttributes = sanitizeAttributes(
+      // Object.assign(attributes, samplingResult.attributes)
+      attributes
+    )
+    span.setAttributes(initAttributes)
+    return span
+  }
+
+  startActiveSpan (name, options, context, fn) {
+    if (arguments.length === 2) {
+      fn = options
+      context = undefined
+      options = undefined
+    } else if (arguments.length === 3) {
+      fn = context
+      context = undefined
+    } else if (arguments.length !== 4) {
+      return
+    }
+
+    const parentContext = context || api.context.active()
+    const span = this.startSpan(name, options, parentContext)
+    const contextWithSpanSet = api.trace.setSpan(parentContext, span)
+
+    return api.context.with(contextWithSpanSet, fn, undefined, span)
+  }
+
+  getActiveSpanProcessor () {
+    return this._tracerProvider.getActiveSpanProcessor()
+  }
+}
+
+module.exports = Tracer

package/packages/dd-trace/src/opentelemetry/tracer_provider.js

@@ -0,0 +1,72 @@
+'use strict'
+
+const { trace, context } = require('@opentelemetry/api')
+
+const tracer = require('../../')
+
+const ContextManager = require('./context_manager')
+const { MultiSpanProcessor, NoopSpanProcessor } = require('./span_processor')
+const Tracer = require('./tracer')
+
+class TracerProvider {
+  constructor (config = {}) {
+    this.config = config
+    this.resource = config.resource
+
+    this._processors = []
+    this._tracers = new Map()
+    this._activeProcessor = new NoopSpanProcessor()
+    this._contextManager = new ContextManager()
+  }
+
+  getTracer (name = 'opentelemetry', version = '0.0.0', options) {
+    const key = `${name}@${version}`
+    if (!this._tracers.has(key)) {
+      this._tracers.set(key, new Tracer(
+        { ...options, name, version },
+        this.config,
+        this
+      ))
+    }
+    return this._tracers.get(key)
+  }
+
+  addSpanProcessor (spanProcessor) {
+    if (!this._processors.length) {
+      this._activeProcessor.shutdown()
+    }
+    this._processors.push(spanProcessor)
+    this._activeProcessor = new MultiSpanProcessor(
+      this._processors
+    )
+  }
+
+  getActiveSpanProcessor () {
+    return this._activeProcessor
+  }
+
+  // Not actually required by the SDK spec, but the official Node.js SDK does
+  // this and the docs reflect that so we should do this too for familiarity.
+  register (config = {}) {
+    context.setGlobalContextManager(this._contextManager)
+    if (!trace.setGlobalTracerProvider(this)) {
+      trace.getTracerProvider().setDelegate(this)
+    }
+  }
+
+  forceFlush () {
+    const exporter = tracer._tracer._exporter
+    if (!exporter) {
+      return Promise.reject(new Error('Not started'))
+    }
+
+    exporter._writer.flush()
+    return this._activeProcessor.forceFlush()
+  }
+
+  shutdown () {
+    return this._activeProcessor.shutdown()
+  }
+}
+
+module.exports = TracerProvider

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

@@ -44,6 +44,8 @@ class DatadogSpan {
     this._spanContext._tags = tags
     this._spanContext._hostname = hostname
 
+    this._spanContext._trace.started.push(this)
+
     this._startTime = fields.startTime || this._getTime()
 
     if (DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
@@ -147,8 +149,14 @@ class DatadogSpan {
 
   _createContext (parent, fields) {
     let spanContext
+    let startTime
 
-    if (parent) {
+    if (fields.context) {
+      spanContext = fields.context
+      if (!spanContext._trace.startTime) {
+        startTime = dateNow()
+      }
+    } else if (parent) {
       spanContext = new SpanContext({
         traceId: parent._traceId,
         spanId: id(),
@@ -160,11 +168,11 @@ class DatadogSpan {
       })
 
       if (!spanContext._trace.startTime) {
-        spanContext._trace.startTime = dateNow()
+        startTime = dateNow()
       }
     } else {
       const spanId = id()
-      const startTime = dateNow()
+      startTime = dateNow()
       spanContext = new SpanContext({
         traceId: spanId,
         spanId
@@ -178,8 +186,10 @@ class DatadogSpan {
       }
     }
 
-    spanContext._trace.started.push(this)
     spanContext._trace.ticks = spanContext._trace.ticks || now()
+    if (startTime) {
+      spanContext._trace.startTime = startTime
+    }
 
     return spanContext
   }

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

@@ -26,8 +26,13 @@ const disabledPlugins = new Set(
 const pluginClasses = {}
 
 loadChannel.subscribe(({ name }) => {
-  const Plugin = plugins[name]
+  maybeEnable(plugins[name])
+})
+
+// Globals
+maybeEnable(require('../../datadog-plugin-fetch/src'))
 
+function maybeEnable (Plugin) {
   if (!Plugin || typeof Plugin !== 'function') return
   if (!pluginClasses[Plugin.id]) {
     const envName = `DD_TRACE_${Plugin.id.toUpperCase()}_ENABLED`
@@ -42,7 +47,7 @@ loadChannel.subscribe(({ name }) => {
       pluginClasses[Plugin.id] = Plugin
     }
   }
-})
+}
 
 // TODO this must always be a singleton.
 module.exports = class PluginManager {
@@ -68,7 +73,7 @@ module.exports = class PluginManager {
 
     if (!Plugin) return
     if (!this._pluginsByName[name]) {
-      this._pluginsByName[name] = new Plugin(this._tracer)
+      this._pluginsByName[name] = new Plugin(this._tracer, this._tracerConfig)
     }
     if (!this._tracerConfig) return // TODO: don't wait for tracer to be initialized
 
@@ -76,6 +81,7 @@ module.exports = class PluginManager {
       enabled: this._tracerConfig.plugins !== false
     }
 
+    // extracts predetermined configuration from tracer and combines it with plugin-specific config
     this._pluginsByName[name].configure({
       ...this._getSharedConfig(name),
       ...pluginConfig
@@ -127,8 +133,7 @@ module.exports = class PluginManager {
       serviceMapping,
       queryStringObfuscation,
       site,
-      url,
-      dbmPropagationMode
+      url
     } = this._tracerConfig
 
     const sharedConfig = {}
@@ -141,8 +146,6 @@ module.exports = class PluginManager {
       sharedConfig.queryStringObfuscation = queryStringObfuscation
     }
 
-    sharedConfig.dbmPropagationMode = dbmPropagationMode
-
     if (serviceMapping && serviceMapping[name]) {
       sharedConfig.service = serviceMapping[name]
     }

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

@@ -38,13 +38,17 @@ class DatabasePlugin extends StoragePlugin {
   }
 
   injectDbmQuery (query, serviceName, isPreparedStatement = false) {
-    if (this.config.dbmPropagationMode === 'disabled') {
+    const mode = this.config.dbmPropagationMode || this._tracerConfig.dbmPropagationMode
+
+    if (mode === 'disabled') {
       return query
     }
+
     const servicePropagation = this.createDBMPropagationCommentService(serviceName)
-    if (isPreparedStatement || this.config.dbmPropagationMode === 'service') {
+
+    if (isPreparedStatement || mode === 'service') {
       return `/*${servicePropagation}*/ ${query}`
-    } else if (this.config.dbmPropagationMode === 'full') {
+    } else if (mode === 'full') {
       this.activeSpan.setTag('_dd.dbm_trace_injected', 'true')
       const traceparent = this.activeSpan._spanContext.toTraceparent()
       return `/*${servicePropagation},traceparent='${traceparent}'*/ ${query}`

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

@@ -26,10 +26,12 @@ class Subscription {
 }
 
 module.exports = class Plugin {
-  constructor (tracer) {
+  constructor (tracer, tracerConfig) {
     this._subscriptions = []
     this._enabled = false
     this._tracer = tracer
+    this.config = {} // plugin-specific configuration, unset until .configure() is called
+    this._tracerConfig = tracerConfig // global tracer configuration
   }
 
   get tracer () {

package/packages/dd-trace/src/plugins/util/exec.js

@@ -1,8 +1,8 @@
 const cp = require('child_process')
 
-const sanitizedExec = (cmd, options = {}) => {
+const sanitizedExec = (cmd, flags, options = { stdio: 'pipe' }) => {
   try {
-    return cp.execSync(cmd, options).toString().replace(/(\r\n|\n|\r)/gm, '')
+    return cp.execFileSync(cmd, flags, options).toString().replace(/(\r\n|\n|\r)/gm, '')
   } catch (e) {
     return ''
   }