@depup/dd-trace 5.90.0-depup.0

package/packages/dd-trace/src/ci-visibility/test-api-manual/test-api-manual-plugin.js

@@ -0,0 +1,63 @@
+'use strict'
+
+const CiPlugin = require('../../plugins/ci_plugin')
+const {
+  TEST_STATUS,
+  finishAllTraceSpans,
+  getTestSuitePath,
+} = require('../../plugins/util/test')
+const { storage } = require('../../../../datadog-core')
+
+class TestApiManualPlugin extends CiPlugin {
+  static id = 'test-api-manual'
+
+  constructor (...args) {
+    super(...args)
+    this._isEnvDataCalcualted = false
+    this.sourceRoot = process.cwd()
+
+    this.unconfiguredAddSub('dd-trace:ci:manual:test:start', ({ testName, testSuite }) => {
+      const store = storage('legacy').getStore()
+      const testSuiteRelative = getTestSuitePath(testSuite, this.sourceRoot)
+      const testSpan = this.startTestSpan(testName, testSuiteRelative)
+      this.enter(testSpan, store)
+    })
+    this.unconfiguredAddSub('dd-trace:ci:manual:test:finish', ({ status, error }) => {
+      const store = storage('legacy').getStore()
+      const testSpan = store && store.span
+      if (testSpan) {
+        testSpan.setTag(TEST_STATUS, status)
+        if (error) {
+          testSpan.setTag('error', error)
+        }
+        testSpan.finish()
+        finishAllTraceSpans(testSpan)
+      }
+    })
+    this.unconfiguredAddSub('dd-trace:ci:manual:test:addTags', (tags) => {
+      const store = storage('legacy').getStore()
+      const testSpan = store && store.span
+      if (testSpan) {
+        testSpan.addTags(tags)
+      }
+    })
+  }
+
+  // To lazily calculate env data.
+  unconfiguredAddSub (channelName, handler) {
+    this.addSub(channelName, (...args) => {
+      if (!this._isEnvDataCalcualted) {
+        this._isEnvDataCalcualted = true
+        this.configure(this._config, true)
+      }
+      return handler(...args)
+    })
+  }
+
+  configure (config, shouldGetEnvironmentData) {
+    this._config = config
+    super.configure(config, shouldGetEnvironmentData)
+  }
+}
+
+module.exports = TestApiManualPlugin

package/packages/dd-trace/src/ci-visibility/test-management/get-test-management-tests.js

@@ -0,0 +1,121 @@
+'use strict'
+
+const request = require('../requests/request')
+const id = require('../../id')
+const { getValueFromEnvSources } = require('../../config/helper')
+const log = require('../../log')
+
+const {
+  incrementCountMetric,
+  distributionMetric,
+  TELEMETRY_TEST_MANAGEMENT_TESTS,
+  TELEMETRY_TEST_MANAGEMENT_TESTS_MS,
+  TELEMETRY_TEST_MANAGEMENT_TESTS_ERRORS,
+  TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_TESTS,
+  TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_BYTES,
+} = require('../telemetry')
+
+// Calculate the number of tests from the test management tests response, which has a shape like:
+// { module: { suites: { suite: { tests: { testName: { properties: {...} } } } } } }
+function getNumFromTestManagementTests (testManagementTests) {
+  if (!testManagementTests) {
+    return 0
+  }
+
+  let totalNumTests = 0
+
+  for (const testModule of Object.values(testManagementTests)) {
+    const { suites } = testModule
+    if (!suites) continue
+    for (const testSuite of Object.values(suites)) {
+      const { tests } = testSuite
+      if (!tests) continue
+      totalNumTests += Object.keys(tests).length
+    }
+  }
+
+  return totalNumTests
+}
+
+function getTestManagementTests ({
+  url,
+  isEvpProxy,
+  evpProxyPrefix,
+  isGzipCompatible,
+  repositoryUrl,
+  commitMessage,
+  sha,
+  commitHeadSha,
+  commitHeadMessage,
+  branch,
+}, done) {
+  const options = {
+    path: '/api/v2/test/libraries/test-management/tests',
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    timeout: 20_000,
+    url,
+  }
+
+  if (isGzipCompatible) {
+    options.headers['accept-encoding'] = 'gzip'
+  }
+
+  if (isEvpProxy) {
+    options.path = `${evpProxyPrefix}/api/v2/test/libraries/test-management/tests`
+    options.headers['X-Datadog-EVP-Subdomain'] = 'api'
+  } else {
+    const apiKey = getValueFromEnvSources('DD_API_KEY')
+    if (!apiKey) {
+      return done(new Error('Test management tests were not fetched because Datadog API key is not defined.'))
+    }
+
+    options.headers['dd-api-key'] = apiKey
+  }
+
+  const data = JSON.stringify({
+    data: {
+      id: id().toString(10),
+      type: 'ci_app_libraries_tests_request',
+      attributes: {
+        repository_url: repositoryUrl,
+        commit_message: commitHeadMessage || commitMessage,
+        sha: commitHeadSha || sha,
+        branch,
+      },
+    },
+  })
+
+  log.debug('Requesting test management tests: %s', data)
+
+  incrementCountMetric(TELEMETRY_TEST_MANAGEMENT_TESTS)
+
+  const startTime = Date.now()
+
+  request(data, options, (err, res, statusCode) => {
+    distributionMetric(TELEMETRY_TEST_MANAGEMENT_TESTS_MS, {}, Date.now() - startTime)
+    if (err) {
+      incrementCountMetric(TELEMETRY_TEST_MANAGEMENT_TESTS_ERRORS, { statusCode })
+      done(err)
+    } else {
+      try {
+        const { data: { attributes: { modules: testManagementTests } } } = JSON.parse(res)
+
+        const numTests = getNumFromTestManagementTests(testManagementTests)
+
+        distributionMetric(TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_TESTS, {}, numTests)
+        distributionMetric(TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_BYTES, {}, res.length)
+
+        log.debug('Test management tests received: %j', testManagementTests)
+
+        done(null, testManagementTests)
+      } catch (err) {
+        done(err)
+      }
+    }
+  })
+}
+
+module.exports = { getTestManagementTests }

