dd-trace 2.4.2 → 2.6.0

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

@@ -69,6 +69,17 @@ const web = {
     context.span = span
     context.res = res
 
+    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)
+
     return span
   },
   wrap (req) {
@@ -83,16 +94,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))

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/profilers/cpu.js

@@ -3,7 +3,7 @@
 class NativeCpuProfiler {
   constructor (options = {}) {
     this.type = 'wall'
-    this._samplingInterval = options.samplingInterval || 10 * 1000
+    this._samplingInterval = options.samplingInterval || 1e6 / 99 // 99hz
     this._mapper = undefined
     this._pprof = undefined
   }

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

@@ -10,6 +10,7 @@ const metrics = require('./metrics')
 const log = require('./log')
 const { isFalse } = require('./util')
 const { setStartupLogInstrumenter } = require('./startup-log')
+const telemetry = require('./telemetry')
 
 const noop = new NoopTracer()
 
@@ -63,6 +64,7 @@ class Tracer extends BaseTracer {
         this._instrumenter.enable(config)
         this._pluginManager.configure(config)
         setStartupLogInstrumenter(this._instrumenter)
+        telemetry.start(config, this._instrumenter, this._pluginManager)
       }
     } catch (e) {
       log.error(e)

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

@@ -32,7 +32,10 @@ class SpanProcessor {
         }
       }
 
-      this._exporter.export(formatted)
+      if (formatted.length !== 0 && trace.isRecording !== false) {
+        this._exporter.export(formatted)
+      }
+
       this._erase(trace, active)
     }
   }

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

