dd-trace 6.15.0 → 6.16.0

package/packages/dd-trace/src/appsec/telemetry/user.js

@@ -1,8 +1,6 @@
 'use strict'
 
-const telemetryMetrics = require('../../telemetry/metrics')
-
-const appsecMetrics = telemetryMetrics.manager.namespace('appsec')
+const { appsecMetrics } = require('./common')
 
 function incrementMissingUserLogin (framework, eventType) {
   appsecMetrics.count('instrum.user_auth.missing_user_login', {

package/packages/dd-trace/src/appsec/telemetry/waf.js

@@ -1,9 +1,6 @@
 'use strict'
 
-const telemetryMetrics = require('../../telemetry/metrics')
-const { tags, getVersionsTags, DD_TELEMETRY_REQUEST_METRICS } = require('./common')
-
-const appsecMetrics = telemetryMetrics.manager.namespace('appsec')
+const { appsecMetrics, tags, getVersionsTags, DD_TELEMETRY_REQUEST_METRICS } = require('./common')
 
 const DD_TELEMETRY_WAF_RESULT_TAGS = Symbol('_dd.appsec.telemetry.waf.result.tags')
 
@@ -126,21 +123,6 @@ function incrementWafRequests (store) {
   }
 }
 
-function incrementWafDurationMetrics (requestMetrics) {
-  const { duration, durationExt, wafVersion, rulesVersion } = requestMetrics
-  if (!duration && !durationExt) return
-
-  const versionsTags = getVersionsTags(wafVersion, rulesVersion)
-
-  if (duration) {
-    appsecMetrics.distribution('waf.duration', versionsTags).track(duration)
-  }
-
-  if (durationExt) {
-    appsecMetrics.distribution('waf.duration_ext', versionsTags).track(durationExt)
-  }
-}
-
 function incrementTruncatedMetrics (metrics, truncationReason) {
   const truncationTags = { truncation_reason: truncationReason }
   appsecMetrics.count('waf.input_truncated', truncationTags).inc(1)
@@ -163,5 +145,4 @@ module.exports = {
   incrementWafUpdates,
   incrementWafConfigErrors,
   incrementWafRequests,
-  incrementWafDurationMetrics,
 }

package/packages/dd-trace/src/config/generated-config-types.d.ts

@@ -68,6 +68,7 @@ export interface GeneratedConfig {
   DD_AGENTLESS_ENABLED: boolean;
   DD_AGENTLESS_LOG_SUBMISSION_ENABLED: boolean;
   DD_AGENTLESS_LOG_SUBMISSION_URL: string | undefined;
+  DD_AI_GUARD_ANALYZE_STREAM_RESPONSES_ENABLED: boolean;
   DD_API_KEY: string | undefined;
   DD_APM_FLUSH_DEADLINE_MILLISECONDS: number;
   DD_APP_KEY: string | undefined;
@@ -615,6 +616,7 @@ export interface GeneratedEnvVarConfig {
   DD_AGENTLESS_ENABLED: boolean;
   DD_AGENTLESS_LOG_SUBMISSION_ENABLED: boolean;
   DD_AGENTLESS_LOG_SUBMISSION_URL: string | undefined;
+  DD_AI_GUARD_ANALYZE_STREAM_RESPONSES_ENABLED: boolean;
   DD_AI_GUARD_BLOCK: boolean;
   DD_AI_GUARD_ENABLED: boolean;
   DD_AI_GUARD_ENDPOINT: string | undefined;

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

@@ -143,10 +143,17 @@ function getEnvNameFromSource (name, source) {
   }
 }
 
+/**
+ * @param {string} name
+ * @returns {boolean}
+ */
+function isSupportedConfiguration (name) {
+  return supportedConfigurations[name] !== undefined || aliasToCanonical[name] !== undefined
+}
+
 function validateAccess (name) {
   if ((name.startsWith('DD_') || name.startsWith('OTEL_')) &&
-    !supportedConfigurations[name] &&
-    !aliasToCanonical[name]) {
+    !isSupportedConfiguration(name)) {
     throw new Error(`Missing ${name} env/configuration in "supported-configurations.json" file.`)
   }
 }
@@ -284,6 +291,7 @@ function getValueFromEnvSources (name, skipDefault) {
 
 module.exports = {
   getValueFromEnvSources,
+  isSupportedConfiguration,
 
   /**
    * Expose raw stable config maps and warnings for consumers that need

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

@@ -24,6 +24,7 @@ const {
 } = require('../serverless')
 const { ORIGIN_KEY, DATADOG_MINI_AGENT_PATH } = require('../constants')
 const { appendRules } = require('../payload-tagging/config')
+const { createSiteUrl } = require('../exporters/common/url')
 const ConfigBase = require('./config-base')
 const {
   getEnvironmentVariable,
@@ -495,9 +496,6 @@ class Config extends ConfigBase {
 
     const agentlessTracingEnabled = this.DD_AGENTLESS_ENABLED ||
       isTrue(getEnvironmentVariable('_DD_APM_TRACING_AGENTLESS_ENABLED'))
-    if (agentlessTracingEnabled && !this.isCiVisibility) {
-      setAndTrack(this, 'OTEL_TRACES_EXPORTER', 'none')
-    }
 
     // Apply the OTel sampler when the user opted into OTel traces or explicitly set the sampler.
     // OTEL_TRACES_SAMPLER has `default: parentbased_always_on` (per OTel spec), so opt-in users
@@ -699,16 +697,33 @@ class Config extends ConfigBase {
 
     // TODO: This could likely be moved to the base class and allow easier GRPC handling
     // Default OTLP endpoints follow the configured agent host so users who point DD at a custom
-    // agent (DD_AGENT_HOST / DD_TRACE_AGENT_URL) also reach OTLP on that host.
-    const defaultOtlpBase = this.OTEL_EXPORTER_OTLP_ENDPOINT?.replace(/\/$/, '') ?? `http://${agentHostname}:4318`
+    // agent (DD_AGENT_HOST / DD_TRACE_AGENT_URL) also reach OTLP on that host. In agentless mode
+    // there is no agent to relay through, so OTLP goes straight to the per-site intake instead.
+    const otlpAgentlessOrigin = agentlessTracingEnabled && !this.OTEL_EXPORTER_OTLP_ENDPOINT
+      ? createSiteUrl(this.site, 'otlp')?.origin
+      : undefined
+    const defaultOtlpBase = otlpAgentlessOrigin ??
+      this.OTEL_EXPORTER_OTLP_ENDPOINT?.replace(/\/$/, '') ?? `http://${agentHostname}:4318`
+
+    const assignOtlpHeaderApiKey = (configName) => {
+      if (otlpAgentlessOrigin) {
+        this[configName] ??= { ...this.OTEL_EXPORTER_OTLP_HEADERS }
+        this[configName]['dd-api-key'] = this.DD_API_KEY
+        setAndTrack(this, configName, this[configName])
+      }
+    }
+
     if (!this.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT) {
       setAndTrack(this, 'OTEL_EXPORTER_OTLP_LOGS_ENDPOINT', `${defaultOtlpBase}/v1/logs`)
+      assignOtlpHeaderApiKey('OTEL_EXPORTER_OTLP_LOGS_HEADERS')
     }
     if (!this.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT) {
       setAndTrack(this, 'OTEL_EXPORTER_OTLP_METRICS_ENDPOINT', `${defaultOtlpBase}/v1/metrics`)
+      assignOtlpHeaderApiKey('OTEL_EXPORTER_OTLP_METRICS_HEADERS')
     }
     if (!this.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT) {
       setAndTrack(this, 'OTEL_EXPORTER_OTLP_TRACES_ENDPOINT', `${defaultOtlpBase}/v1/traces`)
+      assignOtlpHeaderApiKey('OTEL_EXPORTER_OTLP_TRACES_HEADERS')
     }
 
     const autoTraceMetrics = this.OTEL_TRACES_EXPORTER === 'otlp' && this.DD_METRICS_OTEL_ENABLED === true

package/packages/dd-trace/src/config/supported-configurations.json

@@ -53,6 +53,14 @@
         ]
       }
     ],
+    "DD_AI_GUARD_ANALYZE_STREAM_RESPONSES_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "false",
+        "description": "Buffer Vercel AI streamed responses for After Model evaluation before replaying them."
+      }
+    ],
     "DD_AI_GUARD_BLOCK": [
       {
         "implementation": "C",

package/packages/dd-trace/src/debugger/devtools_client/breakpoints.js

@@ -6,7 +6,11 @@ const { getGeneratedPosition } = require('./source-maps')
 const session = require('./session')
 const { compile, compileSegments, templateRequiresEvaluation } = require('./condition')
 const { MAX_SNAPSHOTS_PER_SECOND_PER_PROBE, MAX_NON_SNAPSHOTS_PER_SECOND_PER_PROBE } = require('./defaults')
-const { compileBreakpointCondition, getRemoveProbeExpression } = require('./probe_sampler')
+const {
+  compileBreakpointCondition,
+  getRemoveProbeExpression,
+  isSnapshotProducingProbe,
+} = require('./probe_sampler')
 const {
   DEFAULT_MAX_REFERENCE_DEPTH,
   DEFAULT_MAX_COLLECTION_SIZE,
@@ -76,12 +80,6 @@ async function addBreakpoint (probe) {
   }
   delete probe.segments
 
-  // Optimize for fast calculations when probe is hit
-  const snapshotsPerSecond = probe.sampling?.snapshotsPerSecond ?? (probe.captureSnapshot
-    ? MAX_SNAPSHOTS_PER_SECOND_PER_PROBE
-    : MAX_NON_SNAPSHOTS_PER_SECOND_PER_PROBE)
-  probe.nsBetweenSampling = BigInt(Math.trunc(1 / snapshotsPerSecond * 1e9))
-
   // Warning: The code below relies on undocumented behavior of the inspector!
   // It expects that `await session.post('Debugger.enable')` will wait for all loaded scripts to be emitted as
   // `Debugger.scriptParsed` events. If this ever changes, we will have a race condition!
@@ -156,6 +154,15 @@ async function addBreakpoint (probe) {
     }
   }
 
+  // Must be calculated after `compiledCaptureExpressions` has been resolved, since capture-expression probes produce
+  // snapshots and therefore default to the snapshot rate.
+  //
+  // Optimize for fast calculations when probe is hit
+  const snapshotsPerSecond = probe.sampling?.snapshotsPerSecond ?? (isSnapshotProducingProbe(probe)
+    ? MAX_SNAPSHOTS_PER_SECOND_PER_PROBE
+    : MAX_NON_SNAPSHOTS_PER_SECOND_PER_PROBE)
+  probe.nsBetweenSampling = BigInt(Math.trunc(1 / snapshotsPerSecond * 1e9))
+
   const locationKey = generateLocationKey(scriptId, lineNumber, columnNumber)
   const breakpoint = locationToBreakpoint.get(locationKey)
 

package/packages/dd-trace/src/debugger/devtools_client/probe_sampler.js

@@ -8,6 +8,19 @@ const SAMPLER_EXPRESSION = `globalThis[Symbol.for(${JSON.stringify(DD_TRACE_SYMB
 module.exports = {
   compileBreakpointCondition,
   getRemoveProbeExpression,
+  isSnapshotProducingProbe,
+}
+
+/**
+ * Determine whether a probe produces snapshots. Probes that capture the full local state and probes that only capture
+ * specific expressions both emit snapshot payloads, so they share the snapshot sampling defaults and count towards the
+ * global snapshot rate limit.
+ *
+ * @param {{ captureSnapshot?: boolean, compiledCaptureExpressions?: object[] }} probe - The probe to inspect.
+ * @returns {boolean}
+ */
+function isSnapshotProducingProbe (probe) {
+  return probe.captureSnapshot === true || probe.compiledCaptureExpressions !== undefined
 }
 
 /**
@@ -66,7 +79,7 @@ function compileBreakpointCondition (probes) {
  */
 function compileProbeCondition (probe) {
   const sample = `$dd_sampler.makeSampleDecision(${probe.samplingIndex}, ${JSON.stringify(probe.id)}, ` +
-    `${probe.nsBetweenSampling}n, ${probe.captureSnapshot === true || probe.compiledCaptureExpressions !== undefined})`
+    `${probe.nsBetweenSampling}n, ${isSnapshotProducingProbe(probe)})`
 
   if (probe.condition === undefined) {
     return `$dd_sampled = ${sample} || $dd_sampled`

package/packages/dd-trace/src/evp_proxy/discovery.js

@@ -2,8 +2,7 @@
 
 const { fetchAgentInfo } = require('../agent/info')
 const log = require('../log')
-
-const TRAILING_SLASHES = /\/+$/
+const { stripTrailingSlashes } = require('./path')
 
 /**
  * Receiver discovery contract
@@ -81,14 +80,14 @@ function selectEVPProxyPath (agentInfo, { supportedPaths, requiredHeaders = [] }
   const advertisedPaths = new Set()
   for (const endpoint of agentInfo.endpoints) {
     if (typeof endpoint === 'string') {
-      advertisedPaths.add(endpoint.replace(TRAILING_SLASHES, ''))
+      advertisedPaths.add(stripTrailingSlashes(endpoint))
     }
   }
 
   for (const supportedPath of supportedPaths) {
     if (typeof supportedPath !== 'string') continue
 
-    const normalizedPath = supportedPath.replace(TRAILING_SLASHES, '')
+    const normalizedPath = stripTrailingSlashes(supportedPath)
     if (advertisedPaths.has(normalizedPath)) {
       return normalizedPath
     }

package/packages/dd-trace/src/evp_proxy/path.js

@@ -1,7 +1,16 @@
 'use strict'
 
 const LEADING_SLASHES = /^\/+/
-const TRAILING_SLASHES = /\/+$/
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function stripTrailingSlashes (value) {
+  let end = value.length
+  while (end > 0 && value[end - 1] === '/') end--
+  return end === value.length ? value : value.slice(0, end)
+}
 
 /**
  * Joins a caller-supplied EVP proxy path and product endpoint.
@@ -13,10 +22,10 @@ const TRAILING_SLASHES = /\/+$/
  * @returns {string} Joined request path
  */
 function joinEVPProxyPath (basePath, endpoint) {
-  const normalizedBasePath = basePath.replace(TRAILING_SLASHES, '')
+  const normalizedBasePath = stripTrailingSlashes(basePath)
   const normalizedEndpoint = endpoint.replace(LEADING_SLASHES, '')
 
   return `${normalizedBasePath}/${normalizedEndpoint}`
 }
 
-module.exports = { joinEVPProxyPath }
+module.exports = { joinEVPProxyPath, stripTrailingSlashes }

package/packages/dd-trace/src/exporters/common/docker.js

@@ -12,7 +12,10 @@ const uuidSource =
 const containerSource = '[0-9a-f]{64}'
 const taskSource = String.raw`[0-9a-f]{32}-\d+`
 const lineReg = /^(\d+):([^:]*):(.+)$/m
-const entityReg = new RegExp(String.raw`.*(${uuidSource}|${containerSource}|${taskSource})(?:\.scope)?$`, 'm')
+const entityReg = new RegExp(
+  String.raw`(?:^|/)[^/\r\n\u2028\u2029]*?(${uuidSource}|${containerSource}|${taskSource})(?:\.scope)?$`,
+  'm'
+)
 
 let inode = 0
 let cgroup = ''

package/packages/dd-trace/src/exporters/common/proxy.js

@@ -44,6 +44,9 @@ function getHttpsProxyAgent (url, directAgent) {
       ? { keepAlive: directAgent.keepAlive, maxSockets: directAgent.maxSockets }
       : undefined
     agent = new HttpsProxyAgent(proxyUrl, options)
+    // AgentBase normally infers this from the node:https call stack. Interceptors such as MSW
+    // construct http.ClientRequest directly, so identify the target protocol explicitly.
+    agent.protocol = 'https:'
     agents.set(proxyUrl, agent)
   }
   return agent

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

@@ -66,7 +66,7 @@ function initializeOpenTelemetryMetrics (config) {
   metrics.setGlobalMeterProvider(meterProvider)
 
   // Include the final metric collection and export in lifecycle retention.
-  registerTelemetryFlusher(done => meterProvider.forceFlush(done))
+  registerTelemetryFlusher(done => reader.forceFlush(done))
 
   registerResourceAttributeRefresh(exporter, () => buildGeneralResourceAttributes(config))
 }

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

@@ -51,11 +51,12 @@ class MeterProvider {
   }
 
   /**
-   * @param {Function} [done] Called after the metric export completes
+   * @param {(error: Error | null) => void} [done] Called after shutdown completes
+   * @returns {void}
    */
-  forceFlush (done) {
-    if (this.reader) this.reader.forceFlush(done)
-    else done?.()
+  shutdown (done) {
+    if (this.reader) this.reader.shutdown(done)
+    else done?.(null)
   }
 }
 

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

@@ -8,6 +8,19 @@ const {
 const { ObservableInstrument } = require('./instruments')
 const { nowUnixNano } = require('./time')
 
+/**
+ * @param {(error: Error | null) => void} [done]
+ * @param {Error | null} [error]
+ */
+function callDone (done, error) {
+  if (!done) return
+  try {
+    done(error ?? null)
+  } catch (callbackError) {
+    log.error('Error completing OTLP metrics lifecycle callback:', callbackError)
+  }
+}
+
 /**
  * @typedef {import('@opentelemetry/api').Attributes} Attributes
  * @typedef {import('@opentelemetry/core').InstrumentationScope} InstrumentationScope
@@ -105,6 +118,10 @@ class PeriodicMetricReader {
   #exportInterval
   #aggregator
   #batchCallbacks = []
+  #exportQueue = []
+  #isExporting = false
+  #shutdownCallbacks = []
+  #shutdownComplete = false
 
   /**
    * Creates a new PeriodicMetricReader instance.
@@ -197,47 +214,36 @@ class PeriodicMetricReader {
 
   /**
    * Forces an immediate collection and export of all metrics.
-   * @param {Function} [done] Called after the metric export completes
+   * @param {(error: Error | null) => void} [done] Called after the metric export completes
+   * @returns {void}
    */
   forceFlush (done) {
     if (this.#isShutdown) {
       log.warn('PeriodicMetricReader is shutdown. %d measurement(s) were dropped', this.#droppedCount)
-      done?.()
+      if (this.#shutdownComplete) callDone(done)
+      else if (done) this.#shutdownCallbacks.push(done)
       return
     }
-    let pending = 2
-    const complete = () => {
-      if (--pending === 0) done?.()
-    }
-
-    // Snapshot requests already active before starting this flush's export.
-    try {
-      if (typeof this.exporter.flush === 'function') this.exporter.flush(complete)
-      else complete()
-    } catch (error) {
-      log.error('Error flushing OTLP metrics:', error)
-      complete()
-    }
-    try {
-      this.#collectAndExport(complete)
-    } catch (error) {
-      log.error('Error exporting OTLP metrics:', error)
-      complete()
-    }
+    this.#enqueueExport(true, done)
   }
 
   /**
    * Shuts down the reader and stops periodic collection.
+   * @param {(error: Error | null) => void} [done] Called after the final export and exporter shutdown complete
    * @returns {void}
    */
-  shutdown () {
+  shutdown (done) {
     if (this.#isShutdown) {
       log.warn('PeriodicMetricReader is already shutdown')
+      if (this.#shutdownComplete) callDone(done)
+      else if (done) this.#shutdownCallbacks.push(done)
       return
     }
+    if (done) this.#shutdownCallbacks.push(done)
+
     this.#isShutdown = true
     this.#clearTimer()
-    this.forceFlush()
+    this.#enqueueExport(true, error => this.#shutdownExporter(error))
   }
 
   /**
@@ -248,7 +254,7 @@ class PeriodicMetricReader {
     if (this.#timer) return
 
     this.#timer = setInterval(() => {
-      this.#collectAndExport()
+      if (!this.#isExporting && this.#exportQueue.length === 0) this.#enqueueExport(false)
     }, this.#exportInterval)
     this.#timer.unref?.()
   }
@@ -264,6 +270,75 @@ class PeriodicMetricReader {
     }
   }
 
+  /**
+   * @param {boolean} flushExporter Whether to flush the exporter after export
+   * @param {(error: Error | null) => void} [done] Called when the queued export completes
+   * @returns {void}
+   */
+  #enqueueExport (flushExporter, done) {
+    this.#exportQueue.push({ flushExporter, done })
+    this.#drainExportQueue()
+  }
+
+  /** @returns {void} */
+  #drainExportQueue () {
+    if (this.#isExporting || this.#exportQueue.length === 0) return
+
+    this.#isExporting = true
+    const { flushExporter, done } = this.#exportQueue.shift()
+    let completed = false
+    const complete = error => {
+      if (completed) return
+      completed = true
+      this.#isExporting = false
+      queueMicrotask(() => this.#drainExportQueue())
+      callDone(done, error)
+    }
+    let exportCompleted = false
+    const afterExport = error => {
+      if (exportCompleted) return
+      exportCompleted = true
+      if (!flushExporter || typeof this.exporter.flush !== 'function') return complete(error)
+
+      try {
+        this.exporter.flush(flushError => complete(error || flushError))
+      } catch (flushError) {
+        log.error('Error flushing OTLP metrics:', flushError)
+        complete(error || flushError)
+      }
+    }
+
+    try {
+      this.#collectAndExport(afterExport)
+    } catch (error) {
+      log.error('Error exporting OTLP metrics:', error)
+      afterExport(error)
+    }
+  }
+
+  /**
+   * @param {Error} [exportError] Error from the final export
+   * @returns {void}
+   */
+  #shutdownExporter (exportError) {
+    let completed = false
+    const complete = shutdownError => {
+      if (completed) return
+      completed = true
+      this.#shutdownComplete = true
+      const callbacks = this.#shutdownCallbacks.splice(0)
+      for (const callback of callbacks) callDone(callback, exportError || shutdownError)
+    }
+
+    try {
+      if (typeof this.exporter.shutdown === 'function') this.exporter.shutdown(complete)
+      else complete()
+    } catch (error) {
+      log.error('Error shutting down OTLP metrics exporter:', error)
+      complete(error)
+    }
+  }
+
   /**
    * Collects measurements and exports metrics.
    *
@@ -322,7 +397,13 @@ class PeriodicMetricReader {
       this.#lastExportedState
     )
 
-    this.exporter.export(metrics, callback)
+    this.exporter.export(metrics, result => {
+      if (result?.code === 1) {
+        callback?.(result.error || new Error('OTLP metrics export failed'))
+      } else {
+        callback?.()
+      }
+    })
   }
 }
 

package/packages/dd-trace/src/opentelemetry/otlp/otlp_http_exporter_base.js

@@ -177,7 +177,13 @@ class OtlpHttpExporterBase {
     this.telemetryTags[0] = `protocol:${this.#transport === https ? 'https' : 'http'}`
   }
 
-  shutdown () {}
+  /**
+   * @param {() => void} [done]
+   * @returns {void}
+   */
+  shutdown (done) {
+    done?.()
+  }
 }
 
 module.exports = OtlpHttpExporterBase

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

@@ -2,7 +2,11 @@
 
 const { channel } = require('dc-polyfill')
 
-const { getEnvironmentVariable, getValueFromEnvSources } = require('./config/helper')
+const {
+  getEnvironmentVariable,
+  getValueFromEnvSources,
+  isSupportedConfiguration,
+} = require('./config/helper')
 const { isFalse, isTrue, normalizePluginEnvName } = require('./util')
 const plugins = require('./plugins')
 const log = require('./log')
@@ -59,12 +63,14 @@ function maybeEnable (Plugin) {
 }
 
 function getEnabled (Plugin) {
-  const envName = `DD_TRACE_${Plugin.id.toUpperCase()}_ENABLED`
+  const envName = normalizePluginEnvName(`DD_TRACE_${Plugin.id.toUpperCase()}_ENABLED`)
+  if (!isSupportedConfiguration(envName)) return
+
   // skipDefault: only an explicitly configured value should drive enablement here. A registered
   // default of `false` (e.g. an opt-in plugin like `nats`) must not be read as an explicit
   // "disabled via configuration option" — that path both logs a misleading line and nulls the
   // plugin class, bypassing the opt-in handled by `loadPlugin`.
-  return getValueFromEnvSources(normalizePluginEnvName(envName), true)
+  return getValueFromEnvSources(envName, true)
 }
 
 // TODO this must always be a singleton.

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

@@ -19,6 +19,7 @@ const plugins = {
   get '@google-cloud/pubsub' () { return require('../../../datadog-plugin-google-cloud-pubsub/src') },
   get '@google-cloud/vertexai' () { return require('../../../datadog-plugin-google-cloud-vertexai/src') },
   get '@google/genai' () { return require('../../../datadog-plugin-google-genai/src') },
+  get '@graphql-tools/executor' () { return require('../../../datadog-plugin-graphql/src') },
   get '@grpc/grpc-js' () { return require('../../../datadog-plugin-grpc/src') },
   get '@hapi/hapi' () { return require('../../../datadog-plugin-hapi/src') },
   get '@happy-dom/jest-environment' () { return require('../../../datadog-plugin-jest/src') },

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

@@ -1135,7 +1135,10 @@ function getCodeOwnersPatternRegex (pattern) {
   }
 
   const directoryOnly = pattern.endsWith('/')
-  const normalizedPattern = pattern.replace(/^\/+/, '').replace(/\/+$/, '')
+  let normalizedPattern = pattern.replace(/^\/+/, '')
+  let normalizedPatternEnd = normalizedPattern.length
+  while (normalizedPatternEnd > 0 && normalizedPattern[normalizedPatternEnd - 1] === '/') normalizedPatternEnd--
+  normalizedPattern = normalizedPattern.slice(0, normalizedPatternEnd)
   const anchored = pattern.startsWith('/') || normalizedPattern.includes('/')
 
   if (!normalizedPattern) {

package/packages/dd-trace/src/llmobs/plugins/claude-agent-sdk/utils.js

@@ -1,10 +0,0 @@
-'use strict'
-
-function splitModel (model) {
-  if (!model) return { modelName: undefined, modelProvider: 'anthropic' }
-  const idx = model.indexOf('/')
-  if (idx === -1) return { modelName: model, modelProvider: 'anthropic' }
-  return { modelName: model.slice(idx + 1), modelProvider: model.slice(0, idx) }
-}
-
-module.exports = { splitModel }