dd-trace 3.7.1 → 3.9.0

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

@@ -0,0 +1,132 @@
+const { channel } = require('diagnostics_channel')
+
+const {
+  getTestEnvironmentMetadata,
+  getCodeOwnersFileEntries,
+  getTestParentSpan,
+  getTestCommonTags,
+  getCodeOwnersForFilename,
+  TEST_CODE_OWNERS,
+  CI_APP_ORIGIN
+} = require('./util/test')
+const { getItrConfiguration } = require('../ci-visibility/intelligent-test-runner/get-itr-configuration')
+const { getSkippableSuites } = require('../ci-visibility/intelligent-test-runner/get-skippable-suites')
+const { COMPONENT } = require('../constants')
+
+const Plugin = require('./plugin')
+
+module.exports = class CiPlugin extends Plugin {
+  constructor (...args) {
+    super(...args)
+
+    const gitMetadataUploadFinishCh = channel('ci:git-metadata-upload:finish')
+    // `gitMetadataPromise` is used to wait until git metadata is uploaded to
+    // proceed with calculating the suites to skip
+    // TODO: add timeout after which the promise is resolved
+    const gitMetadataPromise = new Promise(resolve => {
+      gitMetadataUploadFinishCh.subscribe(err => {
+        resolve(err)
+      })
+    })
+
+    this.codeOwnersEntries = getCodeOwnersFileEntries()
+
+    this.addSub(`ci:${this.constructor.name}:configuration`, ({ onDone }) => {
+      if (!this.config.isAgentlessEnabled || !this.config.isIntelligentTestRunnerEnabled) {
+        onDone({ config: {} })
+        return
+      }
+      getItrConfiguration(this.testConfiguration, (err, config) => {
+        if (err) {
+          onDone({ err })
+        } else {
+          this.itrConfig = config
+          onDone({ config })
+        }
+      })
+    })
+
+    this.addSub(`ci:${this.constructor.name}:test-suite:skippable`, ({ onDone }) => {
+      if (!this.config.isAgentlessEnabled || !this.config.isIntelligentTestRunnerEnabled) {
+        return onDone({ skippableSuites: [] })
+      }
+      // we only request after git upload has happened, if it didn't fail
+      gitMetadataPromise.then((gitUploadError) => {
+        if (gitUploadError) {
+          return onDone({ err: gitUploadError })
+        }
+        if (!this.itrConfig || !this.itrConfig.isSuitesSkippingEnabled) {
+          return onDone({ skippableSuites: [] })
+        }
+        getSkippableSuites(this.testConfiguration, (err, skippableSuites) => {
+          if (err) {
+            onDone({ err })
+          } else {
+            onDone({ skippableSuites })
+          }
+        })
+      })
+    })
+  }
+
+  configure (config) {
+    super.configure(config)
+    this.testEnvironmentMetadata = getTestEnvironmentMetadata(this.constructor.name, this.config)
+
+    const {
+      'git.repository_url': repositoryUrl,
+      'git.commit.sha': sha,
+      'os.version': osVersion,
+      'os.platform': osPlatform,
+      'os.architecture': osArchitecture,
+      'runtime.name': runtimeName,
+      'runtime.version': runtimeVersion,
+      'git.branch': branch
+    } = this.testEnvironmentMetadata
+
+    this.testConfiguration = {
+      repositoryUrl,
+      sha,
+      osVersion,
+      osPlatform,
+      osArchitecture,
+      runtimeName,
+      runtimeVersion,
+      branch,
+      url: this.config.url,
+      site: this.config.site,
+      env: this.tracer._env,
+      service: this.config.service || this.tracer._service
+    }
+  }
+
+  startTestSpan (name, suite, extraTags, childOf) {
+    const parent = childOf || getTestParentSpan(this.tracer)
+    const testCommonTags = getTestCommonTags(name, suite, this.tracer._version)
+
+    const testTags = {
+      ...testCommonTags,
+      [COMPONENT]: this.constructor.name,
+      ...extraTags
+    }
+
+    const codeOwners = getCodeOwnersForFilename(suite, this.codeOwnersEntries)
+
+    if (codeOwners) {
+      testTags[TEST_CODE_OWNERS] = codeOwners
+    }
+
+    const testSpan = this.tracer
+      .startSpan(`${this.constructor.name}.test`, {
+        childOf: parent,
+        tags: {
+          ...this.testEnvironmentMetadata,
+          ...testTags
+        }
+      })
+
+    testSpan.context()._trace.origin = CI_APP_ORIGIN
+
+    return testSpan
+  }
+}

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