@@ -0,0 +1,187 @@
+'use strict'
+
+const tracerVersion = require('../lib/version')
+const pkg = require('./pkg')
+const containerId = require('./exporters/common/docker').id()
+const requirePackageJson = require('./require-package-json')
+const path = require('path')
+const os = require('os')
+const request = require('./exporters/common/request')
+
+let config
+let instrumenter
+let pluginManager
+
+let seqId = 0
+let application
+let host
+let interval
+const sentIntegrations = new Set()
+
+function getIntegrations () {
+  const newIntegrations = []
+  for (const plugin of instrumenter._instrumented.keys()) {
+    if (sentIntegrations.has(plugin.name)) {
+      continue
+    }
+    newIntegrations.push({
+      name: plugin.name,
+      enabled: true,
+      auto_enabled: true
+    })
+    sentIntegrations.add(plugin.name)
+  }
+  for (const pluginName in pluginManager._pluginsByName) {
+    if (sentIntegrations.has(pluginName)) {
+      continue
+    }
+    newIntegrations.push({
+      name: pluginName,
+      enabled: pluginManager._pluginsByName[pluginName]._enabled,
+      auto_enabled: true
+    })
+    sentIntegrations.add(pluginName)
+  }
+  return newIntegrations
+}
+
+function getDependencies () {
+  const deps = []
+  const { dependencies } = pkg
+  if (!dependencies) {
+    return deps
+  }
+  const rootDir = pkg.findRoot()
+  for (const [name, version] of Object.entries(dependencies)) {
+    const dep = { name }
+    try {
+      dep.version = requirePackageJson(
+        path.join(rootDir, 'node_modules', name.replace('/', path.sep))
+      ).version
+    } catch (e) {
+      dep.version = version
+    }
+    deps.push(dep)
+  }
+  return deps
+}
+
+function flatten (input, result = [], prefix = [], traversedObjects = null) {
+  traversedObjects = traversedObjects || new WeakSet()
+  if (traversedObjects.has(input)) {
+    return
+  }
+  traversedObjects.add(input)
+  for (const [key, value] of Object.entries(input)) {
+    if (typeof value === 'object' && value !== null) {
+      flatten(value, result, [...prefix, key], traversedObjects)
+    } else {
+      result.push({ name: [...prefix, key].join('.'), value })
+    }
+  }
+  return result
+}
+
+function appStarted () {
+  return {
+    integrations: getIntegrations(),
+    dependencies: getDependencies(),
+    configuration: flatten(config),
+    additional_payload: []
+  }
+}
+
+function onBeforeExit () {
+  process.removeListener('beforeExit', onBeforeExit)
+  sendData('app-closing')
+}
+
+function createAppObject () {
+  return {
+    service_name: config.service,
+    env: config.env,
+    service_version: config.version,
+    tracer_version: tracerVersion,
+    language_name: 'nodejs',
+    language_version: process.versions.node
+  }
+}
+
+function createHostObject () {
+  return {
+    hostname: os.hostname(), // TODO is this enough?
+    container_id: containerId
+  }
+}
+
+function sendData (reqType, payload = {}) {
+  const {
+    hostname,
+    port
+  } = config
+  const options = {
+    hostname,
+    port,
+    method: 'POST',
+    path: '/telemetry/proxy/api/v2/apmtelemetry',
+    headers: {
+      'content-type': 'application/json',
+      'dd-telemetry-api-version': 'v1',
+      'dd-telemetry-request-type': reqType
+    }
+  }
+  const data = JSON.stringify({
+    api_version: 'v1',
+    request_type: reqType,
+    tracer_time: Math.floor(Date.now() / 1000),
+    runtime_id: config.tags['runtime-id'],
+    seq_id: ++seqId,
+    payload,
+    application,
+    host
+  })
+
+  request(data, options, true, () => {
+    // ignore errors
+  })
+}
+
+function start (aConfig, theInstrumenter, thePluginManager) {
+  if (!aConfig.telemetryEnabled) {
+    return
+  }
+  config = aConfig
+  instrumenter = theInstrumenter
+  pluginManager = thePluginManager
+  application = createAppObject()
+  host = createHostObject()
+  sendData('app-started', appStarted())
+  interval = setInterval(() => sendData('app-heartbeat'), 60000)
+  interval.unref()
+  process.on('beforeExit', onBeforeExit)
+}
+
+function stop () {
+  if (!config) {
+    return
+  }
+  clearInterval(interval)
+  process.removeListener('beforeExit', onBeforeExit)
+}
+
+function updateIntegrations () {
+  if (!config || !config.telemetryEnabled) {
+    return
+  }
+  const integrations = getIntegrations()
+  if (integrations.length === 0) {
+    return
+  }
+  sendData('app-integrations-change', { integrations })
+}
+
+module.exports = {
+  start,
+  stop,
+  updateIntegrations
+}

package/scripts/install_plugin_modules.js

