dd-trace 2.12.1 → 2.12.2

package/LICENSE-3rdparty.csv

@@ -18,7 +18,6 @@ require,methods,MIT,Copyright 2013-2014 TJ Holowaychuk
 require,module-details-from-path,MIT,Copyright 2016 Thomas Watson Steen
 require,opentracing,MIT,Copyright 2016 Resonance Labs Inc
 require,path-to-regexp,MIT,Copyright 2014 Blake Embrey
-require,performance-now,MIT,Copyright 2013 Braveg1rl
 require,retry,MIT,Copyright 2011 Tim Koschützki Felix Geisendörfer
 require,semver,ISC,Copyright Isaac Z. Schlueter and Contributors
 dev,autocannon,MIT,Copyright 2016 Matteo Collina

package/ext/formats.js

@@ -1,10 +1,8 @@
 'use strict'
 
-const opentracing = require('opentracing')
-
 module.exports = {
-  TEXT_MAP: opentracing.FORMAT_TEXT_MAP,
-  HTTP_HEADERS: opentracing.FORMAT_HTTP_HEADERS,
-  BINARY: opentracing.FORMAT_BINARY,
+  TEXT_MAP: 'text_map',
+  HTTP_HEADERS: 'http_headers',
+  BINARY: 'binary',
   LOG: 'log'
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "2.12.1",
+  "version": "2.12.2",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -59,8 +59,8 @@
   },
   "dependencies": {
     "@datadog/native-appsec": "^1.2.1",
-    "@datadog/native-metrics": "^1.4.1",
-    "@datadog/pprof": "^1.0.0",
+    "@datadog/native-metrics": "^1.4.2",
+    "@datadog/pprof": "^1.0.2",
     "@datadog/sketches-js": "^1.0.5",
     "@types/node": ">=12",
     "crypto-randomuuid": "^1.0.0",
@@ -77,7 +77,6 @@
     "module-details-from-path": "^1.0.3",
     "opentracing": ">=0.12.1",
     "path-to-regexp": "^0.1.2",
-    "performance-now": "^2.1.0",
     "retry": "^0.10.1",
     "semver": "^5.5.0"
   },

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

@@ -98,7 +98,7 @@ function wrapNext (req, next) {
     nextChannel.publish({ req })
     exitChannel.publish({ req })
 
-    next.apply(null, arguments)
+    next.apply(this, arguments)
   }
 }
 

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

@@ -145,7 +145,7 @@ function wrapNext (req, next) {
   return function () {
     nextChannel.publish({ req })
 
-    return next.apply(null, arguments)
+    return next.apply(this, arguments)
   }
 }
 

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

