dd-trace 4.18.0 → 5.6.0

package/packages/datadog-plugin-child_process/src/scrub-cmd-params.js

@@ -0,0 +1,125 @@
+'use strict'
+
+const shellParser = require('shell-quote/parse')
+
+const ALLOWED_ENV_VARIABLES = ['LD_PRELOAD', 'LD_LIBRARY_PATH', 'PATH']
+const PROCESS_DENYLIST = ['md5']
+
+const VARNAMES_REGEX = /\$([\w\d_]*)(?:[^\w\d_]|$)/gmi
+// eslint-disable-next-line max-len
+const PARAM_PATTERN = '^-{0,2}(?:p(?:ass(?:w(?:or)?d)?)?|api_?key|secret|a(?:ccess|uth)_token|mysql_pwd|credentials|(?:stripe)?token)$'
+const regexParam = new RegExp(PARAM_PATTERN, 'i')
+const ENV_PATTERN = '^(\\w+=\\w+;)*\\w+=\\w+;?$'
+const envvarRegex = new RegExp(ENV_PATTERN)
+const REDACTED = '?'
+
+function extractVarNames (expression) {
+  const varNames = new Set()
+  let match
+
+  while ((match = VARNAMES_REGEX.exec(expression))) {
+    varNames.add(match[1])
+  }
+
+  const varNamesObject = {}
+  for (const varName of varNames.keys()) {
+    varNamesObject[varName] = `$${varName}`
+  }
+  return varNamesObject
+}
+
+function getTokensByExpression (expressionTokens) {
+  const expressionListTokens = []
+  let wipExpressionTokens = []
+  let isNewExpression = true
+
+  expressionTokens.forEach(token => {
+    if (isNewExpression) {
+      expressionListTokens.push(wipExpressionTokens)
+      isNewExpression = false
+    }
+
+    wipExpressionTokens.push(token)
+
+    if (token.op) {
+      wipExpressionTokens = []
+      isNewExpression = true
+    }
+  })
+  return expressionListTokens
+}
+
+function scrubChildProcessCmd (expression) {
+  const varNames = extractVarNames(expression)
+  const expressionTokens = shellParser(expression, varNames)
+
+  const expressionListTokens = getTokensByExpression(expressionTokens)
+
+  const result = []
+  expressionListTokens.forEach((expressionTokens) => {
+    let foundBinary = false
+    for (let index = 0; index < expressionTokens.length; index++) {
+      const token = expressionTokens[index]
+
+      if (typeof token === 'object') {
+        if (token.pattern) {
+          result.push(token.pattern)
+        } else if (token.op) {
+          result.push(token.op)
+        } else if (token.comment) {
+          result.push(`#${token.comment}`)
+        }
+      } else if (!foundBinary) {
+        if (envvarRegex.test(token)) {
+          const envSplit = token.split('=')
+
+          if (!ALLOWED_ENV_VARIABLES.includes(envSplit[0])) {
+            envSplit[1] = REDACTED
+
+            const newToken = envSplit.join('=')
+            expressionTokens[index] = newToken
+
+            result.push(newToken)
+          } else {
+            result.push(token)
+          }
+        } else {
+          foundBinary = true
+          result.push(token)
+
+          if (PROCESS_DENYLIST.includes(token)) {
+            for (index++; index < expressionTokens.length; index++) {
+              const token = expressionTokens[index]
+
+              if (token.op) {
+                result.push(token.op)
+              } else {
+                expressionTokens[index] = REDACTED
+                result.push(REDACTED)
+              }
+            }
+            break
+          }
+        }
+      } else {
+        const paramKeyValue = token.split('=')
+        const paramKey = paramKeyValue[0]
+
+        if (regexParam.test(paramKey)) {
+          if (paramKeyValue.length === 1) {
+            expressionTokens[index + 1] = REDACTED
+            result.push(token)
+          } else {
+            result.push(`${paramKey}=${REDACTED}`)
+          }
+        } else {
+          result.push(token)
+        }
+      }
+    }
+  })
+
+  return result
+}
+
+module.exports = scrubChildProcessCmd

package/packages/datadog-plugin-cucumber/src/index.js