@@ -4,6 +4,52 @@ const StoragePlugin = require('./storage')
 
 class DatabasePlugin extends StoragePlugin {
   static get operation () { return 'query' }
+
+  constructor (...args) {
+    super(...args)
+    this.serviceTags = {
+      dddbs: '',
+      encodedDddbs: '',
+      dde: '',
+      encodedDde: '',
+      ddps: '',
+      encodedDdps: '',
+      ddpv: '',
+      encodedDdpv: ''
+    }
+  }
+  encodingServiceTags (serviceTag, encodeATag, spanConfig) {
+    if (serviceTag !== spanConfig) {
+      this.serviceTags[serviceTag] = spanConfig
+      this.serviceTags[encodeATag] = encodeURIComponent(spanConfig)
+    }
+  }
+
+  createDBMPropagationCommentService () {
+    this.encodingServiceTags('dddbs', 'encodedDddbs', this.config.service)
+    this.encodingServiceTags('dde', 'encodedDde', this.tracer._env)
+    this.encodingServiceTags('ddps', 'encodedDdps', this.tracer._service)
+    this.encodingServiceTags('ddpv', 'encodedDdpv', this.tracer._version)
+
+    const { encodedDddbs, encodedDde, encodedDdps, encodedDdpv } = this.serviceTags
+
+    return `dddbs='${encodedDddbs}',dde='${encodedDde}',` +
+    `ddps='${encodedDdps}',ddpv='${encodedDdpv}'`
+  }
+
+  injectDbmQuery (query) {
+    if (this.config.dbmPropagationMode === 'disabled') {
+      return query
+    }
+    const servicePropagation = this.createDBMPropagationCommentService()
+    if (this.config.dbmPropagationMode === 'service') {
+      return `/*${servicePropagation}*/ ${query}`
+    } else if (this.config.dbmPropagationMode === 'full') {
+      this.activeSpan.setTag('_dd.dbm_trace_injected', 'true')
+      const traceparent = this.activeSpan._spanContext.toTraceparent()
+      return `/*${servicePropagation},traceparent='${traceparent}'*/ ${query}`
+    }
+  }
 }
 
 module.exports = DatabasePlugin

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

@@ -3,6 +3,7 @@
 const Plugin = require('./plugin')
 const { storage } = require('../../../datadog-core')
 const analyticsSampler = require('../analytics_sampler')
