dd-trace 5.100.0 → 5.102.0

package/packages/dd-trace/src/opentracing/propagation/text_map.js

@@ -69,6 +69,12 @@ const percentByte = /%([0-9A-Fa-f]{2})/g
 class TextMapPropagator {
   #extractB3Context
 
+  /** @type {Set<string> | undefined} Cached `Set` view of `_config.baggageTagKeys`. */
+  #baggageTagKeysSet
+
+  /** @type {string[] | undefined} Source array that `#baggageTagKeysSet` was built from. */
+  #baggageTagKeysSetSource
+
   constructor (config) {
     this._config = config
 
@@ -78,6 +84,23 @@ class TextMapPropagator {
     this.#extractB3Context = envName === 'OTEL_PROPAGATORS' ? this._extractB3SingleContext : this._extractB3MultiContext
   }
 
+  /**
+   * Returns a `Set` view of `_config.baggageTagKeys` that is rebuilt only
+   * when the source array reference changes. Avoids an `O(n)` `Set` alloc
+   * per baggage extract (which is per-request when baggage propagation is
+   * enabled).
+   *
+   * @returns {Set<string>}
+   */
+  #getBaggageTagKeysSet () {
+    const source = this._config.baggageTagKeys
+    if (this.#baggageTagKeysSetSource !== source) {
+      this.#baggageTagKeysSet = new Set(source)
+      this.#baggageTagKeysSetSource = source
+    }
+    return this.#baggageTagKeysSet
+  }
+
   inject (spanContext, carrier) {
     if (!carrier) return
     this._injectBaggageItems(spanContext, carrier)
@@ -174,14 +197,14 @@ class TextMapPropagator {
 
       const baggageItems = getAllBaggageItems()
       if (!baggageItems) return
-      for (const [key, value] of Object.entries(baggageItems)) {
+      for (const key of Object.keys(baggageItems)) {
         const baggageKey = key.trim()
         if (!baggageTokenExpr.test(baggageKey)) continue
 
         // Do not trim values. If callers include leading/trailing whitespace, it must be percent-encoded.
         // W3C list-member allows optional properties after ';'.
         // https://www.w3.org/TR/baggage/#header-content
-        const item = `${baggageKey}=${encodeURIComponent(value)},`
+        const item = `${baggageKey}=${encodeURIComponent(baggageItems[key])},`
         itemCounter += 1
         byteCounter += item.length
 
@@ -218,14 +241,15 @@ class TextMapPropagator {
 
     const tags = []
 
-    for (const key in trace.tags) {
-      if (!trace.tags[key] || !key.startsWith('_dd.p.')) continue
-      if (!this._validateTagKey(key) || !this._validateTagValue(trace.tags[key])) {
+    for (const key of Object.keys(trace.tags)) {
+      const value = trace.tags[key]
+      if (!value || !key.startsWith('_dd.p.')) continue
+      if (!this._validateTagKey(key) || !this._validateTagValue(value)) {
         log.error('Trace tags from span are invalid, skipping injection.')
         return
       }
 
-      tags.push(`${key}=${trace.tags[key]}`)
+      tags.push(`${key}=${value}`)
     }
 
     const header = tags.join(',')
@@ -275,7 +299,7 @@ class TextMapPropagator {
     const {
       _sampling: { priority, mechanism },
       _tracestate: ts = new TraceState(),
-      _trace: { origin, tags },
+      _trace: { origin, tags: traceTags },
     } = spanContext
 
     carrier[traceparentKey] = spanContext.toTraceparent()
@@ -297,21 +321,22 @@ class TextMapPropagator {
       if (typeof origin === 'string') {
         const originValue = origin
           .replaceAll(tracestateOriginFilter, '_')
-          .replaceAll(/[\x3D]/g, '~')
+          .replaceAll('=', '~')
 
         state.set('o', originValue)
       }
 
-      for (const key in tags) {
-        if (!tags[key] || !key.startsWith('_dd.p.')) continue
+      for (const key of Object.keys(traceTags)) {
+        const tagValueRaw = traceTags[key]
+        if (!tagValueRaw || !key.startsWith('_dd.p.')) continue
 
         const tagKey = 't.' + key.slice(6)
           .replaceAll(tracestateTagKeyFilter, '_')
 
-        const tagValue = tags[key]
+        const tagValue = tagValueRaw
           .toString()
           .replaceAll(tracestateTagValueFilter, '_')
-          .replaceAll(/[\x3D]/g, '~')
+          .replaceAll('=', '~')
 
         state.set(tagKey, tagValue)
       }
@@ -410,9 +435,11 @@ class TextMapPropagator {
     }
 
     if (this._config.DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT === 'ignore') {
-      context._links = []
+      // `context` is null when no extractor matched; the fallback below picks up
+      // the SQSD context if present, otherwise the request runs untraced.
+      if (context) context._links = []
     } else {
-      if (this._config.DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT === 'restart') {
+      if (this._config.DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT === 'restart' && context) {
         context._links = []
         context._links.push({
           context,
@@ -503,14 +530,19 @@ class TextMapPropagator {
 
   _extractTraceparentContext (carrier) {
     const headerValue = carrier[traceparentKey]
-    if (!headerValue) {
+    if (typeof headerValue !== 'string') {
       return null
     }
     const matches = headerValue.trim().match(traceparentExpr)
-    if (matches?.length) {
-      const [version, traceId, spanId, flags, tail] = matches.slice(1)
+    if (matches !== null) {
+      const [, version, traceId, spanId, flags, tail] = matches
       const traceparent = { version }
-      const tracestate = TraceState.fromString(carrier.tracestate)
+      // W3C Trace Context §3.3.1.1: multiple tracestate fields MUST be combined per RFC 7230 §3.2.2.
+      // `filter` drops non-string members (Symbol, throwing-toString) that would crash `join`.
+      const rawTracestate = Array.isArray(carrier.tracestate)
+        ? carrier.tracestate.filter(item => typeof item === 'string').join(',')
+        : carrier.tracestate
+      const tracestate = TraceState.fromString(rawTracestate)
       if (invalidSegment.test(traceId)) return null
       if (invalidSegment.test(spanId)) return null
 
@@ -524,7 +556,7 @@ class TextMapPropagator {
         traceId: id(traceId, 16),
         spanId: id(spanId, 16),
         isRemote: true,
-        sampling: { priority: Number.parseInt(flags, 10) & 1 ? 1 : 0 },
+        sampling: { priority: Number.parseInt(flags, 16) & 1 ? 1 : 0 },
         traceparent,
         tracestate,
       })
@@ -550,7 +582,7 @@ class TextMapPropagator {
               break
             }
             case 'o':
-              spanContext._trace.origin = value
+              spanContext._trace.origin = value.replaceAll('~', '=')
               break
             case 't.dm': {
               const mechanism = Math.abs(Number.parseInt(value, 10))
@@ -563,7 +595,7 @@ class TextMapPropagator {
             default: {
               if (!key.startsWith('t.')) continue
               const subKey = key.slice(2) // e.g. t.tid -> tid
-              const transformedValue = value.replaceAll(/[\x7E]/gm, '=')
+              const transformedValue = value.replaceAll('~', '=')
 
               // If subkey is tid  then do nothing because trace header tid should always be preserved
               if (subKey === 'tid') {
@@ -681,7 +713,7 @@ class TextMapPropagator {
     if (!header) return
 
     const baggages = header.split(',')
-    const baggageTagKeys = new Set(this._config.baggageTagKeys)
+    const baggageTagKeys = this.#getBaggageTagKeysSet()
     const tagAllKeys = baggageTagKeys.has('*')
     /** @type {Record<string, string> | undefined} */
     let items
@@ -721,11 +753,17 @@ class TextMapPropagator {
         tracerMetrics.count('context_header_style.malformed', ['header_style:baggage']).inc()
         return
       }
-      try {
-        value = decodeURIComponent(value)
-      } catch {
-        const bytes = value.replaceAll(percentByte, (_, hex) => String.fromCharCode(Number.parseInt(hex, 16)))
-        value = Buffer.from(bytes, 'binary').toString('utf8')
+      // `decodeURIComponent` only does work when the value contains a
+      // percent-encoded sequence; everything else passes through unchanged.
+      // Skipping the call (and the surrounding `try` frame) shaves an alloc
+      // per baggage entry on the dominant ASCII case.
+      if (value.includes('%')) {
+        try {
+          value = decodeURIComponent(value)
+        } catch {
+          const bytes = value.replaceAll(percentByte, (_, hex) => String.fromCharCode(Number.parseInt(hex, 16)))
+          value = Buffer.from(bytes, 'binary').toString('utf8')
+        }
       }
       items ??= {}
       items[key] = value

package/packages/dd-trace/src/opentracing/propagation/text_map_dsm.js

@@ -16,7 +16,7 @@ class DSMTextMapPropagator {
   inject (ctx, carrier) {
     if (!this.config.dsmEnabled) return
 
-    this._injectDatadogDSMContext(ctx, carrier)
+    DsmPathwayCodec.encode(ctx, carrier)
 
     // eslint-disable-next-line eslint-rules/eslint-log-printf-style
     log.debug(() => `Inject into carrier (DSM): ${JSON.stringify(pick(carrier, logKeys))}.`)
@@ -25,7 +25,7 @@ class DSMTextMapPropagator {
   extract (carrier) {
     if (!this.config.dsmEnabled) return
 
-    const dsmContext = this._extractDatadogDSMContext(carrier)
+    const dsmContext = DsmPathwayCodec.decode(carrier)
 
     if (!dsmContext) return dsmContext
 
@@ -33,15 +33,6 @@ class DSMTextMapPropagator {
     log.debug(() => `Extract from carrier (DSM): ${JSON.stringify(pick(carrier, logKeys))}.`)
     return dsmContext
   }
-
-  _injectDatadogDSMContext (ctx, carrier) {
-    DsmPathwayCodec.encode(ctx, carrier)
-  }
-
-  _extractDatadogDSMContext (carrier) {
-    const ctx = DsmPathwayCodec.decode(carrier)
-    return ctx
-  }
 }
 
 module.exports = DSMTextMapPropagator

package/packages/dd-trace/src/opentracing/propagation/tracestate.js

@@ -15,8 +15,7 @@ const WHITESPACE = /[ \t]/
  * @returns {[string, string][]} Entries in reverse of wire order.
  */
 function parseEntries (value, fieldSeparator, pairSeparator, rejectValueTabs) {
-  const segments = value.split(fieldSeparator)
-  segments.length = Math.min(segments.length, MAX_LIST_MEMBERS)
+  const segments = value.split(fieldSeparator, MAX_LIST_MEMBERS)
 
   // TODO: We should extract dd no matter at what position and move it to the front of the list.
   // Extract up 31 additional entries.
@@ -57,28 +56,45 @@ function toString (map, pairSeparator, fieldSeparator) {
   return result
 }
 
-class TraceStateData extends Map {
-  constructor (...args) {
-    super(...args)
-    this.changed = false
+class TraceStateData {
+  #map
+  changed = false
+
+  constructor (entries) {
+    this.#map = entries ? new Map(entries) : new Map()
   }
 
-  set (...args) {
-    if (this.has(args[0]) && this.get(args[0]) === args[1]) {
-      return
-    }
+  set (key, value) {
+    if (this.#map.get(key) === value && (value !== undefined || this.#map.has(key))) return this
     this.changed = true
-    return super.set(...args)
+    this.#map.set(key, value)
+    return this
   }
 
-  delete (...args) {
+  get (key) {
+    return this.#map.get(key)
+  }
+
+  delete (key) {
     this.changed = true
-    return super.delete(...args)
+    return this.#map.delete(key)
   }
 
-  clear (...args) {
+  clear () {
     this.changed = true
-    return super.clear(...args)
+    this.#map.clear()
+  }
+
+  entries () {
+    return this.#map.entries()
+  }
+
+  [Symbol.iterator] () {
+    return this.#map[Symbol.iterator]()
+  }
+
+  get size () {
+    return this.#map.size
   }
 
   static fromString (value) {
@@ -94,25 +110,45 @@ class TraceStateData extends Map {
  * Pairs are stored in reverse of the serialized format to rely on set ordering
  * new entries at the end to express update movement.
  */
-class TraceState extends Map {
+class TraceState {
+  #map
+
+  constructor (entries) {
+    this.#map = entries ? new Map(entries) : new Map()
+  }
+
   // Delete entries on update to ensure they're moved to the end of the list
   set (key, value) {
-    if (this.has(key)) {
-      this.delete(key)
-    }
+    if (this.#map.has(key)) this.#map.delete(key)
+    this.#map.set(key, value)
+    return this
+  }
+
+  get (key) {
+    return this.#map.get(key)
+  }
+
+  delete (key) {
+    return this.#map.delete(key)
+  }
+
+  [Symbol.iterator] () {
+    return this.#map[Symbol.iterator]()
+  }
 
-    return super.set(key, value)
+  get size () {
+    return this.#map.size
   }
 
   forVendor (vendor, handle) {
-    const data = super.get(vendor)
+    const data = this.#map.get(vendor)
     const state = TraceStateData.fromString(data)
     const result = handle(state)
 
     if (state.changed) {
       const value = state.toString()
       if (value) {
-        this.set(vendor, state.toString())
+        this.set(vendor, value)
       } else {
         this.delete(vendor)
       }

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

@@ -11,21 +11,16 @@ const runtimeMetrics = require('../runtime_metrics')
 const log = require('../log')
 const { storage } = require('../../../datadog-core')
 const telemetryMetrics = require('../telemetry/metrics')
-const { getValueFromEnvSources } = require('../config/helper')
-const { isTrue } = require('../util')
 const SpanContext = require('./span_context')
 
 const dateNow = Date.now
 
 const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
 
-const DD_TRACE_EXPERIMENTAL_STATE_TRACKING = isTrue(getValueFromEnvSources('DD_TRACE_EXPERIMENTAL_STATE_TRACKING'))
-const DD_TRACE_EXPERIMENTAL_SPAN_COUNTS = isTrue(getValueFromEnvSources('DD_TRACE_EXPERIMENTAL_SPAN_COUNTS'))
-
 const unfinishedRegistry = createRegistry('unfinished')
 const finishedRegistry = createRegistry('finished')
 
-const OTEL_ENABLED = !!getValueFromEnvSources('DD_TRACE_OTEL_ENABLED')
+let OTEL_ENABLED = false
 const ALLOWED = new Set(['string', 'number', 'boolean'])
 
 const integrationCounters = {
@@ -37,6 +32,25 @@ const startCh = channel('dd-trace:span:start')
 const finishCh = channel('dd-trace:span:finish')
 const tagsUpdateCh = channel('dd-trace:span:tags:update')
 
+// Module-scope so we don't allocate a fresh recursive closure on every
+// `addLink` / `addEvent`.
+/**
+ * @param {Record<string, string>} out
+ * @param {string} key
+ * @param {unknown} value
+ */
+function addArrayOrScalarAttribute (out, key, value) {
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      addArrayOrScalarAttribute(out, `${key}.${i}`, value[i])
+    }
+  } else if (ALLOWED.has(typeof value)) {
+    out[key] = typeof value === 'string' ? value : String(value)
+  } else {
+    log.warn('Dropping span link attribute. It is not of an allowed type')
+  }
+}
+
 function getIntegrationCounter (event, integration) {
   const counters = integrationCounters[event]
 
@@ -55,15 +69,22 @@ function getIntegrationCounter (event, integration) {
 }
 
 class DatadogSpan {
+  #parentTracer
+
   constructor (tracer, processor, prioritySampler, fields, debug) {
+    OTEL_ENABLED = tracer._config.DD_TRACE_OTEL_ENABLED
+
     const operationName = fields.operationName
     const parent = fields.parent || null
-    // TODO(BridgeAR): Investigate why this is causing a performance regression
+    // Stay on `Object.assign({}, src)` for backportability: V8 12+ (Node 22 /
+    // 24) inlines `{ ...src }` and beats `Object.assign` here, but on V8 10.2
+    // / 11.3 (Node 18 / 20) the spread takes a generic runtime path and slows
+    // `spans-finish-*` by ~140%. Revisit once those LTS lines drop.
     // eslint-disable-next-line prefer-object-spread
     const tags = Object.assign({}, fields.tags)
     const hostname = fields.hostname
 
-    this._parentTracer = tracer
+    this.#parentTracer = tracer
     this._debug = debug
     this._processor = processor
     this._prioritySampler = prioritySampler
@@ -94,7 +115,7 @@ class DatadogSpan {
       attributes: this._sanitizeAttributes(link.attributes),
     })) ?? []
 
-    if (DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
+    if (this.#parentTracer._config.DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
       runtimeMetrics.increment('runtime.node.spans.unfinished')
       runtimeMetrics.increment('runtime.node.spans.unfinished.by.name', `span_name:${operationName}`)
 
@@ -104,16 +125,8 @@ class DatadogSpan {
       unfinishedRegistry.register(this, operationName, this)
     }
 
-    // Nullish operator is used here because both `tracer` and `tracer._config`
-    // can be null and there are tests passing invalid values to the `Span`
-    // constructor which still succeed today. Part of the problem is that `Span`
-    // stores only the tracer and not the config, so anything that needs the
-    // config has to read it from the tracer stored on the span, including
-    // even `Span` itself in this case.
-    //
-    // TODO: Refactor Tracer/Span + tests to avoid having to do nullish checks.
-    if (tracer?._config?.DD_TRACE_SPAN_LEAK_DEBUG > 0) {
-      require('../spanleak').addSpan(this, operationName)
+    if (tracer._config.DD_TRACE_SPAN_LEAK_DEBUG > 0) {
+      require('../spanleak').addSpan(this)
     }
 
     if (startCh.hasSubscribers) {
@@ -124,7 +137,7 @@ class DatadogSpan {
   [util.inspect.custom] () {
     return {
       ...this,
-      _parentTracer: `[${this._parentTracer.constructor.name}]`,
+      parentTracer: `[${this.#parentTracer.constructor.name}]`,
       _prioritySampler: `[${this._prioritySampler.constructor.name}]`,
       _processor: `[${this._processor.constructor.name}]`,
     }
@@ -156,7 +169,7 @@ class DatadogSpan {
   }
 
   tracer () {
-    return this._parentTracer
+    return this.#parentTracer
   }
 
   setOperationName (name) {
@@ -254,14 +267,14 @@ class DatadogSpan {
       return
     }
 
-    if (DD_TRACE_EXPERIMENTAL_STATE_TRACKING && !this._spanContext._tags['service.name']) {
+    if (this.#parentTracer._config.DD_TRACE_EXPERIMENTAL_STATE_TRACKING && !this._spanContext._tags['service.name']) {
       log.error('Finishing invalid span: %s', this)
     }
 
     getIntegrationCounter('spans_finished', this._integrationName).inc()
     this._spanContext._tags['_dd.integration'] = this._integrationName
 
-    if (DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
+    if (this.#parentTracer._config.DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
       runtimeMetrics.decrement('runtime.node.spans.unfinished')
       runtimeMetrics.decrement('runtime.node.spans.unfinished.by.name', `span_name:${this._name}`)
       runtimeMetrics.increment('runtime.node.spans.finished')
@@ -274,7 +287,11 @@ class DatadogSpan {
       finishedRegistry.register(this, this._name)
     }
 
-    finishTime = Number.parseFloat(finishTime) || this._getTime()
+    // Dominant call site is `span.finish()` with no argument; skip the
+    // `Number.parseFloat` round-trip for the undefined case.
+    finishTime = finishTime === undefined
+      ? this._getTime()
+      : (Number.parseFloat(finishTime) || this._getTime())
 
     this._duration = finishTime - this._startTime
     this._spanContext._trace.finished.push(this)
@@ -283,38 +300,29 @@ class DatadogSpan {
     this._processor.process(this)
   }
 
+  /**
+   * @param {Record<string, unknown>} [attributes]
+   */
   _sanitizeAttributes (attributes = {}) {
-    const sanitizedAttributes = {}
-
-    const addArrayOrScalarAttributes = (key, maybeArray) => {
-      if (Array.isArray(maybeArray)) {
-        for (const subkey in maybeArray) {
-          addArrayOrScalarAttributes(`${key}.${subkey}`, maybeArray[subkey])
-        }
-      } else {
-        const maybeScalar = maybeArray
-        if (ALLOWED.has(typeof maybeScalar)) {
-          // Wrap the value as a string if it's not already a string
-          sanitizedAttributes[key] = typeof maybeScalar === 'string' ? maybeScalar : String(maybeScalar)
-        } else {
-          log.warn('Dropping span link attribute. It is not of an allowed type')
-        }
-      }
+    /** @type {Record<string, string>} */
+    const out = {}
+    for (const key of Object.keys(attributes)) {
+      addArrayOrScalarAttribute(out, key, attributes[key])
     }
-
-    for (const [key, value] of Object.entries(attributes)) {
-      addArrayOrScalarAttributes(key, value)
-    }
-    return sanitizedAttributes
+    return out
   }
 
+  /**
+   * @param {Record<string, unknown>} [attributes]
+   */
   _sanitizeEventAttributes (attributes = {}) {
     const sanitizedAttributes = {}
 
-    for (const [key, value] of Object.entries(attributes)) {
+    for (const key of Object.keys(attributes)) {
+      const value = attributes[key]
       if (Array.isArray(value)) {
         const newArray = []
-        for (const subvalue of Object.values(value)) {
+        for (const subvalue of value) {
           if (ALLOWED.has(typeof subvalue)) {
             newArray.push(subvalue)
           } else {
@@ -336,7 +344,7 @@ class DatadogSpan {
     let startTime
 
     let baggage = {}
-    const propagationBehavior = this._parentTracer?._config?.DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT
+    const propagationBehavior = this.#parentTracer._config.DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT
     if (parent && parent._isRemote && propagationBehavior !== 'continue') {
       baggage = parent._baggageItems
       parent = null

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

@@ -30,6 +30,7 @@ class DatadogSpanContext {
       tags: {},
     }
     this._otelSpanContext = undefined
+    this._otelActiveSpan = undefined
   }
 
   [util.inspect.custom] () {

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

@@ -650,7 +650,7 @@ module.exports = {
         [GIT_TAG]: BITBUCKET_TAG,
         [GIT_REPOSITORY_URL]: BITBUCKET_GIT_SSH_ORIGIN || BITBUCKET_GIT_HTTP_ORIGIN,
         [CI_WORKSPACE_PATH]: BITBUCKET_CLONE_DIR,
-        [CI_PIPELINE_ID]: BITBUCKET_PIPELINE_UUID && BITBUCKET_PIPELINE_UUID.replaceAll(/{|}/gm, ''),
+        [CI_PIPELINE_ID]: BITBUCKET_PIPELINE_UUID && BITBUCKET_PIPELINE_UUID.replaceAll(/[{}]/gm, ''),
         [GIT_PULL_REQUEST_BASE_BRANCH]: BITBUCKET_PR_DESTINATION_BRANCH,
         [PR_NUMBER]: BITBUCKET_PR_ID,
       }

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

@@ -53,14 +53,12 @@ function getCache (cacheKey) {
   try {
     const cacheFilePath = getCacheFilePath(cacheKey)
     if (!fs.existsSync(cacheFilePath)) {
-      return null
+      return
     }
 
-    const content = fs.readFileSync(cacheFilePath, 'utf8')
-    return content
+    return fs.readFileSync(cacheFilePath, 'utf8')
   } catch (err) {
     log.error('Failed to read git cache', err)
-    return null
   }
 }
 
@@ -87,7 +85,7 @@ function cachedExec (cmd, flags, options) {
   }
   const cacheKey = getCacheKey(cmd, flags)
   const cachedResult = getCache(cacheKey)
-  if (cachedResult !== null) {
+  if (cachedResult !== undefined) {
     if (cachedResult.startsWith('__GIT_COMMAND_FAILED__')) {
       let error
       try {

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

@@ -318,6 +318,7 @@ module.exports = {
   parseAnnotations,
   getIsFaultyEarlyFlakeDetection,
   getEfdRetryCount,
+  getMaxEfdRetryCount,
   TEST_BROWSER_DRIVER,
   TEST_BROWSER_DRIVER_VERSION,
   TEST_BROWSER_NAME,
@@ -922,9 +923,7 @@ function getCoveredFilenamesFromCoverage (coverage) {
     .filter(filename => {
       const fileCoverage = coverageMap.fileCoverageFor(filename)
       const lineCoverage = fileCoverage.getLineCoverage()
-      const isAnyLineExecuted = Object.entries(lineCoverage).some(([, numExecutions]) => !!numExecutions)
-
-      return isAnyLineExecuted
+      return Object.entries(lineCoverage).some(([, numExecutions]) => !!numExecutions)
     })
 }
 
@@ -1045,6 +1044,22 @@ function getEfdRetryCount (durationMs, slowTestRetries) {
   return 0 // ≥ 5 min — abort
 }
 
+/**
+ * Returns the maximum retry count configured by the backend for EFD.
+ *
+ * @param {Record<string, number>} slowTestRetries e.g. { '5s': 10, '10s': 5, '30s': 3, '5m': 2 }
+ * @returns {number}
+ */
+function getMaxEfdRetryCount (slowTestRetries) {
+  let maxRetries = 0
+  for (const retryCount of Object.values(slowTestRetries || {})) {
+    if (retryCount > maxRetries) {
+      maxRetries = retryCount
+    }
+  }
+  return maxRetries
+}
+
 function getIsFaultyEarlyFlakeDetection (projectSuites, testsBySuiteName, faultyThresholdPercentage) {
   let newSuites = 0
   for (const suite of projectSuites) {
@@ -1276,10 +1291,7 @@ function getPullRequestBaseBranch (pullRequestBaseBranch) {
   let bestScore = Infinity
   for (const branch of Object.keys(metrics)) {
     const score = metrics[branch].ahead
-    if (score < bestScore) {
-      bestScore = score
-      bestBranch = branch
-    } else if (score === bestScore && isDefaultBranch(branch)) {
+    if (score < bestScore || score === bestScore && isDefaultBranch(branch)) {
       bestScore = score
       bestBranch = branch
     }

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

@@ -108,11 +108,9 @@ function calculateHttpEndpoint (url) {
     return element
   })
 
-  const endpoint = normalizedElements.length > 0
+  return normalizedElements.length > 0
     ? '/' + normalizedElements.join('/')
     : '/'
-
-  return endpoint
 }
 
 function filterSensitiveInfoFromRepository (repositoryUrl) {