package/packages/dd-trace/src/ci-visibility/test-optimization-cache.js

@@ -0,0 +1,61 @@
+'use strict'
+
+const { writeFileSync } = require('node:fs')
+const { tmpdir } = require('node:os')
+const { randomUUID } = require('node:crypto')
+const path = require('node:path')
+
+const { getValueFromEnvSources } = require('../config/helper')
+const log = require('../log')
+
+/**
+ * Gets the test optimization settings cache file path from the env var.
+ * @returns {string|undefined} The cache file path, or undefined if not set.
+ */
+function getSettingsCachePath () {
+  return getValueFromEnvSources('DD_EXPERIMENTAL_TEST_OPT_SETTINGS_CACHE')
+}
+
+/**
+ * Sets up the test optimization settings cache file path.
+ * Returns the existing path if already set, otherwise creates a new one.
+ * @returns {string} The cache file path.
+ */
+function setupSettingsCachePath () {
+  const existing = getSettingsCachePath()
+  if (existing) {
+    return existing
+  }
+
+  const cacheFilePath = path.join(tmpdir(), `dd-test-optimization-${randomUUID()}.json`)
+
+  // eslint-disable-next-line eslint-rules/eslint-process-env
+  process.env.DD_EXPERIMENTAL_TEST_OPT_SETTINGS_CACHE = cacheFilePath
+
+  return cacheFilePath
+}
+
+/**
+ * Writes the settings to the cache file specified by DD_EXPERIMENTAL_TEST_OPT_SETTINGS_CACHE.
+ * Does nothing if the env var is not set.
+ * @param {object} settings - The settings object to cache.
+ */
+function writeSettingsToCache (settings) {
+  const settingsCachePath = getSettingsCachePath()
+  if (!settingsCachePath) {
+    return
+  }
+
+  try {
+    writeFileSync(settingsCachePath, JSON.stringify(settings), 'utf8')
+    log.debug('Settings written to %s', settingsCachePath)
+  } catch (err) {
+    log.error('Failed to write settings to cache file', err)
+  }
+}
+
+module.exports = {
+  getSettingsCachePath,
+  setupSettingsCachePath,
+  writeSettingsToCache,
+}

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