+const { COMPONENT } = require('../constants')
 
 class TracingPlugin extends Plugin {
   constructor (...args) {
@@ -72,6 +73,7 @@ class TracingPlugin extends Plugin {
     const span = this.tracer.startSpan(name, {
       childOf,
       tags: {
+        [COMPONENT]: this.component,
         'service.name': service || this.tracer._service,
         'resource.name': resource,
         'span.kind': kind,

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

@@ -1,6 +1,7 @@
 const path = require('path')
 const fs = require('fs')
 
+const istanbul = require('istanbul-lib-coverage')
 const ignore = require('ignore')
 
 const { getGitMetadata } = require('./git')
@@ -40,10 +41,6 @@ const TEST_COMMAND = 'test.command'
 const TEST_SESSION_ID = 'test_session_id'
 const TEST_SUITE_ID = 'test_suite_id'
 
-const ERROR_TYPE = 'error.type'
-const ERROR_MESSAGE = 'error.msg'
-const ERROR_STACK = 'error.stack'
-
 const CI_APP_ORIGIN = 'ciapp-test'
 
 const JEST_TEST_RUNNER = 'test.jest.test_runner'
@@ -65,9 +62,6 @@ module.exports = {
   TEST_SKIP_REASON,
   TEST_IS_RUM_ACTIVE,
   TEST_SOURCE_FILE,
-  ERROR_TYPE,
-  ERROR_MESSAGE,
-  ERROR_STACK,
   CI_APP_ORIGIN,
   LIBRARY_VERSION,
   getTestEnvironmentMetadata,
@@ -84,7 +78,11 @@ module.exports = {
   TEST_SESSION_ID,
   TEST_SUITE_ID,
   TEST_ITR_TESTS_SKIPPED,
-  TEST_CODE_COVERAGE_LINES_TOTAL
+  TEST_CODE_COVERAGE_LINES_TOTAL,
+  getCoveredFilenamesFromCoverage,
+  resetCoverage,
+  mergeCoverage,
+  fromCoverageMapToCoverage
 }
 
 function getTestEnvironmentMetadata (testFramework, config) {
@@ -262,3 +260,58 @@ function getTestSuiteCommonTags (command, version, testSuite) {
     [TEST_COMMAND]: command
   }
 }
+
+function getCoveredFilenamesFromCoverage (coverage) {
+  const coverageMap = istanbul.createCoverageMap(coverage)
+
+  return coverageMap
+    .files()
+    .filter(filename => {
+      const fileCoverage = coverageMap.fileCoverageFor(filename)
+      const lineCoverage = fileCoverage.getLineCoverage()
+      const isAnyLineExecuted = Object.entries(lineCoverage).some(([, numExecutions]) => !!numExecutions)
+
+      return isAnyLineExecuted
+    })
+}
+
+function resetCoverage (coverage) {
+  const coverageMap = istanbul.createCoverageMap(coverage)
+
+  return coverageMap
+    .files()
+    .forEach(filename => {
+      const fileCoverage = coverageMap.fileCoverageFor(filename)
+      fileCoverage.resetHits()
+    })
+}
+
+function mergeCoverage (coverage, targetCoverage) {
+  const coverageMap = istanbul.createCoverageMap(coverage)
+  return coverageMap
+    .files()
+    .forEach(filename => {
+      const fileCoverage = coverageMap.fileCoverageFor(filename)
+
+      // If the fileCoverage is not there for this filename,
+      // we create it to force a merge between the fileCoverages
+      // instead of a reference assignment (which would not work if the coverage is reset later on)
+      if (!targetCoverage.data[filename]) {
+        targetCoverage.addFileCoverage(istanbul.createFileCoverage(filename))
+      }
+      targetCoverage.addFileCoverage(fileCoverage)
+      const targetFileCoverage = targetCoverage.fileCoverageFor(filename)
+
+      // branches (.b) are copied by reference, so `resetHits` affects the copy, so we need to copy it manually
+      Object.entries(targetFileCoverage.data.b).forEach(([key, value]) => {
+        targetFileCoverage.data.b[key] = [...value]
+      })
+    })
+}
+
+function fromCoverageMapToCoverage (coverageMap) {
+  return Object.entries(coverageMap.data).reduce((acc, [filename, fileCoverage]) => {
+    acc[filename] = fileCoverage.data
+    return acc
+  }, {})
+}

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

@@ -11,6 +11,7 @@ const kinds = require('../../../../../ext/kinds')
 const urlFilter = require('./urlfilter')
 const BlockList = require('./ip_blocklist')
 const { incomingHttpRequestEnd } = require('../../appsec/gateway/channels')
+const { ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK } = require('../../constants')
 
 const WEB = types.WEB
 const SERVER = kinds.SERVER
@@ -51,8 +52,6 @@ const ends = new WeakMap()
 const web = {
   // Ensure the configuration has the correct structure and defaults.
   normalizeConfig (config) {
-    config = config.server || config
-
     const headers = getHeadersToRecord(config)
     const validateStatus = getStatusValidator(config)
     const hooks = getHooks(config)
@@ -60,14 +59,15 @@ const web = {
     const middleware = getMiddlewareSetting(config)
     const queryStringObfuscation = getQsObfuscator(config)
 
-    return Object.assign({}, config, {
+    return {
+      ...config,
       headers,
       validateStatus,
       hooks,
       filter,
       middleware,
       queryStringObfuscation
-    })
+    }
   },
 
   setFramework (req, name, config) {
@@ -77,6 +77,7 @@ const web = {
     if (!span) return
 
     span.context()._name = `${name}.request`
+    span.context()._tags['component'] = name
 
     web.setConfig(req, config)
   },
@@ -204,9 +205,9 @@ const web = {
     if (span) {
       if (error) {
         span.addTags({
-          'error.type': error.name,
-          'error.msg': error.message,
-          'error.stack': error.stack
+          [ERROR_TYPE]: error.name,
+          [ERROR_MESSAGE]: error.message,
+          [ERROR_STACK]: error.stack
         })
       }
 
@@ -276,7 +277,7 @@ const web = {
     const context = contexts.get(req)
     const span = context.span
     const error = context.error
-    const hasExistingError = span.context()._tags['error'] || span.context()._tags['error.msg']
+    const hasExistingError = span.context()._tags['error'] || span.context()._tags[ERROR_MESSAGE]
 
     if (!hasExistingError && !context.config.validateStatus(statusCode)) {
       span.setTag(ERROR, error || true)

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

@@ -10,6 +10,7 @@ const { setStartupLogPluginManager } = require('./startup-log')
 const telemetry = require('./telemetry')
 const PluginManager = require('./plugin_manager')
 const { sendGitMetadata } = require('./ci-visibility/exporters/git/git_metadata')
+const remoteConfig = require('./appsec/remote_config')
 
 const gitMetadataUploadFinishCh = channel('ci:git-metadata-upload:finish')
 
@@ -29,8 +30,7 @@ class Tracer extends NoopProxy {
     try {
       const config = new Config(options) // TODO: support dynamic config
 
-      log.use(config.logger)
-      log.toggle(config.debug, config.logLevel, this)
+      remoteConfig.enable(config)
 
       if (config.profiling.enabled) {
         // do not stop tracer initialization if the profiler fails to be imported
@@ -51,6 +51,7 @@ class Tracer extends NoopProxy {
         if (config.appsec.enabled) {
           require('./appsec').enable(config)
         }
+
         if (config.iast.enabled) {
           require('./appsec/iast').enable(config)
         }
@@ -64,7 +65,7 @@ class Tracer extends NoopProxy {
       if (config.isGitUploadEnabled) {
         sendGitMetadata(config.site, (err) => {
           if (err) {
-            log.error(`Error uploading git metadata: ${err}`)
+            log.error(`Error uploading git metadata: ${err.message}`)
           } else {
             log.debug('Successfully uploaded git metadata')
           }

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

@@ -27,6 +27,7 @@ class SpanProcessor {
     const { flushMinSpans } = this._config
     const { started, finished } = trace
 
+    if (trace.record === false) return
     if (started.length === finished.length || finished.length >= flushMinSpans) {
       this._prioritySampler.sample(spanContext)
       this._spanSampler.sample(spanContext)

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

@@ -6,6 +6,7 @@ const Scope = require('./scope')
 const { storage } = require('../../datadog-core')
 const { isError } = require('./util')
 const { setStartupLogConfig } = require('./startup-log')
+const { ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK } = require('../../dd-trace/src/constants')
 
 const SPAN_TYPE = tags.SPAN_TYPE
 const RESOURCE_NAME = tags.RESOURCE_NAME
@@ -143,9 +144,9 @@ class DatadogTracer extends Tracer {
 function addError (span, error) {
   if (isError(error)) {
     span.addTags({
-      'error.type': error.name,
-      'error.msg': error.message,
-      'error.stack': error.stack
+      [ERROR_TYPE]: error.name,
+      [ERROR_MESSAGE]: error.message,
+      [ERROR_STACK]: error.stack
     })
   }
 }