dd-trace 2.4.2 → 2.7.0

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

@@ -1,28 +1,23 @@
 'use strict'
 
-const request = require('./request')
+const request = require('../common/request')
 const { startupLog } = require('../../startup-log')
 const metrics = require('../../metrics')
 const log = require('../../log')
 const tracerVersion = require('../../../lib/version')
+const BaseWriter = require('../common/writer')
 
 const METRIC_PREFIX = 'datadog.tracer.node.exporter.agent'
 
-class Writer {
-  constructor ({ url, prioritySampler, lookup, protocolVersion }) {
+class Writer extends BaseWriter {
+  constructor ({ prioritySampler, lookup, protocolVersion }) {
+    super(...arguments)
     const AgentEncoder = getEncoder(protocolVersion)
 
-    this._url = url
     this._prioritySampler = prioritySampler
     this._lookup = lookup
     this._protocolVersion = protocolVersion
-    this._encoderForVersion = new AgentEncoder(this)
-  }
-
-  append (spans) {
-    log.debug(() => `Encoding trace: ${JSON.stringify(spans)}`)
-
-    this._encode(spans)
+    this._encoder = new AgentEncoder(this)
   }
 
   _sendPayload (data, count, done) {
@@ -62,26 +57,6 @@ class Writer {
       done()
     })
   }
-
-  setUrl (url) {
-    this._url = url
-  }
-
-  _encode (trace) {
-    this._encoderForVersion.encode(trace)
-  }
-
-  flush (done = () => {}) {
-    const count = this._encoderForVersion.count()
-
-    if (count > 0) {
-      const payload = this._encoderForVersion.makePayload()
-
-      this._sendPayload(payload, count, done)
-    } else {
-      done()
-    }
-  }
 }
 
 function setHeader (headers, key, value) {
@@ -124,7 +99,7 @@ function makeRequest (version, data, count, url, lookup, needsStartupLog, cb) {
 
   log.debug(() => `Request to the agent: ${JSON.stringify(options)}`)
 
-  request(Object.assign({ data }, options), (err, res, status) => {
+  request(data, options, true, (err, res, status) => {
     if (needsStartupLog) {
       // Note that logging will only happen once, regardless of how many times this is called.
       startupLog({

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

@@ -0,0 +1,83 @@
+'use strict'
+
+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 containerId = docker.id()
+
+function request (data, options, keepAlive, callback) {
+  if (!options.headers) {
+    options.headers = {}
+  }
+  const isSecure = options.protocol === 'https:'
+  const client = isSecure ? https : http
+  const dataArray = [].concat(data)
+  options.headers['Content-Length'] = byteLength(dataArray)
+
+  if (containerId) {
+    options.headers['Datadog-Container-ID'] = containerId
+  }
+
+  if (keepAlive) {
+    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 => {
+    let responseData = ''
+
+    res.setTimeout(timeout)
+
+    res.on('data', chunk => { responseData += chunk })
+    res.on('end', () => {
+      if (res.statusCode >= 200 && res.statusCode <= 299) {
+        callback(null, responseData, res.statusCode)
+      } else {
+        const error = new Error(`Error from the endpoint: ${res.statusCode} ${http.STATUS_CODES[res.statusCode]}`)
+        error.status = res.statusCode
+
+        callback(error, null, res.statusCode)
+      }
+    })
+  })
+  request.setTimeout(timeout, request.abort)
+  storage.enterWith(store)
+
+  return request
+}
+
+function byteLength (data) {
+  return data.length > 0 ? data.reduce((prev, next) => prev + next.length, 0) : 0
+}
+
+module.exports = request

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

@@ -0,0 +1,36 @@
+'use strict'
+const log = require('../../log')
+
+class Writer {
+  constructor ({ url }) {
+    this._url = url
+  }
+
+  flush (done = () => {}) {
+    const count = this._encoder.count()
+
+    if (count > 0) {
+      const payload = this._encoder.makePayload()
+
+      this._sendPayload(payload, count, done)
+    } else {
+      done()
+    }
+  }
+
+  append (spans) {
+    log.debug(() => `Encoding trace: ${JSON.stringify(spans)}`)
+
+    this._encode(spans)
+  }
+
+  _encode (trace) {
+    this._encoder.encode(trace)
+  }
+
+  setUrl (url) {
+    this._url = url
+  }
+}
+
+module.exports = Writer

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

@@ -22,7 +22,6 @@ const map = {
 function format (span) {
   const formatted = formatSpan(span)
 
-  extractError(formatted, span)
   extractRootTags(formatted, span)
   extractChunkTags(formatted, span)
   extractTags(formatted, span)
@@ -74,8 +73,8 @@ function extractTags (trace, span) {
         addTag({}, trace.metrics, tag, tags[tag] === undefined || tags[tag] ? 1 : 0)
         break
       case 'error':
-        if (tags[tag] && (context._name !== 'fs.operation')) {
-          trace.error = 1
+        if (context._name !== 'fs.operation') {
+          extractError(trace, tags[tag])
         }
         break
       case 'error.type':
@@ -84,6 +83,8 @@ function extractTags (trace, span) {
         // HACK: remove when implemented in the backend
         if (context._name !== 'fs.operation') {
           trace.error = 1
+        } else {
+          break
         }
       default: // eslint-disable-line no-fallthrough
         addTag(trace.meta, trace.metrics, tag, tags[tag])
@@ -122,8 +123,11 @@ function extractChunkTags (trace, span) {
   }
 }
 
-function extractError (trace, span) {
-  const error = span.context()._tags['error']
+function extractError (trace, error) {
+  if (!error) return
+
+  trace.error = 1
+
   if (isError(error)) {
     addTag(trace.meta, trace.metrics, 'error.msg', error.message)
     addTag(trace.meta, trace.metrics, 'error.type', error.name)

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

@@ -7,6 +7,7 @@ const Loader = require('./loader')
 const { isTrue } = require('./util')
 const plugins = require('./plugins')
 const Plugin = require('./plugins/plugin')
+const telemetry = require('./telemetry')
 
 const disabledPlugins = process.env.DD_TRACE_DISABLED_PLUGINS
 
@@ -54,6 +55,7 @@ class Instrumenter {
 
     try {
       this._set(plugin, { name, config })
+      telemetry.updateIntegrations()
     } catch (e) {
       log.debug(`Could not find a plugin named "${name}".`)
     }
@@ -154,6 +156,7 @@ class Instrumenter {
 
     if (!instrumented) {
       this._instrumented.set(instrumentation, instrumented = new Set())
+      telemetry.updateIntegrations()
     }
 
     if (!instrumented.has(this._defaultExport(moduleExports))) {

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

@@ -11,7 +11,14 @@ function findRoot () {
 
 function findPkg () {
   const cwd = findRoot()
-  const filePath = findUp('package.json', cwd)
+  const directory = path.resolve(cwd)
+  const res = path.parse(directory)
+
+  if (!res) return {}
+
+  const { root } = res
+
+  const filePath = findUp('package.json', root, directory)
 
   try {
     return JSON.parse(fs.readFileSync(filePath, 'utf8'))
@@ -20,18 +27,16 @@ function findPkg () {
   }
 }
 
-function findUp (name, cwd) {
-  let directory = path.resolve(cwd)
-  const { root } = path.parse(directory)
-
+function findUp (name, root, directory) {
   while (true) {
     const current = path.resolve(directory, name)
 
     if (fs.existsSync(current)) return current
+
     if (directory === root) return
 
     directory = path.dirname(directory)
   }
 }
 
-module.exports = findPkg()
+module.exports = Object.assign(findPkg(), { findRoot, findUp })

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

@@ -27,9 +27,11 @@ function getConfig (name, config = {}) {
 module.exports = class PluginManager {
   constructor (tracer) {
     this._pluginsByName = {}
+    this._configsByName = {}
     for (const PluginClass of Object.values(plugins)) {
       if (typeof PluginClass !== 'function') continue
       this._pluginsByName[PluginClass.name] = new PluginClass(tracer)
+      this._configsByName[PluginClass.name] = {}
     }
   }
 
@@ -40,25 +42,29 @@ module.exports = class PluginManager {
       pluginConfig = { enabled: pluginConfig }
     }
 
-    this._pluginsByName[name].configure(getConfig(name, pluginConfig))
+    const config = {
+      ...this._configsByName[name],
+      ...pluginConfig
+    }
+
+    this._pluginsByName[name].configure(getConfig(name, config))
   }
 
   // like instrumenter.enable()
   configure (config) {
-    const serviceMapping = config.serviceMapping
+    const { logInjection, serviceMapping } = config
 
     if (config.plugins !== false) {
       for (const name in this._pluginsByName) {
-        const pluginConfig = {}
+        const pluginConfig = {
+          ...this._configsByName[name],
+          logInjection
+        }
         if (serviceMapping && serviceMapping[name]) {
           pluginConfig.service = serviceMapping[name]
         }
         this.configurePlugin(name, pluginConfig)
       }
-    } else {
-      for (const name in this._pluginsByName) {
-        this.configurePlugin(name, false)
-      }
     }
   }
 

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

@@ -14,6 +14,7 @@ module.exports = {
   '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'),
@@ -23,10 +24,8 @@ module.exports = {
   'http2': require('../../../datadog-plugin-http2/src'),
   'ioredis': require('../../../datadog-plugin-ioredis/src'),
   'jest': require('../../../datadog-plugin-jest/src'),
-  'knex': require('../../../datadog-plugin-knex/src'),
   'koa': require('../../../datadog-plugin-koa/src'),
   'kafkajs': require('../../../datadog-plugin-kafkajs/src'),
-  'limitd-client': require('../../../datadog-plugin-limitd-client/src'),
   'memcached': require('../../../datadog-plugin-memcached/src'),
   'microgateway-core': require('../../../datadog-plugin-microgateway-core/src'),
   'mocha': require('../../../datadog-plugin-mocha/src'),

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

@@ -31,11 +31,8 @@ function messageProxy (message, holder) {
 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) return
 
+    this.addSub(`apm:${this.constructor.name}:log`, (arg) => {
       const store = storage.getStore()
       const span = store && store.span
 
@@ -46,4 +43,11 @@ module.exports = class LogPlugin extends Plugin {
       arg.message = messageProxy(arg.message, holder)
     })
   }
+
+  configure (config) {
+    return super.configure({
+      ...config,
+      enabled: config.enabled && config.logInjection
+    })
+  }
 }

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

@@ -56,6 +56,14 @@ module.exports = class Plugin {
     this._subscriptions.push(new Subscription(channelName, handler))
   }
 
+  addError (error) {
+    const store = storage.getStore()
+
+    if (!store || !store.span) return
+
+    store.span.setTag('error', error)
+  }
+
   configure (config) {
     if (typeof config === 'boolean') {
       config = { enabled: config }

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

@@ -1,4 +1,7 @@
 const path = require('path')
+const fs = require('fs')
+
+const ignore = require('ignore')
 
 const { getGitMetadata } = require('./git')
 const { getUserProviderGitMetadata } = require('./user-provided-git')
@@ -16,6 +19,10 @@ const {
 } = require('./tags')
 const id = require('../../id')
 
+const { SPAN_TYPE, RESOURCE_NAME, SAMPLING_PRIORITY } = require('../../../../../ext/tags')
+const { SAMPLING_RULE_DECISION } = require('../../constants')
+const { AUTO_KEEP } = require('../../../../../ext/priority')
+
 const TEST_FRAMEWORK = 'test.framework'
 const TEST_FRAMEWORK_VERSION = 'test.framework_version'
 const TEST_TYPE = 'test.type'
@@ -25,6 +32,7 @@ const TEST_STATUS = 'test.status'
 const TEST_PARAMETERS = 'test.parameters'
 const TEST_SKIP_REASON = 'test.skip_reason'
 const TEST_IS_RUM_ACTIVE = 'test.is_rum_active'
+const TEST_CODE_OWNERS = 'test.codeowners'
 
 const ERROR_TYPE = 'error.type'
 const ERROR_MESSAGE = 'error.msg'
@@ -35,6 +43,7 @@ const CI_APP_ORIGIN = 'ciapp-test'
 const JEST_TEST_RUNNER = 'test.jest.test_runner'
 
 module.exports = {
+  TEST_CODE_OWNERS,
   TEST_FRAMEWORK,
   TEST_FRAMEWORK_VERSION,
   JEST_TEST_RUNNER,
@@ -53,7 +62,10 @@ module.exports = {
   getTestParametersString,
   finishAllTraceSpans,
   getTestParentSpan,
-  getTestSuitePath
+  getTestSuitePath,
+  getCodeOwnersFileEntries,
+  getCodeOwnersForFilename,
+  getTestCommonTags
 }
 
 function getTestEnvironmentMetadata (testFramework, config) {
@@ -127,6 +139,20 @@ function getTestParentSpan (tracer) {
     'x-datadog-parent-id': '0000000000000000'
   })
 }
+
+function getTestCommonTags (name, suite, version) {
+  return {
+    [SPAN_TYPE]: 'test',
+    [TEST_TYPE]: 'test',
+    [SAMPLING_RULE_DECISION]: 1,
+    [SAMPLING_PRIORITY]: AUTO_KEEP,
+    [TEST_NAME]: name,
+    [TEST_SUITE]: suite,
+    [RESOURCE_NAME]: `${suite}.${name}`,
+    [TEST_FRAMEWORK_VERSION]: version
+  }
+}
+
 /**
  * We want to make sure that test suites are reported the same way for
  * every OS, so we replace `path.sep` by `/`
@@ -140,3 +166,55 @@ function getTestSuitePath (testSuiteAbsolutePath, sourceRoot) {
 
   return testSuitePath.replace(path.sep, '/')
 }
+
+const POSSIBLE_CODEOWNERS_LOCATIONS = [
+  'CODEOWNERS',
+  '.github/CODEOWNERS',
+  'docs/CODEOWNERS',
+  '.gitlab/CODEOWNERS'
+]
+
+function getCodeOwnersFileEntries (rootDir = process.cwd()) {
+  let codeOwnersContent
+
+  POSSIBLE_CODEOWNERS_LOCATIONS.forEach(location => {
+    try {
+      codeOwnersContent = fs.readFileSync(`${rootDir}/${location}`).toString()
+    } catch (e) {
+      // retry with next path
+    }
+  })
+  if (!codeOwnersContent) {
+    return null
+  }
+
+  const entries = []
+  const lines = codeOwnersContent.split('\n')
+
+  for (const line of lines) {
+    const [content] = line.split('#')
+    const trimmed = content.trim()
+    if (trimmed === '') continue
+    const [pattern, ...owners] = trimmed.split(/\s+/)
+    entries.push({ pattern, owners })
+  }
+  // Reverse because rules defined last take precedence
+  return entries.reverse()
+}
+
+function getCodeOwnersForFilename (filename, entries) {
+  if (!entries) {
+    return null
+  }
+  for (const entry of entries) {
+    try {
+      const isResponsible = ignore().add(entry.pattern).ignores(filename)
+      if (isResponsible) {
+        return JSON.stringify(entry.owners)
+      }
+    } catch (e) {
+      return null
+    }
+  }
+  return null
+}

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

@@ -52,10 +52,38 @@ const web = {
     })
   },
 
-  startSpan (tracer, config, req, res, name) {
+  setFramework (req, name, config) {
     const context = this.patch(req)
+    const span = context.span
+
+    if (!span) return
+
+    span.context()._name = `${name}.request`
+
+    web.setConfig(req, config)
+  },
+
+  setConfig (req, config) {
+    const context = contexts.get(req)
+    const span = context.span
+
     context.config = config
 
+    if (!config.filter(req.url)) {
+      span.setTag(MANUAL_DROP, true)
+      span.context()._trace.isRecording = false
+    }
+
+    if (config.service) {
+      span.setTag(SERVICE_NAME, config.service)
+    }
+
+    analyticsSampler.sample(span, config.measured, true)
+  },
+
+  startSpan (tracer, config, req, res, name) {
+    const context = this.patch(req)
+
     let span
 
     if (context.span) {
@@ -69,6 +97,8 @@ const web = {
     context.span = span
     context.res = res
 
+    this.setConfig(req, config)
+
     return span
   },
   wrap (req) {
@@ -83,16 +113,6 @@ const web = {
   instrument (tracer, config, req, res, name, callback) {
     const span = this.startSpan(tracer, config, req, res, name)
 
-    if (!config.filter(req.url)) {
-      span.setTag(MANUAL_DROP, true)
-    }
-
-    if (config.service) {
-      span.setTag(SERVICE_NAME, config.service)
-    }
-
-    analyticsSampler.sample(span, config.measured, true)
-
     this.wrap(req)
 
     return callback && tracer.scope().activate(span, () => callback(span))
@@ -110,6 +130,14 @@ const web = {
     }
   },
 
+  setRoute (req, path) {
+    const context = contexts.get(req)
+
+    if (!context) return
+
+    context.paths = [path]
+  },
+
   // Remove the current route segment.
   exitRoute (req) {
     contexts.get(req).paths.pop()
@@ -231,8 +259,9 @@ const web = {
     const context = contexts.get(req)
     const span = context.span
     const error = context.error
+    const hasMiddlewareError = span.context()._tags['error'] || span.context()._tags['error.msg']
 
-    if (!context.config.validateStatus(statusCode)) {
+    if (!hasMiddlewareError && !context.config.validateStatus(statusCode)) {
       span.setTag(ERROR, error || true)
     }
   },

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

@@ -6,8 +6,8 @@ const { URL } = require('url')
 const { AgentExporter } = require('./exporters/agent')
 const { FileExporter } = require('./exporters/file')
 const { ConsoleLogger } = require('./loggers/console')
-const CpuProfiler = require('./profilers/cpu')
-const HeapProfiler = require('./profilers/heap')
+const WallProfiler = require('./profilers/wall')
+const SpaceProfiler = require('./profilers/space')
 const { tagger } = require('./tagger')
 
 const {
@@ -64,8 +64,8 @@ class Config {
     ], this)
 
     const profilers = coalesce(options.profilers, DD_PROFILING_PROFILERS, [
-      new CpuProfiler(),
-      new HeapProfiler()
+      new WallProfiler(),
+      new SpaceProfiler()
     ])
 
     this.profilers = ensureProfilers(profilers, this)
@@ -100,10 +100,10 @@ function ensureExporters (exporters, options) {
 
 function getProfiler (name, options) {
   switch (name) {
-    case 'cpu':
-      return new CpuProfiler(options)
-    case 'heap':
-      return new HeapProfiler(options)
+    case 'wall':
+      return new WallProfiler(options)
+    case 'space':
+      return new SpaceProfiler(options)
     default:
       options.logger.error(`Unknown profiler "${name}"`)
   }

package/packages/dd-trace/src/profiling/exporters/agent.js

@@ -5,7 +5,7 @@ const { request } = require('http')
 const FormData = require('form-data')
 
 // TODO: avoid using dd-trace internals. Make this a separate module?
-const docker = require('../../exporters/agent/docker')
+const docker = require('../../exporters/common/docker')
 const version = require('../../../lib/version')
 
 const containerId = docker.id()

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

@@ -1,8 +1,8 @@
 'use strict'
 
 const { Profiler } = require('./profiler')
-const CpuProfiler = require('./profilers/cpu')
-const HeapProfiler = require('./profilers/heap')
+const WallProfiler = require('./profilers/wall')
+const SpaceProfiler = require('./profilers/space')
 const { AgentExporter } = require('./exporters/agent')
 const { FileExporter } = require('./exporters/file')
 const { ConsoleLogger } = require('./loggers/console')
@@ -13,7 +13,7 @@ module.exports = {
   profiler,
   AgentExporter,
   FileExporter,
-  CpuProfiler,
-  HeapProfiler,
+  WallProfiler,
+  SpaceProfiler,
   ConsoleLogger
 }