dd-trace 5.2.0 → 5.3.0

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

@@ -27,7 +27,7 @@ const {
   TELEMETRY_EVENT_CREATED,
   TELEMETRY_ITR_SKIPPED
 } = require('../ci-visibility/telemetry')
-const { CI_PROVIDER_NAME, GIT_REPOSITORY_URL, GIT_COMMIT_SHA, GIT_BRANCH } = require('./util/tags')
+const { CI_PROVIDER_NAME, GIT_REPOSITORY_URL, GIT_COMMIT_SHA, GIT_BRANCH, CI_WORKSPACE_PATH } = require('./util/tags')
 const { OS_VERSION, OS_PLATFORM, OS_ARCHITECTURE, RUNTIME_NAME, RUNTIME_VERSION } = require('./util/env')
 
 module.exports = class CiPlugin extends Plugin {
@@ -36,17 +36,17 @@ module.exports = class CiPlugin extends Plugin {
 
     this.rootDir = process.cwd() // fallback in case :session:start events are not emitted
 
-    this.addSub(`ci:${this.constructor.id}:itr-configuration`, ({ onDone }) => {
-      if (!this.tracer._exporter || !this.tracer._exporter.getItrConfiguration) {
+    this.addSub(`ci:${this.constructor.id}:library-configuration`, ({ onDone }) => {
+      if (!this.tracer._exporter || !this.tracer._exporter.getLibraryConfiguration) {
         return onDone({ err: new Error('CI Visibility was not initialized correctly') })
       }
-      this.tracer._exporter.getItrConfiguration(this.testConfiguration, (err, itrConfig) => {
+      this.tracer._exporter.getLibraryConfiguration(this.testConfiguration, (err, libraryConfig) => {
         if (err) {
           log.error(`Intelligent Test Runner configuration could not be fetched. ${err.message}`)
         } else {
-          this.itrConfig = itrConfig
+          this.libraryConfig = libraryConfig
         }
-        onDone({ err, itrConfig })
+        onDone({ err, libraryConfig })
       })
     })
 
@@ -115,6 +115,18 @@ module.exports = class CiPlugin extends Plugin {
       })
       this.telemetry.count(TELEMETRY_ITR_SKIPPED, { testLevel: 'suite' }, skippedSuites.length)
     })
+
+    this.addSub(`ci:${this.constructor.id}:known-tests`, ({ onDone }) => {
+      if (!this.tracer._exporter?.getKnownTests) {
+        return onDone({ err: new Error('CI Visibility was not initialized correctly') })
+      }
+      this.tracer._exporter.getKnownTests(this.testConfiguration, (err, knownTests) => {
+        if (err) {
+          log.error(`Known tests could not be fetched. ${err.message}`)
+        }
+        onDone({ err, knownTests })
+      })
+    })
   }
 
   get telemetry () {
@@ -140,7 +152,6 @@ module.exports = class CiPlugin extends Plugin {
   configure (config) {
     super.configure(config)
     this.testEnvironmentMetadata = getTestEnvironmentMetadata(this.constructor.id, this.config)
-    this.codeOwnersEntries = getCodeOwnersFileEntries()
 
     const {
       [GIT_REPOSITORY_URL]: repositoryUrl,
@@ -151,9 +162,14 @@ module.exports = class CiPlugin extends Plugin {
       [RUNTIME_NAME]: runtimeName,
       [RUNTIME_VERSION]: runtimeVersion,
       [GIT_BRANCH]: branch,
-      [CI_PROVIDER_NAME]: ciProviderName
+      [CI_PROVIDER_NAME]: ciProviderName,
+      [CI_WORKSPACE_PATH]: repositoryRoot
     } = this.testEnvironmentMetadata
 
+    this.repositoryRoot = repositoryRoot || process.cwd()
+
+    this.codeOwnersEntries = getCodeOwnersFileEntries(repositoryRoot)
+
     this.isUnsupportedCIProvider = !ciProviderName
 
     this.testConfiguration = {

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

@@ -23,6 +23,7 @@ module.exports = {
   get 'aws-sdk' () { return require('../../../datadog-plugin-aws-sdk/src') },
   get 'bunyan' () { return require('../../../datadog-plugin-bunyan/src') },
   get 'cassandra-driver' () { return require('../../../datadog-plugin-cassandra-driver/src') },
+  get 'child_process' () { return require('../../../datadog-plugin-child_process/src') },
   get 'connect' () { return require('../../../datadog-plugin-connect/src') },
   get 'couchbase' () { return require('../../../datadog-plugin-couchbase/src') },
   get 'cypress' () { return require('../../../datadog-plugin-cypress/src') },

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

@@ -26,6 +26,7 @@ const {
   TELEMETRY_GIT_COMMAND_ERRORS
 } = require('../../ci-visibility/telemetry')
 const { filterSensitiveInfoFromRepository } = require('./url')
+const { storage } = require('../../../../datadog-core')
 
 const GIT_REV_LIST_MAX_BUFFER = 8 * 1024 * 1024 // 8MB
 
@@ -36,6 +37,9 @@ function sanitizedExec (
   durationMetric,
   errorMetric
 ) {
+  const store = storage.getStore()
+  storage.enterWith({ noop: true })
+
   let startTime
   if (operationMetric) {
     incrementCountMetric(operationMetric.name, operationMetric.tags)
@@ -55,6 +59,8 @@ function sanitizedExec (
     }
     log.error(e)
     return ''
+  } finally {
+    storage.enterWith(store)
   }
 }
 

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

@@ -48,6 +48,12 @@ const TEST_MODULE_ID = 'test_module_id'
 const TEST_SUITE_ID = 'test_suite_id'
 const TEST_TOOLCHAIN = 'test.toolchain'
 const TEST_SKIPPED_BY_ITR = 'test.skipped_by_itr'
+// Browser used in browser test. Namespaced by test.configuration because it affects the fingerprint
+const TEST_CONFIGURATION_BROWSER_NAME = 'test.configuration.browser_name'
+// Early flake detection
+const TEST_IS_NEW = 'test.is_new'
+const TEST_EARLY_FLAKE_IS_RETRY = 'test.early_flake.is_retry'
+const TEST_EARLY_FLAKE_IS_ENABLED = 'test.early_flake.is_enabled'
 
 const CI_APP_ORIGIN = 'ciapp-test'
 
@@ -87,6 +93,10 @@ module.exports = {
   JEST_WORKER_COVERAGE_PAYLOAD_CODE,
   TEST_SOURCE_START,
   TEST_SKIPPED_BY_ITR,
+  TEST_CONFIGURATION_BROWSER_NAME,
+  TEST_IS_NEW,
+  TEST_EARLY_FLAKE_IS_RETRY,
+  TEST_EARLY_FLAKE_IS_ENABLED,
   getTestEnvironmentMetadata,
   getTestParametersString,
   finishAllTraceSpans,
@@ -253,7 +263,6 @@ function getTestCommonTags (name, suite, version, testFramework) {
     [SAMPLING_PRIORITY]: AUTO_KEEP,
     [TEST_NAME]: name,
     [TEST_SUITE]: suite,
-    [TEST_SOURCE_FILE]: suite,
     [RESOURCE_NAME]: `${suite}.${name}`,
     [TEST_FRAMEWORK_VERSION]: version,
     [LIBRARY_VERSION]: ddTraceVersion
@@ -281,16 +290,36 @@ const POSSIBLE_CODEOWNERS_LOCATIONS = [
   '.gitlab/CODEOWNERS'
 ]
 
-function getCodeOwnersFileEntries (rootDir = process.cwd()) {
-  let codeOwnersContent
-
-  POSSIBLE_CODEOWNERS_LOCATIONS.forEach(location => {
+function readCodeOwners (rootDir) {
+  for (const location of POSSIBLE_CODEOWNERS_LOCATIONS) {
     try {
-      codeOwnersContent = fs.readFileSync(`${rootDir}/${location}`).toString()
+      return fs.readFileSync(path.join(rootDir, location)).toString()
     } catch (e) {
       // retry with next path
     }
-  })
+  }
+  return ''
+}
+
+function getCodeOwnersFileEntries (rootDir) {
+  let codeOwnersContent
+  let usedRootDir = rootDir
+  let isTriedCwd = false
+
+  const processCwd = process.cwd()
+
+  if (!usedRootDir || usedRootDir === processCwd) {
+    usedRootDir = processCwd
+    isTriedCwd = true
+  }
+
+  codeOwnersContent = readCodeOwners(usedRootDir)
+
+  // If we haven't found CODEOWNERS in the provided root dir, we try with process.cwd()
+  if (!codeOwnersContent && !isTriedCwd) {
+    codeOwnersContent = readCodeOwners(processCwd)
+  }
+
   if (!codeOwnersContent) {
     return null
   }

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

@@ -18,34 +18,34 @@ const { isFalse, isTrue } = require('../util')
 class Config {
   constructor (options = {}) {
     const {
-      DD_PROFILING_ENABLED,
-      DD_PROFILING_PROFILERS,
-      DD_ENV,
-      DD_TAGS,
-      DD_SERVICE,
-      DD_VERSION,
-      DD_TRACE_AGENT_URL,
       DD_AGENT_HOST,
-      DD_TRACE_AGENT_PORT,
+      DD_ENV,
+      DD_PROFILING_CODEHOTSPOTS_ENABLED,
       DD_PROFILING_DEBUG_SOURCE_MAPS,
-      DD_PROFILING_UPLOAD_TIMEOUT,
-      DD_PROFILING_SOURCE_MAP,
-      DD_PROFILING_UPLOAD_PERIOD,
-      DD_PROFILING_PPROF_PREFIX,
-      DD_PROFILING_HEAP_ENABLED,
-      DD_PROFILING_V8_PROFILER_BUG_WORKAROUND,
-      DD_PROFILING_WALLTIME_ENABLED,
+      DD_PROFILING_ENABLED,
+      DD_PROFILING_ENDPOINT_COLLECTION_ENABLED,
+      DD_PROFILING_EXPERIMENTAL_CODEHOTSPOTS_ENABLED,
       DD_PROFILING_EXPERIMENTAL_CPU_ENABLED,
-      DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED,
+      DD_PROFILING_EXPERIMENTAL_ENDPOINT_COLLECTION_ENABLED,
+      DD_PROFILING_EXPERIMENTAL_OOM_EXPORT_STRATEGIES,
       DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE,
       DD_PROFILING_EXPERIMENTAL_OOM_MAX_HEAP_EXTENSION_COUNT,
-      DD_PROFILING_EXPERIMENTAL_OOM_EXPORT_STRATEGIES,
-      DD_PROFILING_TIMELINE_ENABLED,
+      DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED,
       DD_PROFILING_EXPERIMENTAL_TIMELINE_ENABLED,
-      DD_PROFILING_CODEHOTSPOTS_ENABLED,
-      DD_PROFILING_ENDPOINT_COLLECTION_ENABLED,
-      DD_PROFILING_EXPERIMENTAL_CODEHOTSPOTS_ENABLED,
-      DD_PROFILING_EXPERIMENTAL_ENDPOINT_COLLECTION_ENABLED
+      DD_PROFILING_HEAP_ENABLED,
+      DD_PROFILING_PPROF_PREFIX,
+      DD_PROFILING_PROFILERS,
+      DD_PROFILING_SOURCE_MAP,
+      DD_PROFILING_TIMELINE_ENABLED,
+      DD_PROFILING_UPLOAD_PERIOD,
+      DD_PROFILING_UPLOAD_TIMEOUT,
+      DD_PROFILING_V8_PROFILER_BUG_WORKAROUND,
+      DD_PROFILING_WALLTIME_ENABLED,
+      DD_SERVICE,
+      DD_TAGS,
+      DD_TRACE_AGENT_PORT,
+      DD_TRACE_AGENT_URL,
+      DD_VERSION
     } = process.env
 
     const enabled = isTrue(coalesce(options.enabled, DD_PROFILING_ENABLED, true))

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

@@ -19,6 +19,7 @@ class Tracer extends NoopProxy {
     this._initialized = false
     this._pluginManager = new PluginManager(this)
     this.dogstatsd = new dogstatsd.NoopDogStatsDClient()
+    this._tracingInitialized = false
   }
 
   init (options) {
@@ -28,6 +29,7 @@ class Tracer extends NoopProxy {
 
     try {
       const config = new Config(options) // TODO: support dynamic code config
+      telemetry.start(config, this._pluginManager)
 
       if (config.dogstatsd) {
         // Custom Metrics
@@ -60,11 +62,7 @@ class Tracer extends NoopProxy {
           } else {
             config.configure(conf.lib_config, true)
           }
-
-          if (config.tracing) {
-            this._tracer.configure(config)
-            this._pluginManager.configure(config)
-          }
+          this._enableOrDisableTracing(config)
         })
       }
 
@@ -89,25 +87,9 @@ class Tracer extends NoopProxy {
         runtimeMetrics.start(config)
       }
 
-      if (config.tracing) {
-        // TODO: This should probably not require tracing to be enabled.
-        telemetry.start(config, this._pluginManager)
-
-        // dirty require for now so zero appsec code is executed unless explicitly enabled
-        if (config.appsec.enabled) {
-          require('./appsec').enable(config)
-        }
-
-        this._tracer = new DatadogTracer(config)
-        this.appsec = new AppsecSdk(this._tracer, config)
-
-        if (config.iast.enabled) {
-          require('./appsec/iast').enable(config, this._tracer)
-        }
-
-        this._pluginManager.configure(config)
-        setStartupLogPluginManager(this._pluginManager)
+      this._enableOrDisableTracing(config)
 
+      if (config.tracing) {
         if (config.isManualApiEnabled) {
           const TestApiManualPlugin = require('./ci-visibility/test-api-manual/test-api-manual-plugin')
           this._testApiManualPlugin = new TestApiManualPlugin(this)
@@ -121,6 +103,32 @@ class Tracer extends NoopProxy {
     return this
   }
 
+  _enableOrDisableTracing (config) {
+    if (config.tracing !== false) {
+      // dirty require for now so zero appsec code is executed unless explicitly enabled
+      if (config.appsec.enabled) {
+        require('./appsec').enable(config)
+      }
+      if (!this._tracingInitialized) {
+        this._tracer = new DatadogTracer(config)
+        this.appsec = new AppsecSdk(this._tracer, config)
+        this._tracingInitialized = true
+      }
+      if (config.iast.enabled) {
+        require('./appsec/iast').enable(config, this._tracer)
+      }
+    } else if (this._tracingInitialized) {
+      require('./appsec').disable()
+      require('./appsec/iast').disable()
+    }
+
+    if (this._tracingInitialized) {
+      this._tracer.configure(config)
+      this._pluginManager.configure(config)
+      setStartupLogPluginManager(this._pluginManager)
+    }
+  }
+
   profilerStarted () {
     if (!this._profilerStarted) {
       throw new Error('profilerStarted() must be called after init()')

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

@@ -27,10 +27,14 @@ class SpanProcessor {
     const active = []
     const formatted = []
     const trace = spanContext._trace
-    const { flushMinSpans } = this._config
+    const { flushMinSpans, tracing } = this._config
     const { started, finished } = trace
 
     if (trace.record === false) return
+    if (tracing === false) {
+      this._erase(trace, active)
+      return
+    }
     if (started.length === finished.length || finished.length >= flushMinSpans) {
       this._prioritySampler.sample(spanContext)
       this._spanSampler.sample(spanContext)

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

@@ -141,6 +141,9 @@ function appStarted (config) {
 }
 
 function appClosing () {
+  if (!config?.telemetry?.enabled) {
+    return
+  }
   const { reqType, payload } = createPayload('app-closing')
   sendData(config, application, host, reqType, payload)
   // we flush before shutting down. Only in CI Visibility

package/packages/datadog-instrumentations/src/child-process.js

@@ -1,29 +0,0 @@
-'use strict'
-
-const {
-  channel,
-  addHook
-} = require('./helpers/instrument')
-const shimmer = require('../../datadog-shimmer')
-
-const childProcessChannel = channel('datadog:child_process:execution:start')
-const execMethods = ['exec', 'execFile', 'fork', 'spawn', 'execFileSync', 'execSync', 'spawnSync']
-const names = ['child_process', 'node:child_process']
-
-addHook({ name: names }, childProcess => {
-  shimmer.massWrap(childProcess, execMethods, wrapChildProcessMethod())
-  return childProcess
-})
-
-function wrapChildProcessMethod () {
-  function wrapMethod (childProcessMethod) {
-    return function () {
-      if (childProcessChannel.hasSubscribers && arguments.length > 0) {
-        const command = arguments[0]
-        childProcessChannel.publish({ command })
-      }
-      return childProcessMethod.apply(this, arguments)
-    }
-  }
-  return wrapMethod
-}

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

@@ -1,34 +0,0 @@
-const cp = require('child_process')
-const log = require('../../log')
-const { distributionMetric, incrementCountMetric } = require('../../ci-visibility/telemetry')
-
-const sanitizedExec = (
-  cmd,
-  flags,
-  operationMetric,
-  durationMetric,
-  errorMetric
-) => {
-  let startTime
-  if (operationMetric) {
-    incrementCountMetric(operationMetric.name, operationMetric.tags)
-  }
-  if (durationMetric) {
-    startTime = Date.now()
-  }
-  try {
-    const result = cp.execFileSync(cmd, flags, { stdio: 'pipe' }).toString().replace(/(\r\n|\n|\r)/gm, '')
-    if (durationMetric) {
-      distributionMetric(durationMetric.name, durationMetric.tags, Date.now() - startTime)
-    }
-    return result
-  } catch (e) {
-    if (errorMetric) {
-      incrementCountMetric(errorMetric.name, { ...errorMetric.tags, exitCode: e.status })
-    }
-    log.error(e)
-    return ''
-  }
-}
-
-module.exports = { sanitizedExec }