dd-trace 2.2.1 → 2.3.0

package/index.d.ts

@@ -266,6 +266,12 @@ export declare interface TracerOptions {
    */
   flushInterval?: number;
 
+  /**
+   *  Number of spans before partially exporting a trace. This prevents keeping all the spans in memory for very large traces.
+   * @default 1000
+   */
+   flushMinSpans?: number;
+
   /**
    * Whether to enable runtime metrics.
    * @default false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",

package/packages/datadog-instrumentations/index.js

@@ -3,6 +3,7 @@
 require('./src/bluebird')
 require('./src/bunyan')
 require('./src/couchbase')
+require('./src/cucumber')
 require('./src/dns')
 require('./src/elasticsearch')
 require('./src/generic-pool')

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

@@ -0,0 +1,116 @@
+'use strict'
+
+const { addHook, channel } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const runStartCh = channel('ci:cucumber:run:start')
+const runEndCh = channel('ci:cucumber:run:end')
+const runAsyncEndCh = channel('ci:cucumber:run:async-end')
+const runStepStartCh = channel('ci:cucumber:run-step:start')
+const runStepEndCh = channel('ci:cucumber:run-step:end')
+const errorCh = channel('ci:cucumber:error')
+
+function getStatusFromResult (result) {
+  if (result.status === 1) {
+    return { status: 'pass' }
+  }
+  if (result.status === 2) {
+    return { status: 'skip' }
+  }
+  if (result.status === 4) {
+    return { status: 'skip', skipReason: 'not implemented' }
+  }
+  return { status: 'fail', errorMessage: result.message }
+}
+
+function getStatusFromResultLatest (result) {
+  if (result.status === 'PASSED') {
+    return { status: 'pass' }
+  }
+  if (result.status === 'SKIPPED' || result.status === 'PENDING') {
+    return { status: 'skip' }
+  }
+  if (result.status === 'UNDEFINED') {
+    return { status: 'skip', skipReason: 'not implemented' }
+  }
+  return { status: 'fail', errorMessage: result.message }
+}
+
+function wrapRun (pl, isLatestVersion) {
+  shimmer.wrap(pl.prototype, 'run', run => function () {
+    if (!runStartCh.hasSubscribers) {
+      return run.apply(this, arguments)
+    }
+
+    runStartCh.publish({ pickleName: this.pickle.name, pickleUri: this.pickle.uri })
+    try {
+      const promise = run.apply(this, arguments)
+      promise.finally(() => {
+        const result = this.getWorstStepResult()
+        const { status, skipReason, errorMessage } = isLatestVersion
+          ? getStatusFromResultLatest(result) : getStatusFromResult(result)
+
+        runAsyncEndCh.publish({ status, skipReason, errorMessage })
+      })
+      return promise
+    } catch (err) {
+      errorCh.publish(err)
+    } finally {
+      runEndCh.publish(undefined)
+    }
+  })
+  shimmer.wrap(pl.prototype, 'runStep', runStep => function () {
+    if (!runStepStartCh.hasSubscribers) {
+      return runStep.apply(this, arguments)
+    }
+    const testStep = arguments[0]
+    let resource
+
+    if (isLatestVersion) {
+      resource = testStep.text
+    } else {
+      resource = testStep.isHook ? 'hook' : testStep.pickleStep.text
+    }
+
+    runStepStartCh.publish({ resource })
+    try {
+      const promise = runStep.apply(this, arguments)
+
+      promise.then((result) => {
+        const { status, skipReason, errorMessage } = isLatestVersion
+          ? getStatusFromResultLatest(result) : getStatusFromResult(result)
+
+        runAsyncEndCh.publish({ isStep: true, status, skipReason, errorMessage })
+      })
+      return promise
+    } catch (err) {
+      errorCh.publish(err)
+    } finally {
+      runStepEndCh.publish(undefined)
+    }
+  })
+}
+
+addHook({
+  name: '@cucumber/cucumber',
+  versions: ['7.0.0 - 7.2.1'],
+  file: 'lib/runtime/pickle_runner.js'
+}, (PickleRunner) => {
+  const pl = PickleRunner.default
+
+  wrapRun(pl, false)
+
+  return PickleRunner
+})
+
+addHook({
+  name: '@cucumber/cucumber',
+  versions: ['>=7.3.0'],
+  file: 'lib/runtime/test_case_runner.js'
+}, (TestCaseRunner) => {
+  const pl = TestCaseRunner.default
+
+  wrapRun(pl, true)
+
+  return TestCaseRunner
+})

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

@@ -35,18 +35,20 @@ function wrapRequest (request) {
 
     if (!params) return request.apply(this, arguments)
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    const parentResource = new AsyncResource('bound-anonymous-fn')
 
     startCh.publish({ params })
 
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+
     try {
       const lastIndex = arguments.length - 1
       cb = arguments[lastIndex]
 
       if (typeof cb === 'function') {
-        cb = asyncResource.bind(cb)
+        cb = parentResource.bind(cb)
 
-        arguments[lastIndex] = AsyncResource.bind(function (error) {
+        arguments[lastIndex] = asyncResource.bind(function (error) {
           finish(params, error)
           return cb.apply(null, arguments)
         })
@@ -54,7 +56,10 @@ function wrapRequest (request) {
       } else {
         const promise = request.apply(this, arguments)
         if (promise && typeof promise.then === 'function') {
-          promise.then(() => finish(params), e => finish(params, e))
+          const onResolve = asyncResource.bind(() => finish(params))
+          const onReject = asyncResource.bind(e => finish(params, e))
+
+          promise.then(onResolve, onReject)
         } else {
           finish(params)
         }

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

@@ -2,7 +2,8 @@
 
 const {
   channel,
-  addHook
+  addHook,
+  AsyncResource
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -21,12 +22,14 @@ addHook({ name: 'ioredis', versions: ['>=2'] }, Redis => {
     const connectionName = options.connectionName
     const db = options.db
     const connectionOptions = { host: options.host, port: options.port }
+
     startCh.publish({ db, command: command.name, args: command.args, connectionOptions, connectionName })
 
-    command.promise.then(
-      () => finish(asyncEndCh, errorCh),
-      err => finish(asyncEndCh, errorCh, err)
-    )
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    const onResolve = asyncResource.bind(() => finish(asyncEndCh, errorCh))
+    const onReject = asyncResource.bind(err => finish(asyncEndCh, errorCh, err))
+
+    command.promise.then(onResolve, onReject)
 
     try {
       return sendCommand.apply(this, arguments)

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

@@ -21,14 +21,14 @@ addHook({ name: '@node-redis/client', file: 'dist/lib/client/commands-queue.js',
     const name = command[0]
     const args = command.slice(1)
 
-    startSpan(this, name, args)
+    start(this, name, args)
 
     const res = addCommand.apply(this, arguments)
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    const onResolve = asyncResource.bind(() => finish(asyncEndCh, errorCh))
+    const onReject = asyncResource.bind(err => finish(asyncEndCh, errorCh, err))
 
-    res.then(
-      () => finish(asyncEndCh, errorCh),
-      err => finish(asyncEndCh, errorCh, err)
-    )
+    res.then(onResolve, onReject)
     endCh.publish(undefined)
     return res
   })
@@ -45,7 +45,7 @@ addHook({ name: 'redis', versions: ['>=2.6 <4'] }, redis => {
 
     const cb = asyncResource.bind(options.callback)
 
-    startSpan(this, options.command, options.args)
+    start(this, options.command, options.args)
 
     options.callback = AsyncResource.bind(wrapCallback(asyncEndCh, errorCh, cb))
 
@@ -70,7 +70,7 @@ addHook({ name: 'redis', versions: ['>=0.12 <2.6'] }, redis => {
 
     const asyncResource = new AsyncResource('bound-anonymous-fn')
 
-    startSpan(this, command, args)
+    start(this, command, args)
 
     if (typeof callback === 'function') {
       const cb = asyncResource.bind(callback)
@@ -95,7 +95,7 @@ addHook({ name: 'redis', versions: ['>=0.12 <2.6'] }, redis => {
   return redis
 })
 
-function startSpan (client, command, args) {
+function start (client, command, args) {
   const db = client.selected_db
   const connectionOptions = client.connection_options || client.connection_option || client.connectionOption || {}
   startCh.publish({ db, command, args, connectionOptions })

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/dd-trace/lib/version.js

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

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

@@ -99,6 +99,11 @@ class Config {
       process.env.DD_TRACE_AGENT_PROTOCOL_VERSION,
       '0.4'
     )
+    const DD_TRACE_PARTIAL_FLUSH_MIN_SPANS = coalesce(
+      parseInt(options.flushMinSpans),
+      parseInt(process.env.DD_TRACE_PARTIAL_FLUSH_MIN_SPANS),
+      1000
+    )
     const DD_TRACE_B3_ENABLED = coalesce(
       options.experimental && options.experimental.b3,
       process.env.DD_TRACE_EXPERIMENTAL_B3_ENABLED,
@@ -166,6 +171,7 @@ class Config {
     this.hostname = DD_AGENT_HOST || (this.url && this.url.hostname)
     this.port = String(DD_TRACE_AGENT_PORT || (this.url && this.url.port))
     this.flushInterval = coalesce(parseInt(options.flushInterval, 10), defaultFlushInterval)
+    this.flushMinSpans = DD_TRACE_PARTIAL_FLUSH_MIN_SPANS
     this.sampleRate = coalesce(Math.min(Math.max(sampler.sampleRate, 0), 1), 1)
     this.logger = options.logger
     this.plugins = !!coalesce(options.plugins, true)
@@ -229,7 +235,7 @@ function getAgentUrl (url, options) {
     !process.env.DD_TRACE_AGENT_PORT &&
     fs.existsSync('/var/run/datadog/apm.socket')
   ) {
-    return new URL('file:///var/run/datadog/apm.socket')
+    return new URL('unix:///var/run/datadog/apm.socket')
   }
 }
 

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

@@ -35,7 +35,7 @@ class DatadogTracer extends Tracer {
     this._debug = config.debug
     this._prioritySampler = new PrioritySampler(config.env, config.experimental.sampler)
     this._exporter = new Exporter(config, this._prioritySampler)
-    this._processor = new SpanProcessor(this._exporter, this._prioritySampler)
+    this._processor = new SpanProcessor(this._exporter, this._prioritySampler, config)
     this._url = this._exporter._url
     this._enableGetRumData = config.experimental.enableGetRumData
     this._propagators = {

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

@@ -34,11 +34,16 @@ module.exports = class LogPlugin extends Plugin {
     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)
-      }
+      if (!this.tracer._logInjection) return
+
+      const store = storage.getStore()
+      const span = store && store.span
+
+      if (!span) return
+
+      const holder = {}
+      this.tracer.inject(span, LOG, holder)
+      arg.message = messageProxy(arg.message, holder)
     })
   }
 }

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

@@ -37,7 +37,7 @@ function getGitMetadata (ciMetadata) {
     committerName,
     committerEmail,
     committerDate
-  ] = sanitizedExec('git show -s --format=%an,%ae,%ad,%cn,%ce,%cd', { stdio: 'pipe' }).split(',')
+  ] = sanitizedExec('git show -s --format=%an,%ae,%aI,%cn,%ce,%cI', { stdio: 'pipe' }).split(',')
 
   return {
     [GIT_REPOSITORY_URL]:

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

@@ -1,3 +1,5 @@
+'use strict'
+
 const log = require('./log')
 const format = require('./format')
 
@@ -5,24 +7,37 @@ const startedSpans = new WeakSet()
 const finishedSpans = new WeakSet()
 
 class SpanProcessor {
-  constructor (exporter, prioritySampler) {
+  constructor (exporter, prioritySampler, config) {
     this._exporter = exporter
     this._prioritySampler = prioritySampler
+    this._config = config
   }
 
   process (span) {
     const spanContext = span.context()
+    const active = []
+    const formatted = []
     const trace = spanContext._trace
+    const { flushMinSpans } = this._config
+    const { started, finished } = trace
 
-    if (trace.started.length === trace.finished.length) {
+    if (started.length === finished.length || finished.length >= flushMinSpans) {
       this._prioritySampler.sample(spanContext)
-      const formattedSpans = trace.finished.map(format)
-      this._exporter.export(formattedSpans)
-      this._erase(trace)
+
+      for (const span of started) {
+        if (span._duration !== undefined) {
+          formatted.push(format(span))
+        } else {
+          active.push(span)
+        }
+      }
+
+      this._exporter.export(formatted)
+      this._erase(trace, active)
     }
   }
 
-  _erase (trace) {
+  _erase (trace, active) {
     if (process.env.DD_TRACE_EXPERIMENTAL_STATE_TRACKING === 'true') {
       const started = new Set()
       const startedIds = new Set()
@@ -98,7 +113,7 @@ class SpanProcessor {
       span.context()._tags = {}
     }
 
-    trace.started = []
+    trace.started = active
     trace.finished = []
   }
 }