@@ -12,10 +12,26 @@ const {
   getTestSuiteCommonTags,
   addIntelligentTestRunnerSpanTags,
   TEST_ITR_UNSKIPPABLE,
-  TEST_ITR_FORCED_RUN
+  TEST_ITR_FORCED_RUN,
+  TEST_CODE_OWNERS,
+  ITR_CORRELATION_ID,
+  TEST_SOURCE_FILE,
+  TEST_EARLY_FLAKE_IS_ENABLED,
+  TEST_IS_NEW,
+  TEST_EARLY_FLAKE_IS_RETRY
 } = require('../../dd-trace/src/plugins/util/test')
 const { RESOURCE_NAME } = require('../../../ext/tags')
 const { COMPONENT, ERROR_MESSAGE } = require('../../dd-trace/src/constants')
+const {
+  TELEMETRY_EVENT_CREATED,
+  TELEMETRY_EVENT_FINISHED,
+  TELEMETRY_CODE_COVERAGE_STARTED,
+  TELEMETRY_CODE_COVERAGE_FINISHED,
+  TELEMETRY_ITR_FORCED_TO_RUN,
+  TELEMETRY_CODE_COVERAGE_EMPTY,
+  TELEMETRY_ITR_UNSKIPPABLE,
+  TELEMETRY_CODE_COVERAGE_NUM_FILES
+} = require('../../dd-trace/src/ci-visibility/telemetry')
 
 class CucumberPlugin extends CiPlugin {
   static get id () {
@@ -33,9 +49,10 @@ class CucumberPlugin extends CiPlugin {
       numSkippedSuites,
       testCodeCoverageLinesTotal,
       hasUnskippableSuites,
-      hasForcedToRunSuites
+      hasForcedToRunSuites,
+      isEarlyFlakeDetectionEnabled
     }) => {
-      const { isSuitesSkippingEnabled, isCodeCoverageEnabled } = this.itrConfig || {}
+      const { isSuitesSkippingEnabled, isCodeCoverageEnabled } = this.libraryConfig || {}
       addIntelligentTestRunnerSpanTags(
         this.testSessionSpan,
         this.testModuleSpan,
@@ -50,18 +67,23 @@ class CucumberPlugin extends CiPlugin {
           hasForcedToRunSuites
         }
       )
+      if (isEarlyFlakeDetectionEnabled) {
+        this.testSessionSpan.setTag(TEST_EARLY_FLAKE_IS_ENABLED, 'true')
+      }
 
       this.testSessionSpan.setTag(TEST_STATUS, status)
       this.testModuleSpan.setTag(TEST_STATUS, status)
       this.testModuleSpan.finish()
+      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
       this.testSessionSpan.finish()
+      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'session')
       finishAllTraceSpans(this.testSessionSpan)
 
-      this.itrConfig = null
+      this.libraryConfig = null
       this.tracer._exporter.flush()
     })
 