@@ -153,7 +153,10 @@ function mochaHook (Runner) {
       if (isHook && testOrHook.ctx) {
         test = testOrHook.ctx.currentTest
       }
-      const asyncResource = getTestAsyncResource(test)
+      let asyncResource
+      if (test) {
+        asyncResource = getTestAsyncResource(test)
+      }
       if (asyncResource) {
         asyncResource.runInAsyncScope(() => {
           if (isHook) {

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

@@ -6,7 +6,10 @@ const handlers = ['use', 'pre']
 const methods = ['del', 'get', 'head', 'opts', 'post', 'put', 'patch']
 
 const handleChannel = channel('apm:restify:request:handle')
-const routeChannel = channel('apm:restify:request:route')
+const errorChannel = channel('apm:restify:middleware:error')
+const enterChannel = channel('apm:restify:middleware:enter')
+const exitChannel = channel('apm:restify:middleware:exit')
+const nextChannel = channel('apm:restify:middleware:next')
 
 function wrapSetupRequest (setupRequest) {
   return function (req, res) {
@@ -37,18 +40,37 @@ function wrapFn (fn) {
   if (Array.isArray(fn)) return wrapMiddleware(fn)
 
   return function (req, res, next) {
-    if (req.route) {
-      routeChannel.publish({ req, route: req.route })
+    if (typeof next === 'function') {
+      arguments[2] = wrapNext(req, next)
     }
 
-    return fn.apply(this, arguments)
+    const route = req.route && req.route.path
+
+    enterChannel.publish({ req, route })
+
+    try {
+      return fn.apply(this, arguments)
+    } catch (error) {
+      errorChannel.publish({ req, error })
+      nextChannel.publish({ req })
+      exitChannel.publish({ req })
+    }
+  }
+}
+
+function wrapNext (req, next) {
+  return function () {
+    nextChannel.publish({ req })
+    exitChannel.publish({ req })
+
+    next.apply(this, arguments)
   }
 }
 
 addHook({ name: 'restify', versions: ['>=3'], file: 'lib/server.js' }, Server => {
   shimmer.wrap(Server.prototype, '_setupRequest', wrapSetupRequest)
   shimmer.massWrap(Server.prototype, handlers, wrapHandler)
-  shimmer.wrap(Server.prototype, methods, wrapMethod)
+  shimmer.massWrap(Server.prototype, methods, wrapMethod)
 
   return Server
 })

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

@@ -97,7 +97,7 @@ function createWrapRouterMethod (name) {
       nextChannel.publish({ req })
       exitChannel.publish({ req })
 
-      next.apply(null, arguments)
+      next.apply(this, arguments)
     }
   }
 

package/packages/datadog-plugin-aws-sdk/src/base.js

@@ -1,6 +1,5 @@
 'use strict'
 
-const Tags = require('opentracing').Tags
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 const Plugin = require('../../dd-trace/src/plugins/plugin')
 const { storage } = require('../../datadog-core')
@@ -33,7 +32,7 @@ class BaseAwsSdkPlugin extends Plugin {
       const serviceName = this.getServiceName(serviceIdentifier)
       const childOf = this.tracer.scope().active()
       const tags = {
-        [Tags.SPAN_KIND]: 'client',
+        'span.kind': 'client',
         'service.name': serviceName,
         'aws.operation': operation,
         'aws.region': awsRegion,

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

@@ -1,6 +1,5 @@
 'use strict'
 
-const Tags = require('opentracing').Tags
 const log = require('../../../dd-trace/src/log')
 const BaseAwsSdkPlugin = require('../base')
 const { storage } = require('../../../datadog-core')
@@ -25,7 +24,7 @@ class Sqs extends BaseAwsSdkPlugin {
           tags: Object.assign(
             {},
             this.requestTags.get(request) || {},
-            { [Tags.SPAN_KIND]: 'server' }
+            { 'span.kind': 'server' }
           )
         }
         const span = plugin.tracer.startSpan('aws.response', options)

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

@@ -19,6 +19,13 @@ class RestifyPlugin extends RouterPlugin {
       web.setRoute(req, route)
     })
   }
+
+  configure (config) {
+    return super.configure({
+      ...config,
+      middleware: false // not supported
+    })
+  }
 }
 
 module.exports = RestifyPlugin

package/packages/dd-trace/src/encode/0.4.js

@@ -57,6 +57,10 @@ class AgentEncoder {
     return buffer
   }
 
+  reset () {
+    this._reset()
+  }
+
   _encode (bytes, trace) {
     this._encodeArrayPrefix(bytes, trace)
 

package/packages/dd-trace/src/exporters/common/request.js

@@ -1,22 +1,33 @@
 'use strict'
 
+// TODO: Add test with slow or unresponsive agent.
+// TODO: Add telemetry for things like dropped requests, errors, etc.
+
 const http = require('http')
 const https = require('https')
-const log = require('../../log')
 const docker = require('./docker')
 const { storage } = require('../../../../datadog-core')
 
-const httpAgent = new http.Agent({ keepAlive: true })
-const httpsAgent = new https.Agent({ keepAlive: true })
+const keepAlive = true
+const maxTotalSockets = 1
+const maxActiveRequests = 8
+const httpAgent = new http.Agent({ keepAlive, maxTotalSockets })
+const httpsAgent = new https.Agent({ keepAlive, maxTotalSockets })
 const containerId = docker.id()
 
+let activeRequests = 0
+
 function request (data, options, keepAlive, callback) {
   if (!options.headers) {
     options.headers = {}
   }
+
+  // The timeout should be kept low to avoid excessive queueing.
+  const timeout = options.timeout || 2000
   const isSecure = options.protocol === 'https:'
   const client = isSecure ? https : http
   const dataArray = [].concat(data)
+
   options.headers['Content-Length'] = byteLength(dataArray)
 
   if (containerId) {
@@ -27,39 +38,15 @@ function request (data, options, keepAlive, callback) {
     options.agent = isSecure ? httpsAgent : httpAgent
   }
 
-  const firstRequest = retriableRequest(options, client, callback)
-  dataArray.forEach(buffer => firstRequest.write(buffer))
-
-  // The first request will be retried
-  const firstRequestErrorHandler = () => {
-    log.debug('Retrying request to the intake')
-    const retriedReq = retriableRequest(options, client, callback)
-    dataArray.forEach(buffer => retriedReq.write(buffer))
-    // The retried request will fail normally
-    retriedReq.on('error', e => callback(new Error(`Network error trying to reach the intake: ${e.message}`)))
-    retriedReq.end()
-  }
-
-  firstRequest.on('error', firstRequestErrorHandler)
-  firstRequest.end()
-
-  return firstRequest
-}
-
-function retriableRequest (options, client, callback) {
-  const store = storage.getStore()
-
-  storage.enterWith({ noop: true })
-
-  const timeout = options.timeout || 15000
-
-  const request = client.request(options, res => {
+  const onResponse = res => {
     let responseData = ''
 
     res.setTimeout(timeout)
 
     res.on('data', chunk => { responseData += chunk })
     res.on('end', () => {
+      activeRequests--
+
       if (res.statusCode >= 200 && res.statusCode <= 299) {
         callback(null, responseData, res.statusCode)
       } else {
@@ -69,15 +56,43 @@ function retriableRequest (options, client, callback) {
         callback(error, null, res.statusCode)
       }
     })
-  })
-  request.setTimeout(timeout, request.abort)
-  storage.enterWith(store)
+  }
 
-  return request
+  const makeRequest = onError => {
+    if (!request.writable) return callback(null)
+
+    activeRequests++
+
+    const store = storage.getStore()
+
+    storage.enterWith({ noop: true })
+
+    const req = client.request(options, onResponse)
+
+    req.once('error', err => {
+      activeRequests--
+      onError(err)
+    })
+
+    dataArray.forEach(buffer => req.write(buffer))
+
+    req.setTimeout(timeout, req.abort)
+    req.end()
+
+    storage.enterWith(store)
+  }
+
+  makeRequest(() => makeRequest(callback))
 }
 
 function byteLength (data) {
   return data.length > 0 ? data.reduce((prev, next) => prev + next.length, 0) : 0
 }
 
+Object.defineProperty(request, 'writable', {
+  get () {
+    return activeRequests < maxActiveRequests
+  }
+})
+
 module.exports = request

package/packages/dd-trace/src/exporters/common/writer.js

@@ -1,4 +1,6 @@
 'use strict'
+
+const request = require('./request')
 const log = require('../../log')
 
 class Writer {
@@ -9,7 +11,10 @@ class Writer {
   flush (done = () => {}) {
     const count = this._encoder.count()
 
-    if (count > 0) {
+    if (!request.writable) {
+      this._encoder.reset()
+      done()
+    } else if (count > 0) {
       const payload = this._encoder.makePayload()
 
       this._sendPayload(payload, count, done)
@@ -19,6 +24,8 @@ class Writer {
   }
 
   append (spans) {
+    if (!request.writable) return
+
     log.debug(() => `Encoding trace: ${JSON.stringify(spans)}`)
 
     this._encode(spans)

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

@@ -1,26 +1,26 @@
 'use strict'
 
-const Span = require('opentracing').Span
-const NoopSpanContext = require('../noop/span_context')
+const NoopSpanContext = require('./span_context')
 const id = require('../id')
 const { storage } = require('../../../datadog-core') // TODO: noop storage?
 
-class NoopSpan extends Span {
+class NoopSpan {
   constructor (tracer, parent) {
-    super()
-
     this._store = storage.getStore()
     this._noopTracer = tracer
     this._noopContext = this._createContext(parent)
   }
 
-  _context () {
-    return this._noopContext
-  }
-
-  _tracer () {
-    return this._noopTracer
-  }
+  context () { return this._noopContext }
+  tracer () { return this._noopTracer }
+  setOperationName (name) { return this }
+  setBaggageItem (key, value) { return this }
+  getBaggageItem (key) {}
+  setTag (key, value) { return this }
+  addTags (keyValueMap) { return this }
+  log () { return this }
+  logEvent () {}
+  finish (finishTime) {}
 
   _createContext (parent) {
     const spanId = id()

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

@@ -1,13 +1,10 @@
 'use strict'
 
-const Tracer = require('opentracing').Tracer
 const Scope = require('../noop/scope')
 const Span = require('./span')
 
-class NoopTracer extends Tracer {
+class NoopTracer {
   constructor (config) {
-    super(config)
-
     this._scope = new Scope()
     this._span = new Span(this)
   }
@@ -35,10 +32,16 @@ class NoopTracer extends Tracer {
   setUrl () {
   }
 
-  _startSpan (name, options) {
+  startSpan (name, options) {
     return this._span
   }
 
+  inject (spanContext, format, carrier) {}
+
+  extract (format, carrier) {
+    return this._span.context()
+  }
+
   setUser () {
     return this
   }

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/plugins/util/web.js

@@ -2,7 +2,7 @@
 
 const uniq = require('lodash.uniq')
 const analyticsSampler = require('../../analytics_sampler')
-const FORMAT_HTTP_HEADERS = require('opentracing').FORMAT_HTTP_HEADERS
+const FORMAT_HTTP_HEADERS = 'http_headers'
 const log = require('../../log')
 const tags = require('../../../../../ext/tags')
 const types = require('../../../../../ext/types')

package/packages/dd-trace/src/profiling/profilers/cpu.js

@@ -20,7 +20,7 @@ function getStartedSpans (activeSpan) {
 }
 
 function getSpanContextTags (span) {
-  return span._context()._tags
+  return span.context()._tags
 }
 
 function isWebServerSpan (tags) {
@@ -55,13 +55,13 @@ class NativeCpuProfiler {
     const active = getActiveSpan()
     if (!active) return
 
-    const activeCtx = active._context()
+    const activeCtx = active.context()
     if (!activeCtx) return
 
     const spans = getStartedSpans(active)
     if (!spans || !spans.length) return
 
-    const firstCtx = spans[0]._context()
+    const firstCtx = spans[0].context()
     if (!firstCtx) return
 
     const labels = {

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

@@ -1,6 +1,5 @@
 'use strict'
 
-const BaseTracer = require('opentracing').Tracer
 const NoopTracer = require('./noop/tracer')
 const DatadogTracer = require('./tracer')
 const Config = require('./config')
@@ -14,10 +13,8 @@ const telemetry = require('./telemetry')
 
 const noop = new NoopTracer()
 
-class Tracer extends BaseTracer {
+class Tracer {
   constructor () {
-    super()
-
     this._initialized = false
     this._tracer = noop
     this._instrumenter = new Instrumenter(this)