@@ -0,0 +1,174 @@
+'use strict'
+
+const pkg = require('../pkg')
+const { isFalse, isTrue } = require('../util')
+const { getEnvironmentVariable: getEnv } = require('./helper')
+
+const {
+  supportedConfigurations,
+} = /** @type {import('./helper').SupportedConfigurationsJson} */ (require('./supported-configurations.json'))
+
+const service = getEnv('AWS_LAMBDA_FUNCTION_NAME') ||
+  getEnv('FUNCTION_NAME') || // Google Cloud Function Name set by deprecated runtimes
+  getEnv('K_SERVICE') || // Google Cloud Function Name set by newer runtimes
+  getEnv('WEBSITE_SITE_NAME') || // set by Azure Functions
+  pkg.name ||
+  'node'
+
+/**
+ * @param {string|null} raw
+ * @param {string} type
+ * @returns {string|number|boolean|Record<string, string>|unknown[]|undefined}
+ */
+function parseDefaultByType (raw, type) {
+  if (raw === null) {
+    return
+  }
+
+  switch (type) {
+    case 'boolean':
+      if (isTrue(raw)) return true
+      if (isFalse(raw)) return false
+      // TODO: What should we do with these?
+      return
+    case 'int':
+    case 'decimal': {
+      return Number(raw)
+    }
+    case 'array': {
+      if (!raw || raw.length === 0) return []
+      // TODO: Make the parsing a helper that is reused.
+      return raw.split(',').map(item => {
+        const colonIndex = item.indexOf(':')
+        if (colonIndex === -1) {
+          return item.trim()
+        }
+        const key = item.slice(0, colonIndex).trim()
+        const value = item.slice(colonIndex + 1).trim()
+        return `${key}:${value}`
+      })
+    }
+    case 'map': {
+      if (!raw || raw.length === 0) return {}
+      // TODO: Make the parsing a helper that is reused.
+      /** @type {Record<string, string>} */
+      const entries = {}
+      for (const item of raw.split(',')) {
+        const colonIndex = item.indexOf(':')
+        if (colonIndex === -1) {
+          const key = item.trim()
+          if (key.length > 0) {
+            entries[key] = ''
+          }
+          continue
+        }
+        const key = item.slice(0, colonIndex).trim()
+        const value = item.slice(colonIndex + 1).trim()
+        if (key.length > 0) {
+          entries[key] = value
+        }
+      }
+      return entries
+    }
+    default:
+      return raw
+  }
+}
+
+/** @type {Record<string, unknown>} */
+const metadataDefaults = {}
+for (const entries of Object.values(supportedConfigurations)) {
+  for (const entry of entries) {
+    // TODO: Replace $dynamic with method names that would be called and that
+    // are also called when the user passes through the value. That way the
+    // handling is unified and methods can be declared as default.
+    // The name of that method should be expressive for users.
+    // TODO: Add handling for all environment variable names. They should not
+    // need a configuration name for being listed with their default.
+    if (!Array.isArray(entry.configurationNames)) {
+      continue
+    }
+
+    const parsedValue = parseDefaultByType(entry.default, entry.type)
+    for (const configurationName of entry.configurationNames) {
+      metadataDefaults[configurationName] = entry.default === null ? undefined : parsedValue
+    }
+  }
+}
+
+// Defaults required by JS config merge/applyCalculated that are not represented in supported-configurations.
+const defaultsWithoutSupportedConfigurationEntry = {
+  'cloudPayloadTagging.rules': [],
+  'cloudPayloadTagging.requestsEnabled': false,
+  'cloudPayloadTagging.responsesEnabled': false,
+  isAzureFunction: false,
+  isCiVisibility: false,
+  isGCPFunction: false,
+  instrumentationSource: 'manual',
+  isServiceUserProvided: false,
+  lookup: undefined,
+  plugins: true,
+}
+
+// These values are documented in supported-configurations as CI Visibility
+// defaults. Keep startup baseline false and let #applyCalculated() switch them
+// when CI Visibility is active.
+// TODO: These entries should be removed. They are off by default
+// because they rely on other configs.
+const defaultsWithConditionalRuntimeBehavior = {
+  isGitUploadEnabled: false,
+  isImpactedTestsEnabled: false,
+  isIntelligentTestRunnerEnabled: false,
+  isManualApiEnabled: false,
+  isTestManagementEnabled: false,
+  // TODO: These are not conditional, they would just be of type number.
+  'dogstatsd.port': '8125',
+  port: '8126',
+  // Override due to expecting numbers, not strings. TODO: Replace later.
+  'grpc.client.error.statuses': [
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+  ],
+  'grpc.server.error.statuses': [
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+  ],
+}
+
+/** @type {Record<string, unknown>} */
+const defaults = {
+  ...defaultsWithoutSupportedConfigurationEntry,
+  ...metadataDefaults,
+  ...defaultsWithConditionalRuntimeBehavior,
+  service,
+  version: pkg.version,
+}
+
+module.exports = defaults

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