-    this.addSub('ci:cucumber:test-suite:start', ({ testSuitePath, isUnskippable, isForcedToRun }) => {
+    this.addSub('ci:cucumber:test-suite:start', ({ testSuitePath, isUnskippable, isForcedToRun, itrCorrelationId }) => {
       const testSuiteMetadata = getTestSuiteCommonTags(
         this.command,
         this.frameworkVersion,
@@ -69,11 +91,16 @@ class CucumberPlugin extends CiPlugin {
         'cucumber'
       )
       if (isUnskippable) {
+        this.telemetry.count(TELEMETRY_ITR_UNSKIPPABLE, { testLevel: 'suite' })
         testSuiteMetadata[TEST_ITR_UNSKIPPABLE] = 'true'
       }
       if (isForcedToRun) {
+        this.telemetry.count(TELEMETRY_ITR_FORCED_TO_RUN, { testLevel: 'suite' })
         testSuiteMetadata[TEST_ITR_FORCED_RUN] = 'true'
       }
+      if (itrCorrelationId) {
+        testSuiteMetadata[ITR_CORRELATION_ID] = itrCorrelationId
+      }
       this.testSuiteSpan = this.tracer.startSpan('cucumber.test_suite', {
         childOf: this.testModuleSpan,
         tags: {
@@ -82,19 +109,30 @@ class CucumberPlugin extends CiPlugin {
           ...testSuiteMetadata
         }
       })
+      this.telemetry.ciVisEvent(TELEMETRY_EVENT_CREATED, 'suite')
+      if (this.libraryConfig?.isCodeCoverageEnabled) {
+        this.telemetry.ciVisEvent(TELEMETRY_CODE_COVERAGE_STARTED, 'suite', { library: 'istanbul' })
+      }
     })
 
     this.addSub('ci:cucumber:test-suite:finish', status => {
       this.testSuiteSpan.setTag(TEST_STATUS, status)
       this.testSuiteSpan.finish()
+      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
     })
 
     this.addSub('ci:cucumber:test-suite:code-coverage', ({ coverageFiles, suiteFile }) => {
-      if (!this.itrConfig || !this.itrConfig.isCodeCoverageEnabled) {
+      if (!this.libraryConfig?.isCodeCoverageEnabled) {
         return
       }
+      if (!coverageFiles.length) {
+        this.telemetry.count(TELEMETRY_CODE_COVERAGE_EMPTY)
+      }
+
       const relativeCoverageFiles = [...coverageFiles, suiteFile]
-        .map(filename => getTestSuitePath(filename, this.sourceRoot))
+        .map(filename => getTestSuitePath(filename, this.repositoryRoot))
+
+      this.telemetry.distribution(TELEMETRY_CODE_COVERAGE_NUM_FILES, {}, relativeCoverageFiles.length)
 
       const formattedCoverage = {
         sessionId: this.testSuiteSpan.context()._traceId,
@@ -103,12 +141,19 @@ class CucumberPlugin extends CiPlugin {
       }
 
       this.tracer._exporter.exportCoverage(formattedCoverage)
+      this.telemetry.ciVisEvent(TELEMETRY_CODE_COVERAGE_FINISHED, 'suite', { library: 'istanbul' })
     })
 
-    this.addSub('ci:cucumber:test:start', ({ testName, fullTestSuite, testSourceLine }) => {
+    this.addSub('ci:cucumber:test:start', ({ testName, testFileAbsolutePath, testSourceLine }) => {
       const store = storage.getStore()
-      const testSuite = getTestSuitePath(fullTestSuite, this.sourceRoot)
-      const testSpan = this.startTestSpan(testName, testSuite, testSourceLine)
+      const testSuite = getTestSuitePath(testFileAbsolutePath, this.sourceRoot)
+      const testSourceFile = getTestSuitePath(testFileAbsolutePath, this.repositoryRoot)
+
+      const extraTags = {
+        [TEST_SOURCE_START]: testSourceLine,
+        [TEST_SOURCE_FILE]: testSourceFile
+      }
+      const testSpan = this.startTestSpan(testName, testSuite, extraTags)
 
       this.enter(testSpan, store)
     })
@@ -127,12 +172,19 @@ class CucumberPlugin extends CiPlugin {
       this.enter(span, store)
     })
 
-    this.addSub('ci:cucumber:test:finish', ({ isStep, status, skipReason, errorMessage }) => {
+    this.addSub('ci:cucumber:test:finish', ({ isStep, status, skipReason, errorMessage, isNew, isEfdRetry }) => {
       const span = storage.getStore().span
       const statusTag = isStep ? 'step.status' : TEST_STATUS
 
       span.setTag(statusTag, status)
 
+      if (isNew) {
+        span.setTag(TEST_IS_NEW, 'true')
+        if (isEfdRetry) {
+          span.setTag(TEST_EARLY_FLAKE_IS_RETRY, 'true')
+        }
+      }
+
       if (skipReason) {
         span.setTag(TEST_SKIP_REASON, skipReason)
       }
@@ -143,6 +195,11 @@ class CucumberPlugin extends CiPlugin {
 
       span.finish()
       if (!isStep) {
+        this.telemetry.ciVisEvent(
+          TELEMETRY_EVENT_FINISHED,
+          'test',
+          { hasCodeOwners: !!span.context()._tags[TEST_CODE_OWNERS] }
+        )
         finishAllTraceSpans(span)
       }
     })
@@ -155,12 +212,12 @@ class CucumberPlugin extends CiPlugin {
     })
   }
 
-  startTestSpan (testName, testSuite, testSourceLine) {
+  startTestSpan (testName, testSuite, extraTags) {
     return super.startTestSpan(
       testName,
       testSuite,
       this.testSuiteSpan,
-      { [TEST_SOURCE_START]: testSourceLine }
+      extraTags
     )
   }
 }

package/packages/datadog-plugin-cypress/src/after-run.js

@@ -0,0 +1,3 @@
+const cypressPlugin = require('./cypress-plugin')
+
+module.exports = cypressPlugin.afterRun.bind(cypressPlugin)

package/packages/datadog-plugin-cypress/src/after-spec.js

@@ -0,0 +1,3 @@
+const cypressPlugin = require('./cypress-plugin')
+
+module.exports = cypressPlugin.afterSpec.bind(cypressPlugin)