dd-trace 6.12.0 → 6.14.0

package/packages/dd-trace/src/opentracing/span.js

@@ -26,6 +26,15 @@ const finishedRegistry = createRegistry('finished')
 let OTEL_ENABLED = false
 const ALLOWED = new Set(['string', 'number', 'boolean'])
 
+/**
+ * @typedef {object} RecordedException
+ * @property {string} message
+ * @property {string} [name]
+ * @property {string} [stack]
+ * @typedef {string | number | boolean} SpanEventAttributeScalar
+ * @typedef {SpanEventAttributeScalar | string[] | number[] | boolean[]} SpanEventAttributeValue
+ */
+
 const integrationCounters = {
   spans_created: {},
   spans_finished: {},
@@ -306,6 +315,25 @@ class DatadogSpan {
     this._events.push(event)
   }
 
+  /**
+   * @param {RecordedException} exception
+   * @param {Record<string, SpanEventAttributeValue>} [attributes]
+   */
+  recordException (exception, attributes) {
+    const { message, name, stack } = exception
+    const eventAttributes = { ...attributes }
+    eventAttributes['exception.message'] ??= message
+
+    if (typeof name === 'string') {
+      eventAttributes['exception.type'] ??= name
+    }
+    if (typeof stack === 'string') {
+      eventAttributes['exception.stacktrace'] ??= stack
+    }
+
+    this.addEvent('exception', eventAttributes)
+  }
+
   finish (finishTime) {
     if (this._duration !== undefined) {
       return

package/packages/dd-trace/src/otel-thread-ctx.js

@@ -105,6 +105,10 @@ const THREAD_ID = String(threadId)
 //             time onEnter activates the span, and cleared on span finish, which
 //             is how a pendingEndpoints waiter recognizes a record it must no
 //             longer append to.
+//   webTags:  the web-server tag bag the record's endpoint comes from, or is
+//             waiting on; undefined while the span has no web-server ancestry.
+//             Distinguishes a stale announcement from a live one when a nearer
+//             web-server span takes over.
 const CachedSym = Symbol('OtelThreadCtx.cached')
 
 let started = false
@@ -137,6 +141,7 @@ function getOrBuildContext (span) {
     span[CachedSym] = cached
   }
   cached.context = new ThreadContext(traceId, spanId, attrs)
+  cached.webTags = webTags
   if (endpoint === undefined) awaitEndpoint(webTags, cached)
   return cached.context
 }
@@ -227,21 +232,34 @@ function onEndpointResolved (span) {
   if (endpoint === undefined) return
   pendingEndpoints.delete(webTags)
   for (const cached of waiting) {
-    if (cached.context !== undefined) appendEndpoint(cached.context, endpoint)
+    // A record whose span has since been attributed to a nearer web-server span
+    // enlisted again under that bag, and this one is no longer its endpoint.
+    if (cached.context !== undefined && cached.webTags === webTags) appendEndpoint(cached.context, endpoint)
   }
 }
 
-// A span whose record was built before it looked like a web-server span at all
-// has just been recognized as one, so it has no endpoint and never enlisted for
-// this request. Its ancestry can't have changed, only its own tags, so this is
-// only ever about the announced span's own record.
+// webTagsCache has changed which request it attributes this span to: the span
+// itself or an ancestor was recognized as a web-server span, giving a record
+// built without any web-server ancestry its first endpoint, or a nearer
+// web-server span superseded the one this record is showing. Give the record
+// the new request's endpoint if it has settled, or wait for its announcement.
 function onWebTagsResolved (span) {
   if (!started) return
   const cached = span[CachedSym]
   if (cached === undefined || cached.context === undefined) return
   const webTags = webTagsCache.getCachedWebTags(span)
+  if (webTags === cached.webTags) return
+  // Recorded so that an announcement for the bag this record was previously
+  // waiting on no longer applies to it.
+  cached.webTags = webTags
   const endpoint = finalEndpoint(webTags)
   if (endpoint === undefined) {
+    // A record that already shows the outer request's endpoint goes on showing
+    // it until the nearer one settles: the record buffer is append-only, so
+    // there is no way to take the attribute back, and rebuilding the
+    // ThreadContext would strand every async-context frame holding this one.
+    // The work is still nested in the outer request, which makes that the least
+    // wrong of the values available.
     awaitEndpoint(webTags, cached)
   } else {
     appendEndpoint(cached.context, endpoint)

package/packages/dd-trace/src/payload-tagging/index.js

@@ -1,6 +1,7 @@
 'use strict'
 
-const rfdc = require('../../../../vendor/dist/rfdc')({ proto: false, circles: false })
+const createRfdc = require('../../../../vendor/dist/rfdc')
+const rfdc = createRfdc({ proto: false, circles: false })
 
 const {
   PAYLOAD_TAG_REQUEST_PREFIX,

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

@@ -165,6 +165,7 @@ module.exports = class PluginManager {
       codeOriginForSpans,
       dbmPropagationMode,
       dsmEnabled,
+      DD_TRACE_HTTP_CLIENT_ERROR_STATUSES,
       DD_TRACE_HTTP_SERVER_ERROR_STATUSES,
       clientIpEnabled,
       clientIpHeader,
@@ -195,6 +196,7 @@ module.exports = class PluginManager {
       site,
       url,
       headers: headerTags || [],
+      DD_TRACE_HTTP_CLIENT_ERROR_STATUSES,
       DD_TRACE_HTTP_SERVER_ERROR_STATUSES,
       clientIpHeader,
       DD_TEST_SESSION_NAME,

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

@@ -728,12 +728,7 @@ module.exports = class CiPlugin extends Plugin {
       this._bufferWorkerTrace(missingTestSuite, trace)
       return
     }
-    const exporter = this.tracer._exporter
-    if (exporter.exportTraceWithDeferredTestSuite) {
-      exporter.exportTraceWithDeferredTestSuite(trace)
-    } else {
-      exporter.export(trace)
-    }
+    this.tracer._exporter.export(trace)
   }
 
   /**

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

@@ -243,19 +243,21 @@ class TracingPlugin extends Plugin {
       serviceSource = undefined
     }
 
+    const tags = {
+      [COMPONENT]: component,
+      'service.name': serviceName || tracer._service,
+      'resource.name': resource,
+      'span.kind': kind,
+      'span.type': type,
+      ...meta,
+      ...metrics,
+    }
+    if (serviceSource !== undefined && !Object.hasOwn(tags, SVC_SRC_KEY)) tags[SVC_SRC_KEY] = serviceSource
+
     const span = tracer.startSpan(name, {
       startTime,
       childOf,
-      tags: {
-        [COMPONENT]: component,
-        'service.name': serviceName || tracer._service,
-        'resource.name': resource,
-        'span.kind': kind,
-        'span.type': type,
-        ...(serviceSource === undefined ? undefined : { [SVC_SRC_KEY]: serviceSource }),
-        ...meta,
-        ...metrics,
-      },
+      tags,
       integrationName: integrationName || component,
       links: childOf?._links,
     })

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

@@ -45,7 +45,9 @@ function parseEmailAndName (emailAndName) {
   }
   let name = ''
   let email = ''
-  const matchNameAndEmail = emailAndName.match(/(?:"?([^"]*)"?\s)?(?:<?(.+@[^>]+)>?)/)
+  // Untrusted git author metadata (a fork PR controls it). The anchor fixes the start position, the
+  // email classes cannot overlap around `@`, and the slice bounds the optional name part.
+  const matchNameAndEmail = emailAndName.slice(0, 1024).match(/^(?:"?([^"]*)"?\s)?<?([^\s@]+@[^\s>]+)>?/)
   if (matchNameAndEmail) {
     name = matchNameAndEmail[1]
     email = matchNameAndEmail[2]

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

@@ -69,26 +69,27 @@ function createInferredProxySpan (headers, childOf, tracer, reqCtx, traceCtx, co
 
   log.debug('Successfully extracted inferred span info %s for proxy:', proxyContext, proxyContext.proxySystemName)
 
+  const meta = {
+    service: proxyContext.domainName || tracer._config.service,
+    component: proxySpanInfo.component,
+    [SPAN_TYPE]: 'web',
+    [SPAN_KIND]: 'server',
+    [HTTP_METHOD]: proxyContext.method,
+    [HTTP_URL]: 'https://' + proxyContext.domainName + proxyContext.path,
+    stage: proxyContext.stage,
+    region: proxyContext.region,
+  }
+  if (proxyContext.resourcePath) meta[HTTP_ROUTE] = proxyContext.resourcePath
+  if (proxyContext.accountId) meta.account_id = proxyContext.accountId
+  if (proxyContext.apiId) meta.apiid = proxyContext.apiId
+  if (proxyContext.awsUser) meta.aws_user = proxyContext.awsUser
+
   const span = startSpanHelper(tracer, proxySpanInfo.spanName, {
     childOf,
     type: 'web',
     startTime: proxyContext.requestTime,
     integrationName: proxySpanInfo.component,
-    meta: {
-      service: proxyContext.domainName || tracer._config.service,
-      component: proxySpanInfo.component,
-      [SPAN_TYPE]: 'web',
-      [SPAN_KIND]: 'server',
-      [HTTP_METHOD]: proxyContext.method,
-      [HTTP_URL]: 'https://' + proxyContext.domainName + proxyContext.path,
-      stage: proxyContext.stage,
-      region: proxyContext.region,
-      ...(proxyContext.resourcePath && { [HTTP_ROUTE]: proxyContext.resourcePath }),
-      ...(proxyContext.accountId && { account_id: proxyContext.accountId }),
-      ...(proxyContext.apiId && { apiid: proxyContext.apiId }),
-      ...(proxyContext.region && { region: proxyContext.region }),
-      ...(proxyContext.awsUser && { aws_user: proxyContext.awsUser }),
-    },
+    meta,
   }, traceCtx, config)
 
   reqCtx.inferredProxySpan = span

package/packages/dd-trace/src/plugins/util/status-validator.js

@@ -0,0 +1,98 @@
+'use strict'
+
+const log = require('../../log')
+
+const statusCodeRangesPattern = /^[1-5]\d{2}(?:-[1-5]\d{2})?(?:,[1-5]\d{2}(?:-[1-5]\d{2})?)*$/
+const whitespacePattern = /\s/g
+const MAX_HTTP_STATUS_CODE = 599
+
+const SERVER_ERROR_STATUSES = 'DD_TRACE_HTTP_SERVER_ERROR_STATUSES'
+const CLIENT_ERROR_STATUSES = 'DD_TRACE_HTTP_CLIENT_ERROR_STATUSES'
+
+/** @typedef {(code: number) => boolean} StatusValidator */
+
+/** @type {StatusValidator} */
+function isNotServerErrorCode (code) {
+  return code < 500
+}
+
+/** @type {StatusValidator} */
+function isNotClientErrorCode (code) {
+  return code < 400 || code >= 500
+}
+
+/**
+ * @param {{ validateStatus?: unknown, DD_TRACE_HTTP_SERVER_ERROR_STATUSES?: unknown }} config
+ * @returns {StatusValidator}
+ */
+function getServerStatusValidator (config) {
+  return getStatusValidator(config, SERVER_ERROR_STATUSES, '500-599', isNotServerErrorCode)
+}
+
+/**
+ * @param {{ validateStatus?: unknown, DD_TRACE_HTTP_CLIENT_ERROR_STATUSES?: unknown }} config
+ * @returns {StatusValidator}
+ */
+function getClientStatusValidator (config) {
+  return getStatusValidator(config, CLIENT_ERROR_STATUSES, '400-499', isNotClientErrorCode)
+}
+
+/**
+ * @param {Record<string, unknown>} config
+ * @param {string} optionName - Name of the configuration holding the error status ranges.
+ * @param {string} defaultRanges - Ranges covered by `defaultValidator`
+ * @param {StatusValidator} defaultValidator
+ * @returns {StatusValidator}
+ */
+function getStatusValidator (config, optionName, defaultRanges, defaultValidator) {
+  if (typeof config.validateStatus === 'function') {
+    return /** @type {StatusValidator} */ (config.validateStatus)
+  } else if (Object.hasOwn(config, 'validateStatus')) {
+    log.error('Expected `validateStatus` to be a function.')
+  }
+
+  const ranges = config[optionName]
+  if (ranges === undefined) return defaultValidator
+  if (typeof ranges !== 'string') {
+    log.error('Expected `%s` to be a string.', optionName)
+    return defaultValidator
+  }
+  if (ranges === defaultRanges) return defaultValidator
+
+  const normalized = ranges.replaceAll(whitespacePattern, '')
+  if (normalized === defaultRanges) return defaultValidator
+  if (!statusCodeRangesPattern.test(normalized)) {
+    log.error('`%s` must contain comma-separated status codes or ranges from 100 to 599.', optionName)
+    return defaultValidator
+  }
+
+  const errorStatusCodes = new Uint8Array(MAX_HTTP_STATUS_CODE + 1)
+  for (const range of normalized.split(',')) {
+    const separator = range.indexOf('-')
+    if (separator === -1) {
+      errorStatusCodes[Number(range)] = 1
+      continue
+    }
+
+    const first = Number(range.slice(0, separator))
+    const second = Number(range.slice(separator + 1))
+    const start = Math.min(first, second)
+    const end = Math.max(first, second)
+    errorStatusCodes.fill(1, start, end + 1)
+  }
+
+  /**
+   * @param {number} code
+   * @returns {boolean}
+   */
+  function isValidStatusCode (code) {
+    return errorStatusCodes[code] !== 1
+  }
+
+  return isValidStatusCode
+}
+
+module.exports = {
+  getClientStatusValidator,
+  getServerStatusValidator,
+}

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

@@ -108,6 +108,9 @@ const TEST_SOURCE_FILE = 'test.source.file'
 const TEST_SOURCE_START = 'test.source.start'
 const TEST_FAILURE_SCREENSHOT_UPLOADED = 'test.failure_screenshot.uploaded'
 const TEST_FAILURE_SCREENSHOT_UPLOAD_ERROR = 'test.failure_screenshot.upload_error'
+const TEST_FAILURE_VIDEO_UPLOADED = 'test.failure_video.uploaded'
+const TEST_FAILURE_VIDEO_UPLOAD_ERROR = 'test.failure_video.upload_error'
+const TEST_FAILURE_VIDEO_SCOPE = 'test.failure_video.scope'
 const LIBRARY_VERSION = 'library_version'
 const TEST_COMMAND = 'test.command'
 const TEST_MODULE = 'test.module'
@@ -127,7 +130,7 @@ const TEST_IS_MODIFIED = 'test.is_modified'
 const TEST_HAS_DYNAMIC_NAME = '_dd.has_dynamic_name'
 const CI_APP_ORIGIN = 'ciapp-test'
 // eslint-disable-next-line no-control-regex
-const TEST_OPTIMIZATION_NAME_CONTROL_RE = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g
+const TEST_OPTIMIZATION_NAME_CONTROL_RE = /[\u0000-\u0008\v\f\u000E-\u001F\u007F-\u009F]/g
 const TEST_OPTIMIZATION_NAME_WHITESPACE_RE = /\s+/g
 
 // Matches patterns that are almost certainly runtime-generated values in test names:
@@ -474,6 +477,9 @@ module.exports = {
   TEST_SOURCE_FILE,
   TEST_FAILURE_SCREENSHOT_UPLOADED,
   TEST_FAILURE_SCREENSHOT_UPLOAD_ERROR,
+  TEST_FAILURE_VIDEO_UPLOADED,
+  TEST_FAILURE_VIDEO_UPLOAD_ERROR,
+  TEST_FAILURE_VIDEO_SCOPE,
   CI_APP_ORIGIN,
   LIBRARY_VERSION,
   JEST_WORKER_TRACE_PAYLOAD_CODE,
@@ -541,6 +547,7 @@ module.exports = {
   getRelativeCoverageFiles,
   getLineCoverageBitmap,
   applySkippedCoverageToCoverage,
+  getTestCoverageLinesData,
   getTestCoverageLinesPercentage,
   resetCoverage,
   mergeCoverage,
@@ -1359,6 +1366,34 @@ function getLineCoverageBitmap (lineCoverage, onlyCoveredLines = false) {
   return bitmap
 }
 
+function getLineCoverageBitmaps (lineCoverage) {
+  let maxLine = 0
+  const entries = Object.entries(lineCoverage)
+
+  for (const [line] of entries) {
+    const lineNumber = Number(line)
+    if (Number.isSafeInteger(lineNumber) && lineNumber > maxLine) {
+      maxLine = lineNumber
+    }
+  }
+  if (maxLine === 0) return {}
+
+  const length = Math.ceil((maxLine + 1) / 8)
+  const coveredBitmap = Buffer.alloc(length)
+  const executableBitmap = Buffer.alloc(length)
+  for (const [line, hits] of entries) {
+    const lineNumber = Number(line)
+    if (!Number.isSafeInteger(lineNumber) || lineNumber <= 0) continue
+
+    const byteIndex = lineNumber >> 3
+    const bit = 1 << (lineNumber % 8)
+    executableBitmap[byteIndex] |= bit
+    if (hits) coveredBitmap[byteIndex] |= bit
+  }
+
+  return { coveredBitmap, executableBitmap }
+}
+
 function mergeCoverageBitmaps (targetBitmap, bitmap) {
   if (!targetBitmap) {
     return Buffer.from(bitmap)
@@ -1419,16 +1454,6 @@ function getCoverageFileBitmap (bitmap) {
   }
 }
 
-function addCoverageFilesToMap (files, targetMap, rootDir) {
-  for (const file of files) {
-    const bitmap = getCoverageFileBitmap(file.bitmap)
-    if (!bitmap) continue
-
-    const filename = rootDir ? getTestSuitePath(file.filename, rootDir) : file.filename
-    targetMap.set(filename, mergeCoverageBitmaps(targetMap.get(filename), bitmap))
-  }
-}
-
 function addSkippedCoverageToMap (skippedCoverage, targetMap) {
   if (!skippedCoverage) return
 
@@ -1439,23 +1464,57 @@ function addSkippedCoverageToMap (skippedCoverage, targetMap) {
   }
 }
 
-function getTestCoverageLinesPercentage (coverage, skippedCoverage, rootDir) {
-  const executableLinesByFile = new Map()
-  const coveredLinesByFile = new Map()
+/**
+ * Calculates line coverage and optionally returns executable-line coverage files in the same traversal.
+ * @param {object} coverage
+ * @param {object} [skippedCoverage]
+ * @param {string} [rootDir]
+ * @param {boolean} [includeExecutableFiles]
+ * @returns {{ percentage: number, executableFiles?: Array<{ filename: string, bitmap: Buffer }> }}
+ */
+function getTestCoverageLinesData (coverage, skippedCoverage, rootDir, includeExecutableFiles = false) {
+  const coverageMap = getCoverageMap(coverage)
+  const skippedCoverageByFilename = getSkippedCoverageByFilename(skippedCoverage)
+  const coverageByFilename = new Map()
+  const executableFiles = includeExecutableFiles ? [] : undefined
 
-  addCoverageFilesToMap(getExecutableFilesFromCoverage(coverage), executableLinesByFile, rootDir)
-  addCoverageFilesToMap(getCoveredFilesFromCoverage(coverage), coveredLinesByFile, rootDir)
-  addSkippedCoverageToMap(skippedCoverage, coveredLinesByFile)
+  for (const filename of coverageMap.files()) {
+    const fileCoverage = coverageMap.fileCoverageFor(filename)
+    const { coveredBitmap, executableBitmap } = getLineCoverageBitmaps(fileCoverage.getLineCoverage())
+    if (!executableBitmap) continue
+
+    const relativeFilename = rootDir ? getTestSuitePath(filename, rootDir) : filename
+    const existingCoverage = coverageByFilename.get(relativeFilename)
+    if (existingCoverage) {
+      existingCoverage.coveredBitmap = mergeCoverageBitmaps(existingCoverage.coveredBitmap, coveredBitmap)
+      existingCoverage.executableBitmap = mergeCoverageBitmaps(existingCoverage.executableBitmap, executableBitmap)
+    } else {
+      coverageByFilename.set(relativeFilename, { coveredBitmap, executableBitmap })
+    }
+  }
 
   let totalExecutableLines = 0
   let totalCoveredLines = 0
-
-  for (const [filename, executableLines] of executableLinesByFile) {
-    totalExecutableLines += countBitmapBits(executableLines)
-    totalCoveredLines += countCoveredExecutableBits(coveredLinesByFile.get(filename), executableLines)
+  for (const [filename, { coveredBitmap, executableBitmap }] of coverageByFilename) {
+    const skippedBitmap = skippedCoverageByFilename.get(filename)
+    const combinedCoveredBitmap = skippedBitmap
+      ? mergeCoverageBitmaps(coveredBitmap, skippedBitmap)
+      : coveredBitmap
+    totalExecutableLines += countBitmapBits(executableBitmap)
+    totalCoveredLines += countCoveredExecutableBits(combinedCoveredBitmap, executableBitmap)
+    if (executableFiles) {
+      executableFiles.push({ filename, bitmap: executableBitmap })
+    }
   }
 
-  return totalExecutableLines === 0 ? 0 : Math.floor((totalCoveredLines / totalExecutableLines) * 10_000) / 100
+  const percentage = totalExecutableLines === 0
+    ? 0
+    : Math.floor((totalCoveredLines / totalExecutableLines) * 10_000) / 100
+  return { percentage, executableFiles }
+}
+
+function getTestCoverageLinesPercentage (coverage, skippedCoverage, rootDir) {
+  return getTestCoverageLinesData(coverage, skippedCoverage, rootDir).percentage
 }
 
 function isLineCoveredByBitmap (bitmap, line) {
@@ -1552,19 +1611,77 @@ function fromCoverageMapToCoverage (coverageMap) {
   }, {})
 }
 
+/**
+ * @param {number} code
+ * @returns {boolean}
+ */
+function isAsciiDigit (code) {
+  return code >= 0x30 && code <= 0x39
+}
+
+/**
+ * Parse a V8 stack frame into its file path and 1-based line number.
+ *
+ * Stack text includes caller-controlled function names and can be overwritten. Scan numeric suffixes
+ * right-to-left and discard V8's trailing anonymous location for eval frames.
+ * @param {string} frame
+ * @param {string} expectedPath A known path contained in the frame.
+ * @returns {{ file: string, line: number } | null}
+ */
+function parseStackFrameLocation (frame, expectedPath) {
+  let pathStart = frame.lastIndexOf(expectedPath)
+  while (frame.charCodeAt(pathStart - 1) !== 0x28 /* ( */ &&
+        !frame.startsWith('at ', pathStart - 3) &&
+        !frame.startsWith('file://', pathStart - 7)) {
+    const previousPathStart = frame.lastIndexOf(expectedPath, pathStart - 1)
+    if (previousPathStart === -1) break
+    pathStart = previousPathStart
+  }
+  const scope = frame.slice(pathStart)
+  let end = scope.length
+  if (scope.charCodeAt(end - 1) === 0x29 /* ) */) end--
+
+  while (true) {
+    let lastNumberStart = end
+    while (lastNumberStart > 0 && isAsciiDigit(scope.charCodeAt(lastNumberStart - 1))) {
+      lastNumberStart--
+    }
+    if (lastNumberStart === end || scope.charCodeAt(lastNumberStart - 1) !== 0x3A /* : */) {
+      return null
+    }
+    const colonBeforeLast = lastNumberStart - 1
+    let lineStart = colonBeforeLast
+    while (lineStart > 0 && isAsciiDigit(scope.charCodeAt(lineStart - 1))) {
+      lineStart--
+    }
+    if (lineStart < colonBeforeLast && scope.charCodeAt(lineStart - 1) === 0x3A /* : */) {
+      const fileEnd = lineStart - 1
+      const anonymousStart = fileEnd - 11
+      if (scope.charCodeAt(fileEnd - 1) === 0x3E /* > */ && anonymousStart >= 3 &&
+          scope.startsWith('<anonymous>', anonymousStart) &&
+          scope.charCodeAt(anonymousStart - 1) === 0x20 /* space */ &&
+          scope.charCodeAt(anonymousStart - 2) === 0x2C /* , */ &&
+          scope.charCodeAt(anonymousStart - 3) === 0x29 /* ) */) {
+        end = anonymousStart - 3
+        while (scope.charCodeAt(end - 1) === 0x29 /* ) */) end--
+        continue
+      }
+      return { file: scope.slice(0, fileEnd), line: Number(scope.slice(lineStart, colonBeforeLast)) }
+    }
+    return { file: scope.slice(0, colonBeforeLast), line: Number(scope.slice(lastNumberStart, end)) }
+  }
+}
+
 // Get the start line of a test by inspecting a given error's stack trace
 function getTestLineStart (err, testSuitePath) {
   if (!err.stack) {
     return null
   }
-  // From https://github.com/felixge/node-stack-trace/blob/ba06dcdb50d465cd440d84a563836e293b360427/index.js#L40
   const testFileLine = err.stack.split('\n').find(line => line.includes(testSuitePath))
-  try {
-    const testFileLineMatch = testFileLine.match(/at (?:(.+?)\s+\()?(?:(.+?):(\d+)(?::(\d+))?|([^)]+))\)?/)
-    return Number.parseInt(testFileLineMatch[3], 10) || null
-  } catch {
+  if (!testFileLine) {
     return null
   }
+  return parseStackFrameLocation(testFileLine, testSuitePath)?.line || null
 }
 
 // Get the end line of a test by inspecting a given function's source code
@@ -1587,7 +1704,7 @@ function parseAnnotations (annotations) {
     }
     const { type, description } = annotation
     if (type.startsWith('DD_TAGS')) {
-      const regex = /\[(.*?)\]/
+      const regex = /^DD_TAGS\[([^\]]*)\]/
       const match = regex.exec(type)
       let tagValue = ''
       if (match) {
@@ -1691,15 +1808,9 @@ function getFileAndLineNumberFromError (error, repositoryRoot) {
   }
 
   const topFrame = frames[topRelevantFrameIndex]
-  // Regular expression to match the file path, line number, and column number
-  const regex = /\s*at\s+(?:.*\()?(.+):(\d+):(\d+)\)?/
-  const match = topFrame.match(regex)
-
-  if (match) {
-    const filePath = match[1]
-    const lineNumber = Number(match[2])
-
-    return [filePath, lineNumber, topRelevantFrameIndex]
+  const location = parseStackFrameLocation(topFrame, repositoryRoot)
+  if (location) {
+    return [location.file, location.line, topRelevantFrameIndex]
   }
   return []
 }
@@ -2029,12 +2140,17 @@ function formatTestOptimizationList (items) {
   const more = items.length - shown.length
   const moreSuffix = more > 0 ? `\n  ... and ${more} more` : ''
 
-  return shown
-    .map(({ text, suffix }) => `  • ${truncateTestOptimizationNameMiddle(
+  let formattedItems = ''
+  let isFirstItem = true
+  for (const { text, suffix } of shown) {
+    if (!isFirstItem) formattedItems += '\n'
+    formattedItems += `  • ${truncateTestOptimizationNameMiddle(
       sanitizeTestOptimizationName(text),
       MAX_TEST_OPTIMIZATION_NAME_LENGTH
-    )}${suffix ? ` (${suffix})` : ''}`)
-    .join('\n') + moreSuffix
+    )}${suffix ? ` (${suffix})` : ''}`
+    isFirstItem = false
+  }
+  return formattedItems + moreSuffix
 }
 
 /**

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

@@ -14,7 +14,7 @@ const INT_SEGMENT = /^[1-9][0-9]+$/ // Integer of size at least 2 (>=10)
 const INT_ID_SEGMENT = /^(?=.*[0-9])[0-9._-]{3,}$/ // Mixed string with digits and delimiters
 const HEX_SEGMENT = /^(?=.*[0-9])[A-Fa-f0-9]{6,}$/ // Hexadecimal digits of size at least 6 with at least one decimal digit
 const HEX_ID_SEGMENT = /^(?=.*[0-9])[A-Fa-f0-9._-]{6,}$/ // Mixed string with hex digits and delimiters
-const STRING_SEGMENT = /(?:^.{20,}|[%&'()*+,:=@])/ // Long string or a string containing special characters
+const SPECIAL_CHARACTER_SEGMENT = /[%&'()*+,:=@]/
 
 /**
  * Extract full URL from HTTP request
@@ -167,7 +167,7 @@ function calculateHttpEndpoint (url) {
 
     if (HEX_ID_SEGMENT.test(element)) return '{param:hex_id}'
 
-    if (STRING_SEGMENT.test(element)) return '{param:str}'
+    if (element.length >= 20 || SPECIAL_CHARACTER_SEGMENT.test(element)) return '{param:str}'
 
     // No match
     return element