@@ -0,0 +1,120 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+
+const gitPropertiesCommitSHARegex = /git\.commit\.sha=([a-f\d]{40})/
+const gitPropertiesRepositoryUrlRegex = /git\.repository_url=([\w\d:@/.-]+)/
+const repositoryUrlRegex = /^([\w\d:@/.-]+)$/
+const remoteOriginRegex = /^\[remote\s+"origin"\]/i
+const gitHeadRefRegex = /ref:\s+(refs\/[A-Za-z0-9._/-]+)/
+const commitSHARegex = /^[0-9a-f]{40}$/
+
+function removeUserSensitiveInfo (repositoryUrl) {
+  try {
+    // repository URLs can contain username and password, so we want to filter those out
+    const parsedUrl = new URL(repositoryUrl)
+    if (parsedUrl.username || parsedUrl.password) {
+      return `${parsedUrl.origin}${parsedUrl.pathname}`
+    }
+    return repositoryUrl
+  } catch {
+    // if protocol isn't https, no password will be used
+    return repositoryUrl
+  }
+}
+
+function getGitMetadataFromGitProperties (gitPropertiesString) {
+  if (!gitPropertiesString) {
+    return {}
+  }
+  const commitSHAMatch = gitPropertiesString.match(gitPropertiesCommitSHARegex)
+  const repositoryUrlMatch = gitPropertiesString.match(gitPropertiesRepositoryUrlRegex)
+
+  const repositoryUrl = repositoryUrlMatch ? repositoryUrlMatch[1] : undefined
+
+  return {
+    commitSHA: commitSHAMatch ? commitSHAMatch[1] : undefined,
+    repositoryUrl: removeUserSensitiveInfo(repositoryUrl),
+  }
+}
+
+function getRemoteOriginURL (gitConfigContent) {
+  if (!gitConfigContent) {
+    return
+  }
+  const lines = gitConfigContent.split('\n')
+  let index = 0
+
+  // find the remote origin section
+  for (; index < lines.length; index++) {
+    const line = lines[index]
+    if (line[0] !== '[') continue // fast path
+    if (remoteOriginRegex.test(line)) break
+  }
+
+  // find the url key/value in the [remote "origin"] section
+  index++
+  for (; index < lines.length; index++) {
+    const line = lines[index]
+    if (line[0] === '[') return // abort, section didn't contain a url
+    const splitAt = line.indexOf('=')
+    if (splitAt === -1) continue
+    const key = line.slice(0, splitAt).trim().toLowerCase()
+    if (key !== 'url') continue
+    const repositoryUrlValue = line.slice(splitAt + 1).trim()
+    const repositoryUrlMatch = repositoryUrlValue.match(repositoryUrlRegex)
+    if (!repositoryUrlMatch) continue
+    return removeUserSensitiveInfo(repositoryUrlMatch[0])
+  }
+}
+
+function getGitHeadRef (gitHeadContent) {
+  if (!gitHeadContent) {
+    return
+  }
+
+  // Extract the ref after 'ref: '
+  const gitRefMatch = gitHeadContent.match(gitHeadRefRegex)
+  return gitRefMatch?.[1]
+}
+
+function resolveGitHeadSHA (DD_GIT_FOLDER_PATH) {
+  const gitHeadPath = path.join(DD_GIT_FOLDER_PATH, 'HEAD')
+
+  try {
+    const gitHeadContent = fs.readFileSync(gitHeadPath, 'utf8')
+    if (!gitHeadContent) {
+      return
+    }
+
+    const headContent = gitHeadContent.trim()
+
+    // Handle detached head case
+    if (commitSHARegex.test(headContent)) {
+      return headContent
+    }
+
+    // Handle ref case - extract the ref and read the SHA from the ref file
+    const gitHeadRef = getGitHeadRef(headContent)
+    if (!gitHeadRef) {
+      return
+    }
+    const gitHeadRefPath = path.join(DD_GIT_FOLDER_PATH, gitHeadRef)
+    const gitHeadRefContent = fs.readFileSync(gitHeadRefPath, 'utf8')
+    if (gitHeadRefContent) {
+      const headRefContent = gitHeadRefContent.trim()
+      if (commitSHARegex.test(headRefContent)) {
+        return headRefContent
+      }
+    }
+  } catch {}
+}
+
+module.exports = {
+  getGitMetadataFromGitProperties,
+  removeUserSensitiveInfo,
+  getGitHeadRef,
+  getRemoteOriginURL,
+  resolveGitHeadSHA,
+}