dd-trace 6.8.0 → 6.9.0

package/packages/dd-trace/src/llmobs/sdk.js

@@ -3,7 +3,6 @@
 const { channel } = require('dc-polyfill')
 
 const { isError } = require('../util')
-const tracerVersion = require('../../../../package.json').version
 const logger = require('../log')
 const { getValueFromEnvSources } = require('../config/helper')
 const Span = require('../opentracing/span')
@@ -13,6 +12,17 @@ const {
   INPUT_VALUE,
   TRACE_ID,
 } = require('./constants/tags')
+const {
+  FEEDBACK_METRIC_TYPES,
+  FEEDBACK_TARGET_KEYS,
+  buildMetricTags,
+  validateAssessment,
+  validateLabel,
+  validateMetricType,
+  validateMetricValue,
+  validateReasoning,
+  validateTimestamp,
+} = require('./eval-metric')
 const {
   getFunctionArguments,
   validateKind,
@@ -392,92 +402,35 @@ class LLMObs extends NoopLLMObs {
       }
 
       const timestampMs = options.timestampMs || Date.now()
-      if (typeof timestampMs !== 'number' || timestampMs < 0) {
-        err = 'invalid_timestamp'
-        throw new Error('timestampMs must be a non-negative integer. Evaluation metric data will not be sent')
-      }
+      validateTimestamp(timestampMs, 'evaluation')
 
       const { label, value, tags, reasoning, assessment, metadata } = options
       const metricType = options.metricType?.toLowerCase()
-      if (!label) {
-        err = 'invalid_metric_label'
-        throw new Error('label must be the specified name of the evaluation metric')
-      }
-      if (!metricType || !['categorical', 'score', 'boolean', 'json'].includes(metricType)) {
-        err = 'invalid_metric_type'
-        throw new Error('metricType must be one of "categorical", "score", "boolean" or "json"')
-      }
-      if (metricType === 'categorical' && typeof value !== 'string') {
-        err = 'invalid_metric_value'
-        throw new Error('value must be a string for a categorical metric.')
-      }
-      if (metricType === 'score' && typeof value !== 'number') {
-        err = 'invalid_metric_value'
-        throw new Error('value must be a number for a score metric.')
-      }
-      if (metricType === 'boolean' && typeof value !== 'boolean') {
-        err = 'invalid_metric_value'
-        throw new Error('value must be a boolean for a boolean metric')
-      }
-      if (metricType === 'json' && (typeof value !== 'object' || value == null || Array.isArray(value))) {
-        err = 'invalid_metric_value'
-        throw new Error('value must be a JSON object for a json metric')
-      }
-      if (assessment != null && assessment !== 'pass' && assessment !== 'fail') {
-        err = 'invalid_assessment'
-        throw new Error('assessment must be pass or fail')
-      }
-      if (reasoning != null && typeof reasoning !== 'string') {
-        err = 'invalid_reasoning'
-        throw new Error('reasoning must be a string')
-      }
+      const labelValue = validateLabel(label, 'evaluation')
+      validateMetricType(metricType, 'evaluation')
+      validateMetricValue(metricType, value)
+      validateAssessment(assessment)
+      validateReasoning(reasoning)
       if (metadata != null && (typeof metadata !== 'object' || Array.isArray(metadata))) {
         err = 'invalid_metadata'
         throw new Error('metadata must be a JSON object')
       }
 
-      const evaluationTags = {
-        'ddtrace.version': tracerVersion,
-        ml_app: mlApp,
-      }
-
-      if (tags) {
-        for (const key in tags) {
-          const tag = tags[key]
-          if (typeof tag === 'string') {
-            evaluationTags[key] = tag
-          } else if (typeof tag.toString === 'function') {
-            evaluationTags[key] = tag.toString()
-          } else if (tag == null) {
-            evaluationTags[key] = Object.prototype.toString.call(tag)
-          } else {
-            // should be a rare case
-            // every object in JS has a toString, otherwise every primitive has its own toString
-            // null and undefined are handled above
-            err = 'invalid_tags'
-            throw new Error('Failed to parse tags. Tags for evaluation metrics must be strings')
-          }
-        }
-      }
-
-      // When OTel tracing is enabled, add source:otel tag to allow backend to wait for OTel span conversion
-      if (this._config.DD_TRACE_OTEL_ENABLED) {
-        evaluationTags.source = 'otel'
-      }
-
       const payload = {
+        event_kind: 'evaluation',
         join_on: {
           span: {
             span_id: spanId,
             trace_id: traceId,
           },
         },
-        label,
+        label: labelValue,
         metric_type: metricType,
         ml_app: mlApp,
         [`${metricType}_value`]: value,
         timestamp_ms: timestampMs,
-        tags: Object.entries(evaluationTags).map(([key, value]) => `${key}:${value}`),
+        // When OTel tracing is enabled, `source:otel` lets the backend wait for OTel span conversion
+        tags: buildMetricTags(tags, mlApp, 'evaluation', this._config.DD_TRACE_OTEL_ENABLED),
       }
       if (reasoning != null) {
         payload.reasoning = reasoning
@@ -491,11 +444,139 @@ class LLMObs extends NoopLLMObs {
       const currentStore = storage.getStore()
       const routing = currentStore?.routingContext
       evalMetricAppendCh.publish({ payload, routing })
+    } catch (e) {
+      if (e.ddErrorTag) err = e.ddErrorTag
+      throw e
     } finally {
       telemetry.recordSubmitEvaluation(options, err)
     }
   }
 
+  /**
+   * Submits end-user feedback for a span, trace, session, or customer-defined entity.
+   *
+   * Exactly one target must be provided: `span` (as returned by `llmobs.exportSpan()`) or
+   * `spanId` to target a span, `traceId` a trace, `sessionId` a session, or `feedbackJoinKey`
+   * a customer-defined entity.
+   * `label`, `metricType`, `value` and `submitter` are required, and are validated at call time.
+   * @param {object} [options] - The feedback options.
+   * @param {string} [options.label] - The name of the feedback metric.
+   * @param {'categorical' | 'score' | 'boolean' | 'json' | 'text'} [options.metricType] - The value type.
+   * @param {string | number | boolean | Record<string, unknown>} [options.value] - The feedback value,
+   *   matching `metricType`.
+   * @param {{ id: string, type?: string }} [options.submitter] - Who submitted the feedback.
+   * @param {{ traceId: string, spanId: string }} [options.span] - Span context to attach the feedback to.
+   * @param {string} [options.spanId] - ID of the span to attach the feedback to.
+   * @param {string} [options.traceId] - ID of the trace to attach the feedback to.
+   * @param {string} [options.sessionId] - ID of the session to attach the feedback to.
+   * @param {string} [options.feedbackJoinKey] - Customer-defined key to attach the feedback to.
+   * @param {Record<string, string>} [options.tags] - Tags to attach to the feedback.
+   * @param {string} [options.mlApp] - The ML app name. Defaults to the configured one.
+   * @param {number} [options.timestampMs] - When the feedback was generated. Defaults to now.
+   * @param {'pass' | 'fail'} [options.assessment] - Assessment of the feedback.
+   * @param {string} [options.reasoning] - Explanation of the feedback.
+   * @returns {void}
+   */
+  submitFeedback (options = {}) {
+    if (!this.enabled) return
+
+    let err = ''
+    let targetType = 'other'
+    let metricTypeTag = 'other'
+    try {
+      const { span, spanId, traceId, sessionId, feedbackJoinKey, submitter } = options
+
+      // Resolved before any validation so telemetry still reports the metric type of a
+      // submission that fails on an unrelated field.
+      const metricType = options.metricType?.toLowerCase()
+      if (FEEDBACK_METRIC_TYPES.includes(metricType)) metricTypeTag = metricType
+
+      // The intake keys feedback off a single top-level identifier, so more than one target
+      // would be ambiguous and none would leave the feedback unattached. `span` also carries a
+      // traceId, but passing it is wire-equivalent to passing its `spanId` directly.
+      let targetName, targetValue
+      let targetCount = 0
+      if (span != null) { targetName = 'span'; targetValue = span.spanId; targetCount++ }
+      if (spanId != null) { targetName = 'spanId'; targetValue = spanId; targetCount++ }
+      if (traceId != null) { targetName = 'traceId'; targetValue = traceId; targetCount++ }
+      if (sessionId != null) { targetName = 'sessionId'; targetValue = sessionId; targetCount++ }
+      if (feedbackJoinKey != null) { targetName = 'feedbackJoinKey'; targetValue = feedbackJoinKey; targetCount++ }
+
+      if (targetCount !== 1) {
+        err = 'invalid_target_count'
+        throw new Error(
+          'Exactly one of `span`, `spanId`, `traceId`, `sessionId` or `feedbackJoinKey` ' +
+          'must be specified to submit feedback.'
+        )
+      }
+
+      targetType = FEEDBACK_TARGET_KEYS[targetName]
+      if (typeof targetValue !== 'string' || !targetValue) {
+        if (targetName === 'span') {
+          err = 'invalid_span'
+          throw new TypeError(
+            '`span` must be an object containing a non-empty string spanId. ' +
+            '`llmobs.exportSpan()` can be used to generate this object from a given span.'
+          )
+        }
+        err = `invalid_${targetType}`
+        throw new TypeError(`\`${targetName}\` must be a non-empty string`)
+      }
+
+      if (typeof submitter?.id !== 'string' || !submitter.id) {
+        err = 'invalid_submitter'
+        throw new TypeError('submitter must be an object containing a non-empty string id')
+      }
+      if (submitter.type != null && typeof submitter.type !== 'string') {
+        err = 'invalid_submitter'
+        throw new TypeError('submitter.type must be a string')
+      }
+
+      const mlApp = options.mlApp || this._config.llmobs.mlApp
+      if (!mlApp) {
+        err = 'missing_ml_app'
+        throw new Error('ML App name is required for sending feedback. Feedback data will not be sent.')
+      }
+
+      const timestampMs = options.timestampMs || Date.now()
+      validateTimestamp(timestampMs, 'feedback')
+
+      const { label, value, tags, reasoning, assessment } = options
+      const labelValue = validateLabel(label, 'feedback')
+      validateMetricType(metricType, 'feedback')
+      validateMetricValue(metricType, value)
+      validateAssessment(assessment)
+      validateReasoning(reasoning)
+
+      const payload = {
+        event_kind: 'feedback',
+        [targetType]: targetValue,
+        label: labelValue,
+        metric_type: metricType,
+        ml_app: mlApp,
+        [`${metricType}_value`]: value,
+        timestamp_ms: timestampMs,
+        tags: buildMetricTags(tags, mlApp, 'feedback'),
+        submitter: submitter.type == null ? { id: submitter.id } : { id: submitter.id, type: submitter.type },
+      }
+      if (reasoning != null) {
+        payload.reasoning = reasoning
+      }
+      if (assessment != null) {
+        payload.assessment = assessment
+      }
+
+      const currentStore = storage.getStore()
+      const routing = currentStore?.routingContext
+      evalMetricAppendCh.publish({ payload, routing })
+    } catch (e) {
+      if (e.ddErrorTag) err = e.ddErrorTag
+      throw e
+    } finally {
+      telemetry.recordSubmitFeedback(metricTypeTag, targetType, err)
+    }
+  }
+
   annotationContext (options, fn) {
     if (!this.enabled) return fn()
 

package/packages/dd-trace/src/llmobs/telemetry.js

@@ -183,6 +183,23 @@ function recordSubmitEvaluation (options, err, value = 1) {
   llmobsMetrics.count('evals_submitted', tags).inc(value)
 }
 
+/**
+ * @param {string} metricType - The submitted metric type, `'other'` if unrecognized.
+ * @param {string} targetType - The payload key the feedback was attached to, `'other'` if unresolved.
+ * @param {string} err - The telemetry error tag, empty when the submission succeeded.
+ * @param {number} [value]
+ * @returns {void}
+ */
+function recordSubmitFeedback (metricType, targetType, err, value = 1) {
+  const tags = {
+    error: Number(!!err),
+    metric_type: metricType,
+    target_type: targetType,
+  }
+  if (err) tags.error_type = err
+  llmobsMetrics.count('feedback_submitted', tags).inc(value)
+}
+
 function recordLLMObsUserProcessorCalled (error, value = 1) {
   const tags = { error: error ? 1 : 0 }
   llmobsMetrics.count('user_processor_called', tags).inc(value)
@@ -201,5 +218,6 @@ module.exports = {
   recordUserFlush,
   recordExportSpan,
   recordSubmitEvaluation,
+  recordSubmitFeedback,
   recordLLMObsUserProcessorCalled,
 }

package/packages/dd-trace/src/llmobs/writers/base.js

@@ -88,6 +88,9 @@ class BaseLLMObsWriter {
   }
 
   /**
+   * @param {Record<string, unknown>} event
+   * @param {{ apiKey?: string, site?: string }} [routing]
+   * @param {number} [byteLength]
    * @returns {boolean} `true` if the event was buffered, `false` if it was dropped
    * (e.g. the per-routing buffer was full). Callers that depend on the event
    * actually being submitted should check this value.

package/packages/dd-trace/src/llmobs/writers/util.js

@@ -7,6 +7,8 @@ const { fetchAgentInfo } = require('../../agent/info')
 
 /**
  * @param {import('../../config/config-base')} config
+ * @param {(agentless: boolean) => void} setWritersAgentlessValue
+ * @returns {void}
  */
 function setAgentStrategy (config, setWritersAgentlessValue) {
   const agentlessEnabled = config.llmobs.agentlessEnabled

package/packages/dd-trace/src/log/channels.js

@@ -2,15 +2,7 @@
 
 const { channel } = require('dc-polyfill')
 
-const Level = {
-  trace: 10,
-  debug: 20,
-  info: 30,
-  warn: 40,
-  error: 50,
-  critical: 50,
-  off: 100,
-}
+const Level = require('./levels')
 
 const traceChannel = channel('datadog:log:trace')
 const debugChannel = channel('datadog:log:debug')

package/packages/dd-trace/src/log/levels.js

@@ -0,0 +1,12 @@
+'use strict'
+
+// The guardrails logger requires this file, so it has to parse on Node.js 0.8.
+module.exports = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  critical: 50,
+  off: 100
+}

package/packages/dd-trace/src/openfeature/writers/exposures.js

@@ -63,7 +63,7 @@ class ExposuresWriter extends BaseFFEWriter {
    * @param {import('../../config/config-base')} config - Tracer configuration object
    */
   constructor (config) {
-    const basePath = EVP_PROXY_AGENT_BASE_PATH.replace(/\/+$/, '')
+    const basePath = EVP_PROXY_AGENT_BASE_PATH.replace(/\/$/, '')
     const endpoint = EXPOSURES_ENDPOINT.replace(/^\/+/, '')
     const fullEndpoint = `${basePath}/${endpoint}`
 

package/packages/dd-trace/src/openfeature/writers/util.js

@@ -18,7 +18,7 @@ function setAgentStrategy (config, setWriterEnabledValue) {
     }
 
     const endpoints = agentInfo.endpoints
-    const normalizedPath = EVP_PROXY_AGENT_BASE_PATH.replace(/\/+$/, '')
+    const normalizedPath = EVP_PROXY_AGENT_BASE_PATH.replace(/\/$/, '')
     const hasEndpoint = Array.isArray(endpoints) &&
       endpoints.includes(normalizedPath) || endpoints.includes(normalizedPath + '/')
 

package/packages/dd-trace/src/opentelemetry/logs/batch_log_processor.js

@@ -22,7 +22,7 @@ class BatchLogRecordProcessor {
   /**
    * Creates a new BatchLogRecordProcessor instance.
    *
-   * @param {OtlpHttpLogExporter} exporter - Log processor for exporting batches to Datadog Agent
+   * @param {import('./otlp_http_log_exporter')} exporter - Log processor for exporting batches to Datadog Agent
    * @param {number} batchTimeout - Timeout in milliseconds for batch processing
    * @param {number} maxExportBatchSize - Maximum number of log records per batch
    */

package/packages/dd-trace/src/opentelemetry/metrics/meter.js

@@ -9,6 +9,8 @@ const { METRIC_TYPES } = require('./constants')
 /**
  * @typedef {import('@opentelemetry/api').MetricOptions} MetricOptions
  * @typedef {import('@opentelemetry/core').InstrumentationScope} InstrumentationScope
+ * @typedef {Counter | UpDownCounter | Histogram | Gauge |
+ *   ObservableGauge | ObservableCounter | ObservableUpDownCounter} Instrument
  */
 
 /**
@@ -25,7 +27,7 @@ class Meter {
   /**
    * Creates a new Meter instance.
    *
-   * @param {MeterProvider} meterProvider - Parent meter provider
+   * @param {import('./meter_provider')} meterProvider - Parent meter provider
    * @param {InstrumentationScope} instrumentationScope - Instrumentation scope information
    * @param {string} [instrumentationScope.name] - Meter name (defaults to 'dd-trace-js')
    * @param {string} [instrumentationScope.version] - Meter version (defaults to tracer version)
@@ -50,11 +52,13 @@ class Meter {
    * Instruments are cached by type and normalized (lowercase) name.
    *
    *
+   * @template {Instrument} T
    * @param {string} name - Instrument name (will be normalized to lowercase)
    * @param {string} type - Instrument type (e.g., 'counter', 'histogram', 'gauge')
-   * @param {Function} InstrumentClass - Constructor for the instrument type
-   * @param {MetricOptions} [options] - Instrument options (description, unit, etc.)
-   * @returns {Instrument} The instrument instance (new or cached)
+   * @param {new (name: string, options: object, instrumentationScope: InstrumentationScope,
+   *   reader: object) => T} InstrumentClass - Constructor for the instrument type
+   * @param {MetricOptions} options - Instrument options (description, unit, etc.)
+   * @returns {T} The instrument instance (new or cached)
    */
   #getOrCreateInstrument (name, type, InstrumentClass, options) {
     const normalizedName = name.toLowerCase()

package/packages/dd-trace/src/opentelemetry/metrics/periodic_metric_reader.js

@@ -109,7 +109,7 @@ class PeriodicMetricReader {
   /**
    * Creates a new PeriodicMetricReader instance.
    *
-   * @param {OtlpHttpMetricExporter} exporter - Metric exporter for sending to Datadog Agent
+   * @param {import('./otlp_http_metric_exporter')} exporter - Metric exporter for sending to Datadog Agent
    * @param {number} exportInterval - Export interval in milliseconds
    * @param {string} temporalityPreference - Temporality preference: DELTA, CUMULATIVE, or LOWMEMORY
    * @param {number} maxBatchedQueueSize - Maximum number of measurements to queue before dropping

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

@@ -38,6 +38,10 @@ function hrTimeToMilliseconds (hrTime) {
 /**
  * Several of these attributes are not yet supported by the Node.js OTel API.
  * We check for old equivalents where we can, but not all had equivalents.
+ *
+ * @param {string | undefined} spanName
+ * @param {import('@opentelemetry/api').SpanKind} kind
+ * @param {import('@opentelemetry/api').Attributes} attributes
  */
 function spanNameMapper (spanName, kind, attributes) {
   if (spanName) return spanName

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

@@ -169,7 +169,7 @@ function getTestSuiteLevelVisibilityTags (testSuiteSpan, testFramework) {
 }
 
 /**
- * Keeps non-TIA settings while disabling suite skipping and coverage collection.
+ * Keeps non-TIA settings while disabling suite skipping and per-suite coverage collection.
  *
  * @param {object} libraryConfig
  * @returns {object}
@@ -178,7 +178,6 @@ function disableTestImpactAnalysis (libraryConfig) {
   return Object.freeze({
     ...libraryConfig,
     isCodeCoverageEnabled: false,
-    isCoverageReportUploadEnabled: false,
     isItrEnabled: false,
     isSuitesSkippingEnabled: false,
   })
@@ -260,6 +259,7 @@ module.exports = class CiPlugin extends Plugin {
         {
           ...this.testConfiguration,
           isCoverageReportUploadEnabled: this.libraryConfig?.isCoverageReportUploadEnabled,
+          isLineCoverageSupported: this.constructor.id !== 'vitest',
         },
         (err, skippableSuites, itrCorrelationId, skippableSuitesCoverage) => {
           if (err) {
@@ -461,12 +461,28 @@ module.exports = class CiPlugin extends Plugin {
         this.tracer._exporter.exportDiLogs(this.testEnvironmentMetadata, logMessage)
       }
     })
+
+    this.addSub(`ci:${this.constructor.id}:worker-report:telemetry`, data => {
+      const telemetryEvents = JSON.parse(data)
+      for (const event of telemetryEvents) {
+        if (event.type === 'ciVisEvent') {
+          this.telemetry.ciVisEvent(event.name, event.testLevel, {
+            ...event.tags,
+            testFramework: event.testFramework,
+            isUnsupportedCIProvider: event.isUnsupportedCIProvider,
+          })
+        } else if (event.type === 'count') {
+          this.telemetry.count(event.name, event.tags, event.value)
+        } else if (event.type === 'distribution') {
+          this.telemetry.distribution(event.name, event.tags, event.measure)
+        }
+      }
+    })
   }
 
   get telemetry () {
     const testFramework = this.testFramework || this.constructor.id
     const exporter = this.tracer?._exporter
-    // TODO: only jest worker supported yet
     const isSupportedWorker = exporter && typeof exporter.exportTelemetry === 'function'
     const ciProviderName = this.ciProviderName
 
@@ -1157,11 +1173,11 @@ module.exports = class CiPlugin extends Plugin {
         return
       }
 
-      const { filePath, format } = coverageReports[reportIndex]
+      const { filePath, fileDevice, fileInode, format } = coverageReports[reportIndex]
       reportIndex++
 
       this.tracer._exporter.uploadCoverageReport(
-        { filePath, format, testEnvironmentMetadata: this.testEnvironmentMetadata },
+        { filePath, fileDevice, fileInode, format, testEnvironmentMetadata: this.testEnvironmentMetadata },
         (err) => {
           if (err) {
             failedCount++

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

@@ -36,6 +36,7 @@ const plugins = {
   get '@smithy/core' () { return require('../../../datadog-plugin-aws-sdk/src') },
   get '@smithy/smithy-client' () { return require('../../../datadog-plugin-aws-sdk/src') },
   get '@vitest/runner' () { return require('../../../datadog-plugin-vitest/src') },
+  get '@wdio/jasmine-framework' () { return require('../../../datadog-plugin-mocha/src') },
   get '@wdio/local-runner' () { return require('../../../datadog-plugin-mocha/src') },
   get '@langchain/langgraph' () { return require('../../../datadog-plugin-langgraph/src') },
   get '@openai/agents' () { return require('../../../datadog-plugin-openai-agents/src') },

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

@@ -114,6 +114,9 @@ const uniq = (items) => [...new Set(items)]
  *
  * This is much more robust than relying on hardcoded paths, especially on self-hosted runners
  * and GHES environments where the runner may be installed under arbitrary directories/users.
+ *
+ * @param {string | undefined} runnerTemp value of the `RUNNER_TEMP` environment variable
+ * @returns {string[]}
  */
 function getGithubDiagnosticDirsFromEnv (runnerTemp) {
   const dirs = []
@@ -182,6 +185,9 @@ function expandGlobPattern (pattern) {
 /**
  * Expands a mixed list of literal directories and glob patterns into concrete
  * directories. Literals pass through unchanged (existence is checked later).
+ *
+ * @param {string[]} candidates
+ * @returns {string[]}
  */
 function expandDiagnosticDirCandidates (candidates) {
   const expanded = []

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

@@ -38,6 +38,8 @@ const {
 const { filterSensitiveInfoFromRepository } = require('./url')
 const { cachedExec } = require('./git-cache')
 
+/** @typedef {NonNullable<ReturnType<string['match']>>} RegExpMatch */
+
 const legacyStorage = storage('legacy')
 
 const GIT_REV_LIST_MAX_BUFFER = 12 * 1024 * 1024 // 12MB
@@ -116,12 +118,12 @@ function isShallowRepository () {
 
 function getGitVersion () {
   const gitVersionString = sanitizedExec('git', ['version'])
-  const gitVersionMatches = /** @type {RegExpMatchArray} */ (gitVersionString.match(/git version (\d+)\.(\d+)\.(\d+)/))
+  const gitVersionMatches = /** @type {RegExpMatch} */ (gitVersionString.match(/git version (\d+)\.(\d+)\.(\d+)/))
   try {
     return {
-      major: Number.parseInt(gitVersionMatches[1]),
-      minor: Number.parseInt(gitVersionMatches[2]),
-      patch: Number.parseInt(gitVersionMatches[3]),
+      major: Number.parseInt(gitVersionMatches[1], 10),
+      minor: Number.parseInt(gitVersionMatches[2], 10),
+      patch: Number.parseInt(gitVersionMatches[3], 10),
     }
   } catch {
     return null

package/packages/dd-trace/src/plugins/util/http-otel-semantics.js

@@ -71,7 +71,7 @@ function decomposeServerUrl (rawUrl, obfuscatedUrl) {
       address = stripIpv6Brackets(hostname)
     }
     if (parsed.port) {
-      const parsedPort = Number.parseInt(parsed.port)
+      const parsedPort = Number.parseInt(parsed.port, 10)
       if (parsedPort > 0) port = parsedPort
     }
     path = parsed.pathname || '/'
@@ -210,7 +210,7 @@ function applyHttpOtelSemantics (formattedSpan) {
     // metric (the OTLP exporter serializes meta as stringValue but metrics as
     // intValue) — mirroring how server.port is handled below. Guard against a
     // non-numeric status, which would otherwise write a NaN metric.
-    statusCode = Number.parseInt(status)
+    statusCode = Number.parseInt(status, 10)
     if (Number.isFinite(statusCode)) newMetrics[HTTP_RESPONSE_STATUS_CODE] = statusCode
   }
 

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

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

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

@@ -184,6 +184,9 @@ function isDDInstrumentationFile (fileName) {
  * This function extracts the `myscript.js:10:3` part, passes it, returns the file name, line number, and column
  * number and sets the `index` to the start of the whole location string.
  *
+ * @param {string} stack the stack trace, or the nested location string when recursing
+ * @param {number} start index of the first character of the frame in `stack`
+ * @param {number} index index to start parsing backwards from
  * @returns {[string, string, string, number]|undefined}
  */
 function parseLocation (stack, start, index) {