@@ -186,6 +186,7 @@ const requirePackageJson = require('${requirePackageJsonPath}')
 
 module.exports = {
   get (id) { return require(id || '${name}') },
+  getPath (id) { return require.resolve(id || '${name}' ) },
   version () { return requirePackageJson('${name}', module).version }
 }
 `

package/packages/datadog-plugin-jest/src/jest-environment.js

@@ -1,272 +0,0 @@
-const { promisify } = require('util')
-
-const { RESOURCE_NAME } = require('../../../ext/tags')
-const {
-  TEST_NAME,
-  TEST_SUITE,
-  TEST_STATUS,
-  TEST_FRAMEWORK_VERSION,
-  JEST_TEST_RUNNER,
-  ERROR_MESSAGE,
-  ERROR_TYPE,
-  TEST_PARAMETERS,
-  CI_APP_ORIGIN,
-  getTestEnvironmentMetadata,
-  getTestParametersString,
-  finishAllTraceSpans,
-  getTestSuitePath
-} = require('../../dd-trace/src/plugins/util/test')
-const {
-  getFormattedJestTestParameters,
-  getTestSpanTags,
-  setSuppressedErrors
-} = require('./util')
-
-const originals = new WeakMap()
-
-function getVmContext (environment) {
-  if (typeof environment.getVmContext === 'function') {
-    return environment.getVmContext()
-  }
-  return null
-}
-
-function wrapEnvironment (BaseEnvironment) {
-  return class DatadogJestEnvironment extends BaseEnvironment {
-    constructor (config, context) {
-      super(config, context)
-      this.testSuite = getTestSuitePath(context.testPath, config.rootDir)
-      this.testSpansByTestName = {}
-      this.originalTestFnByTestName = {}
-    }
-  }
-}
-
-function createWrapTeardown (tracer, instrumenter) {
-  return function wrapTeardown (teardown) {
-    return async function teardownWithTrace () {
-      instrumenter.unwrap(this.global.test, 'each')
-      nameToParams = {}
-      // for jest-jasmine2
-      if (this.global.jasmine) {
-        instrumenter.unwrap(this.global.jasmine.Spec.prototype, 'onException')
-        instrumenter.unwrap(this.global, 'it')
-        instrumenter.unwrap(this.global, 'fit')
-        instrumenter.unwrap(this.global, 'xit')
-      }
-
-      instrumenter.unwrap(this.global.test, 'each')
-
-      return teardown.apply(this, arguments).finally(() => {
-        return new Promise(resolve => tracer._exporter._writer.flush(resolve))
-      })
-    }
-  }
-}
-
-let nameToParams = {}
-
-const isTimeout = (event) => {
-  return event.error &&
-  typeof event.error === 'string' &&
-  event.error.startsWith('Exceeded timeout')
-}
-
-function createHandleTestEvent (tracer, testEnvironmentMetadata, instrumenter) {
-  return async function handleTestEventWithTrace (event) {
-    if (event.name === 'test_retry') {
-      let testName = event.test && event.test.name
-      const context = getVmContext(this)
-      if (context) {
-        const { currentTestName } = context.expect.getState()
-        testName = currentTestName
-      }
-      // If it's a retry, we restore the original test function so that it is not wrapped again
-      if (this.originalTestFnByTestName[testName]) {
-        event.test.fn = this.originalTestFnByTestName[testName]
-      }
-      return
-    }
-    if (event.name === 'test_fn_failure') {
-      if (!isTimeout(event)) {
-        return
-      }
-      const context = getVmContext(this)
-      if (context) {
-        const { currentTestName } = context.expect.getState()
-        const testSpan = this.testSpansByTestName[`${currentTestName}_${event.test.invocations}`]
-        if (testSpan) {
-          testSpan.setTag(ERROR_TYPE, 'Timeout')
-          testSpan.setTag(ERROR_MESSAGE, event.error)
-          testSpan.setTag(TEST_STATUS, 'fail')
-        }
-      }
-      return
-    }
-    if (event.name === 'setup') {
-      instrumenter.wrap(this.global.test, 'each', function (original) {
-        return function () {
-          const testParameters = getFormattedJestTestParameters(arguments)
-          const eachBind = original.apply(this, arguments)
-          return function () {
-            const [testName] = arguments
-            nameToParams[testName] = testParameters
-            return eachBind.apply(this, arguments)
-          }
-        }
-      })
-      return
-    }
-
-    if (event.name !== 'test_skip' &&
-      event.name !== 'test_todo' &&
-      event.name !== 'test_start' &&
-      event.name !== 'hook_failure') {
-      return
-    }
-    // for hook_failure events the test entry might not be defined, because the hook
-    // is not necessarily associated to a test:
-    if (!event.test) {
-      return
-    }
-
-    const { childOf, commonSpanTags } = getTestSpanTags(tracer, testEnvironmentMetadata)
-
-    let testName = event.test.name
-    const context = getVmContext(this)
-
-    if (context) {
-      const { currentTestName } = context.expect.getState()
-      testName = currentTestName
-    }
-    const spanTags = {
-      ...commonSpanTags,
-      [TEST_NAME]: testName,
-      [TEST_SUITE]: this.testSuite,
-      [TEST_FRAMEWORK_VERSION]: tracer._version,
-      [JEST_TEST_RUNNER]: 'jest-circus'
-    }
-
-    const testParametersString = getTestParametersString(nameToParams, event.test.name)
-    if (testParametersString) {
-      spanTags[TEST_PARAMETERS] = testParametersString
-    }
-
-    const resource = `${this.testSuite}.${testName}`
-    if (event.name === 'test_skip' || event.name === 'test_todo') {
-      const testSpan = tracer.startSpan(
-        'jest.test',
-        {
-          childOf,
-          tags: {
-            ...spanTags,
-            [RESOURCE_NAME]: resource,
-            [TEST_STATUS]: 'skip'
-          }
-        }
-      )
-      testSpan.context()._trace.origin = CI_APP_ORIGIN
-      testSpan.finish()
-      return
-    }
-    if (event.name === 'hook_failure') {
-      const testSpan = tracer.startSpan(
-        'jest.test',
-        {
-          childOf,
-          tags: {
-            ...spanTags,
-            [RESOURCE_NAME]: resource,
-            [TEST_STATUS]: 'fail'
-          }
-        }
-      )
-      testSpan.context()._trace.origin = CI_APP_ORIGIN
-      if (event.test.errors && event.test.errors.length) {
-        const error = new Error(event.test.errors[0][0])
-        error.stack = event.test.errors[0][1].stack
-        testSpan.setTag('error', error)
-      }
-      testSpan.finish()
-      return
-    }
-    // event.name === test_start at this point
-    const environment = this
-    environment.originalTestFnByTestName[testName] = event.test.fn
-
-    let specFunction = event.test.fn
-    if (specFunction.length) {
-      specFunction = promisify(specFunction)
-    }
-    event.test.fn = tracer.wrap(
-      'jest.test',
-      {
-        type: 'test',
-        childOf,
-        resource,
-        tags: spanTags
-      },
-      async () => {
-        let result
-        const testSpan = tracer.scope().active()
-        environment.testSpansByTestName[`${testName}_${event.test.invocations}`] = testSpan
-        testSpan.context()._trace.origin = CI_APP_ORIGIN
-        try {
-          result = await specFunction()
-          // it may have been set already if the test timed out
-          let suppressedErrors = []
-          const context = getVmContext(environment)
-          if (context) {
-            suppressedErrors = context.expect.getState().suppressedErrors
-          }
-          setSuppressedErrors(suppressedErrors, testSpan)
-          if (!testSpan._spanContext._tags[TEST_STATUS]) {
-            testSpan.setTag(TEST_STATUS, 'pass')
-          }
-        } catch (error) {
-          testSpan.setTag(TEST_STATUS, 'fail')
-          testSpan.setTag('error', error)
-          throw error
-        } finally {
-          finishAllTraceSpans(testSpan)
-        }
-        return result
-      }
-    )
-  }
-}
-
-function patch (Environment, tracer, config) {
-  const testEnvironmentMetadata = getTestEnvironmentMetadata('jest', config)
-  const proto = Environment.prototype
-
-  this.wrap(proto, 'teardown', createWrapTeardown(tracer, this))
-
-  const newHandleTestEvent = createHandleTestEvent(tracer, testEnvironmentMetadata, this)
-  originals.set(newHandleTestEvent, proto.handleTestEvent)
-  proto.handleTestEvent = newHandleTestEvent
-
-  return wrapEnvironment(Environment)
-}
-
-function unpatch (Environment) {
-  const proto = Environment.prototype
-
-  this.unwrap(Environment.prototype, 'teardown')
-  proto.handleTestEvent = originals.get(proto.handleTestEvent)
-}
-
-module.exports = [
-  {
-    name: 'jest-environment-node',
-    versions: ['>=24.8.0'],
-    patch,
-    unpatch
-  },
-  {
-    name: 'jest-environment-jsdom',
-    versions: ['>=24.8.0'],
-    patch,
-    unpatch
-  }
-]