dd-trace 5.53.0 → 5.55.0

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

@@ -51,7 +51,7 @@ function sanitizedExec (
   try {
     let result = cp.execFileSync(cmd, flags, { stdio: 'pipe' }).toString()
     if (shouldTrim) {
-      result = result.replace(/(\r\n|\n|\r)/gm, '')
+      result = result.replaceAll(/(\r\n|\n|\r)/gm, '')
     }
     if (durationMetric) {
       distributionMetric(durationMetric.name, durationMetric.tags, Date.now() - startTime)
@@ -76,7 +76,7 @@ function isDirectory (path) {
   try {
     const stats = fs.statSync(path)
     return stats.isDirectory()
-  } catch (e) {
+  } catch {
     return false
   }
 }
@@ -87,7 +87,7 @@ function isGitAvailable () {
   try {
     cp.execFileSync(command, ['git'], { stdio: 'pipe' })
     return true
-  } catch (e) {
+  } catch {
     incrementCountMetric(TELEMETRY_GIT_COMMAND_ERRORS, { command: 'check_git', exitCode: 'missing' })
     return false
   }
@@ -108,11 +108,11 @@ function getGitVersion () {
   const gitVersionMatches = gitVersionString.match(/git version (\d+)\.(\d+)\.(\d+)/)
   try {
     return {
-      major: parseInt(gitVersionMatches[1]),
-      minor: parseInt(gitVersionMatches[2]),
-      patch: parseInt(gitVersionMatches[3])
+      major: Number.parseInt(gitVersionMatches[1]),
+      minor: Number.parseInt(gitVersionMatches[2]),
+      patch: Number.parseInt(gitVersionMatches[3])
     }
-  } catch (e) {
+  } catch {
     return null
   }
 }
@@ -196,7 +196,7 @@ function getLatestCommits () {
     const result = cp.execFileSync('git', ['log', '--format=%H', '-n 1000', '--since="1 month ago"'], { stdio: 'pipe' })
       .toString()
       .split('\n')
-      .filter(commit => commit)
+      .filter(Boolean)
     distributionMetric(TELEMETRY_GIT_COMMAND_MS, { command: 'get_local_commits' }, Date.now() - startTime)
     return result
   } catch (err) {
@@ -209,6 +209,138 @@ function getLatestCommits () {
   }
 }
 
+function getGitDiff (baseCommit, targetCommit) {
+  const flags = ['diff', '-U0', '--word-diff=porcelain', baseCommit]
+  if (targetCommit) {
+    flags.push(targetCommit)
+  }
+  return sanitizedExec(
+    'git',
+    flags,
+    { name: TELEMETRY_GIT_COMMAND, tags: { command: 'diff' } },
+    { name: TELEMETRY_GIT_COMMAND_MS, tags: { command: 'diff' } },
+    { name: TELEMETRY_GIT_COMMAND_ERRORS, tags: { command: 'diff' } },
+    false // important not to trim or we'll lose the line breaks which we need to detect impacted tests
+  )
+}
+
+function getGitRemoteName () {
+  const upstreamRemote = sanitizedExec(
+    'git',
+    ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'],
+    { name: TELEMETRY_GIT_COMMAND, tags: { command: 'get_remote_name' } },
+    { name: TELEMETRY_GIT_COMMAND_MS, tags: { command: 'get_remote_name' } },
+    { name: TELEMETRY_GIT_COMMAND_ERRORS, tags: { command: 'get_remote_name' } }
+  )
+
+  if (upstreamRemote) {
+    return upstreamRemote.split('/')[0]
+  }
+
+  const remotes = sanitizedExec(
+    'git',
+    ['remote'],
+    { name: TELEMETRY_GIT_COMMAND, tags: { command: 'get_remote_name' } },
+    { name: TELEMETRY_GIT_COMMAND_MS, tags: { command: 'get_remote_name' } },
+    { name: TELEMETRY_GIT_COMMAND_ERRORS, tags: { command: 'get_remote_name' } },
+    false
+  )
+
+  return remotes.split('\n')[0] || 'origin'
+}
+
+function getSourceBranch () {
+  return sanitizedExec(
+    'git',
+    ['rev-parse', '--abbrev-ref', 'HEAD'],
+    { name: TELEMETRY_GIT_COMMAND, tags: { command: 'get_source_branch' } },
+    { name: TELEMETRY_GIT_COMMAND_MS, tags: { command: 'get_source_branch' } },
+    { name: TELEMETRY_GIT_COMMAND_ERRORS, tags: { command: 'get_source_branch' } }
+  )
+}
+
+function checkAndFetchBranch (branch, remoteName) {
+  try {
+    // `git show-ref --verify --quiet refs/remotes/${remoteName}/${branch}` will exit 0 if the branch exists
+    // Otherwise it will exit 1
+    cp.execFileSync(
+      'git',
+      ['show-ref', '--verify', '--quiet', `refs/remotes/${remoteName}/${branch}`],
+      { stdio: 'pipe' }
+    )
+    // branch exists locally, so we finish
+  } catch {
+    // branch does not exist locally, so we will check the remote
+    try {
+      // IMPORTANT: we use timeouts because these commands hang if the branch can't be found
+      // `git ls-remote --heads origin my-branch` will exit 0 even if the branch doesn't exist.
+      // The piece of information we need is whether the command outputs anything.
+      // `git ls-remote --heads origin my-branch` could exit an error code if the remote does not exist.
+      const remoteHeads = cp.execFileSync(
+        'git',
+        ['ls-remote', '--heads', remoteName, branch],
+        { stdio: 'pipe', timeout: 2000 }
+      )
+      if (remoteHeads) {
+        // branch exists, so we'll fetch it
+        cp.execFileSync(
+          'git',
+          ['fetch', '--depth', '1', remoteName, branch],
+          { stdio: 'pipe', timeout: 5000 }
+        )
+      }
+    } catch (e) {
+      // branch does not exist or couldn't be fetched, so we can't do anything
+      log.error('Git plugin error checking and fetching branch', e)
+    }
+  }
+}
+
+function getLocalBranches (remoteName) {
+  const localBranches = sanitizedExec(
+    'git',
+    ['for-each-ref', '--format=%(refname:short)', `refs/remotes/${remoteName}`],
+    { name: TELEMETRY_GIT_COMMAND, tags: { command: 'get_local_branches' } },
+    { name: TELEMETRY_GIT_COMMAND_MS, tags: { command: 'get_local_branches' } },
+    { name: TELEMETRY_GIT_COMMAND_ERRORS, tags: { command: 'get_local_branches' } },
+    false
+  )
+  try {
+    return localBranches.split('\n').filter(Boolean)
+  } catch {
+    return []
+  }
+}
+
+function getMergeBase (baseBranch, sourceBranch) {
+  return sanitizedExec(
+    'git',
+    ['merge-base', baseBranch, sourceBranch],
+    { name: TELEMETRY_GIT_COMMAND, tags: { command: 'get_merge_base' } },
+    { name: TELEMETRY_GIT_COMMAND_MS, tags: { command: 'get_merge_base' } },
+    { name: TELEMETRY_GIT_COMMAND_ERRORS, tags: { command: 'get_merge_base' } }
+  )
+}
+
+function getCounts (sourceBranch, candidateBranch) {
+  const counts = sanitizedExec(
+    'git',
+    ['rev-list', '--left-right', '--count', `${candidateBranch}...${sourceBranch}`],
+    { name: TELEMETRY_GIT_COMMAND, tags: { command: 'get_counts' } },
+    { name: TELEMETRY_GIT_COMMAND_MS, tags: { command: 'get_counts' } },
+    { name: TELEMETRY_GIT_COMMAND_ERRORS, tags: { command: 'get_counts' } }
+  )
+  try {
+    if (!counts) {
+      return { behind: null, ahead: null }
+    }
+    const [behind, ahead] = counts.split(/\s+/).map(Number)
+    return { behind, ahead }
+  } catch {
+    return { behind: null, ahead: null }
+  }
+}
+
 function getCommitsRevList (commitsToExclude, commitsToInclude) {
   let result = null
 
@@ -231,7 +363,7 @@ function getCommitsRevList (commitsToExclude, commitsToInclude) {
       { stdio: 'pipe', maxBuffer: GIT_REV_LIST_MAX_BUFFER })
       .toString()
       .split('\n')
-      .filter(commit => commit)
+      .filter(Boolean)
   } catch (err) {
     log.error('Get commits to upload failed: %s', err.message)
     incrementCountMetric(
@@ -252,7 +384,7 @@ function generatePackFilesForCommits (commitsToUpload) {
     return []
   }
 
-  const randomPrefix = String(Math.floor(Math.random() * 10000))
+  const randomPrefix = String(Math.floor(Math.random() * 10_000))
   const temporaryPath = path.join(tmpFolder, randomPrefix)
   const cwdPath = path.join(process.cwd(), randomPrefix)
 
@@ -270,7 +402,7 @@ function generatePackFilesForCommits (commitsToUpload) {
         targetPath
       ],
       { stdio: 'pipe', input: commitsToUpload.join('\n') }
-    ).toString().split('\n').filter(commit => commit).map(commit => `${targetPath}-${commit}.pack`)
+    ).toString().split('\n').filter(Boolean).map(commit => `${targetPath}-${commit}.pack`)
   }
 
   try {
@@ -362,6 +494,20 @@ function getGitMetadata (ciMetadata) {
   return tags
 }
 
+function getGitInformationDiscrepancy () {
+  const gitRepositoryUrl = getRepositoryUrl()
+
+  const gitCommitSHA = sanitizedExec(
+    'git',
+    ['rev-parse', 'HEAD'],
+    { name: TELEMETRY_GIT_COMMAND, tags: { command: 'get_commit_sha' } },
+    { name: TELEMETRY_GIT_COMMAND_MS, tags: { command: 'get_commit_sha' } },
+    { name: TELEMETRY_GIT_COMMAND_ERRORS, tags: { command: 'get_commit_sha' } }
+  )
+
+  return { gitRepositoryUrl, gitCommitSHA }
+}
+
 module.exports = {
   getGitMetadata,
   getLatestCommits,
@@ -371,5 +517,13 @@ module.exports = {
   GIT_REV_LIST_MAX_BUFFER,
   isShallowRepository,
   unshallowRepository,
-  isGitAvailable
+  isGitAvailable,
+  getGitInformationDiscrepancy,
+  getGitDiff,
+  getGitRemoteName,
+  getSourceBranch,
+  checkAndFetchBranch,
+  getLocalBranches,
+  getMergeBase,
+  getCounts
 }

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

@@ -85,7 +85,7 @@ function extractInferredProxyContext (headers) {
 
   return {
     requestTime: headers[PROXY_HEADER_START_TIME_MS]
-      ? parseInt(headers[PROXY_HEADER_START_TIME_MS], 10)
+      ? Number.parseInt(headers[PROXY_HEADER_START_TIME_MS], 10)
       : null,
     method: headers[PROXY_HEADER_HTTPMETHOD],
     path: headers[PROXY_HEADER_PATH],

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

@@ -33,7 +33,7 @@ const privateIPMatcher = new BlockList()
 for (const cidr of privateCIDRs) {
   const [address, prefix] = cidr.split('/')
 
-  privateIPMatcher.addSubnet(address, parseInt(prefix), net.isIPv6(address) ? 'ipv6' : 'ipv4')
+  privateIPMatcher.addSubnet(address, Number.parseInt(prefix), net.isIPv6(address) ? 'ipv6' : 'ipv4')
 }
 
 function extractIp (config, req) {

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

@@ -4,32 +4,49 @@ const RE_NEWLINE = /\n/g
 const RE_TAB = /\t/g
 
 function normalize (text, limit = 128) {
-  if (!text) return
-  if (typeof text !== 'string' || !text || (typeof text === 'string' && text.length === 0)) return
+  if (typeof text !== 'string' || text.length === 0) return
+
+  if (text.length > limit) {
+    return text.slice(0, limit) + '...'
+  }
 
   text = text
-    .replace(RE_NEWLINE, '\\n')
-    .replace(RE_TAB, '\\t')
+    .replaceAll(RE_NEWLINE, String.raw`\n`)
+    .replaceAll(RE_TAB, String.raw`\t`)
 
+  // In case the replace above matched, more characters were added that must now be considered.
   if (text.length > limit) {
-    return text.substring(0, limit) + '...'
+    return text.slice(0, limit) + '...'
   }
 
   return text
 }
 
-function isPromptCompletionSampled (sampler) {
-  return sampler.isSampled()
+/**
+ * Determines whether a prompt completion should be sampled based on the configured sampling rate.
+ *
+ * @param {Sampler} sampler
+ * @param {import('index').Span|import('index').SpanContext} span
+ * @returns {boolean} `true` if the prompt completion should be sampled, otherwise `false`.
+ */
+function isPromptCompletionSampled (sampler, span) {
+  return sampler.isSampled(span)
 }
 
-module.exports = function (integrationName, tracerConfig) {
+module.exports = function makeUtilities (integrationName, tracerConfig) {
   const integrationConfig = tracerConfig[integrationName] || {}
   const { spanCharLimit, spanPromptCompletionSampleRate } = integrationConfig
 
-  const sampler = new Sampler(spanPromptCompletionSampleRate ?? 1.0)
+  const sampler = new Sampler(spanPromptCompletionSampleRate ?? 1)
 
   return {
     normalize: str => normalize(str, spanCharLimit),
-    isPromptCompletionSampled: () => isPromptCompletionSampled(sampler)
+    /**
+     * Determines whether a prompt completion should be sampled based on the configured sampling rate.
+     *
+     * @param {import('index').Span|import('index').SpanContext} span
+     * @returns {boolean} `true` if the prompt completion should be sampled, otherwise `false`.
+     */
+    isPromptCompletionSampled: (span) => isPromptCompletionSampled(sampler, span)
   }
 }

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

@@ -34,7 +34,14 @@ function getCallSites (constructorOpt) {
  *
  * @param {Function} constructorOpt - Function to pass along to Error.captureStackTrace
  * @param {number} [limit=Infinity] - The maximum number of frames to return
- * @returns {{ file: string, line: number, method: (string|undefined), type: (string|undefined) }[]} - A
+ * @returns {StackFrame[]} - A list of stack frames from user-land code
+ *
+ * @typedef {Object} StackFrame
+ * @property {string} file - The file path of the frame
+ * @property {number} line - The line number in the file
+ * @property {number} column - The column number in the file
+ * @property {string} [method] - The function name, if available
+ * @property {string} [type] - The type name, if available
  */
 function getUserLandFrames (constructorOpt, limit = Infinity) {
   const callsites = getCallSites(constructorOpt)
@@ -72,7 +79,7 @@ function getUserLandFrames (constructorOpt, limit = Infinity) {
     // However, the tests in `packages/dd-trace/test/plugins/util/stacktrace.spec.js` will fail on my machine
     // because I have the source code in a parent folder called `node_modules`. So the code below thinks that
     // it's not in user-land
-    const relativePath = relative(cwd, containsFileProtocol ? filename.substring(7) : filename)
+    const relativePath = relative(cwd, containsFileProtocol ? filename.slice(7) : filename)
     if (relativePath.startsWith('node_modules' + sep) || relativePath.includes(sep + 'node_modules' + sep)) {
       continue
     }