dd-trace 6.16.0 → 6.18.0

package/packages/datadog-plugin-supabase/src/supabase-postgrest-js-postgrestbuilder-then.js

@@ -0,0 +1,122 @@
+'use strict'
+
+const { storage } = require('../../datadog-core')
+const log = require('../../dd-trace/src/log')
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+const { extractPathFromUrl } = require('../../dd-trace/src/plugins/util/url')
+const { stripQueryAndFragment } = require('../../dd-trace/src/util')
+const normalizeError = require('./error')
+
+const spanFinished = Symbol('spanFinished')
+
+const operationByMethod = {
+  DELETE: 'DELETE',
+  GET: 'SELECT',
+  HEAD: 'SELECT',
+  PATCH: 'UPDATE',
+  POST: 'INSERT',
+}
+
+/**
+ * @typedef {{
+ *   arguments: { [index: number]: unknown, length: number, 0?: Function, 1?: Function },
+ *   self: { method: string, url: URL, schema?: string },
+ *   currentStore?: { span: import('../../..').Span },
+ *   parentStore: import('../../datadog-core/src/storage').Store<unknown>,
+ *   result?: { error?: Error | { message?: string } | null },
+ *   error?: unknown
+ * } & Record<symbol, boolean | undefined>} PostgrestContext
+ */
+
+function finishSafely (plugin, ctx, hasError = false) {
+  try {
+    if (hasError) plugin.error(ctx)
+    plugin.finish(ctx)
+  } catch (error) {
+    log.error('Error in plugin handler:', error)
+    log.info('Disabling plugin: %s', plugin.constructor.name)
+    plugin.configure(false)
+  }
+}
+
+class SupabasePostgrestBuilderThenPlugin extends DatabasePlugin {
+  static id = 'supabase'
+  static prefix = 'tracing:orchestrion:@supabase/postgrest-js:PostgrestBuilder_then'
+
+  /** @param {PostgrestContext} ctx */
+  bindStart (ctx) {
+    const method = ctx.self?.method
+    const requestUrl = ctx.self?.url
+    const url = stripQueryAndFragment(String(requestUrl))
+    const path = extractPathFromUrl(url)
+    const operation = path.includes('/rpc/') ? 'CALL' : operationByMethod[method] || method
+    const resource = `${operation} ${path.slice(path.lastIndexOf('/') + 1)}`
+
+    this.startSpan('supabase.database.query', {
+      service: { name: this.tracer._service },
+      type: 'sql',
+      resource,
+      meta: {
+        component: 'supabase',
+        'span.kind': 'client',
+        'db.type': 'postgres',
+        'db.name': ctx.self?.schema || 'public',
+        'db.operation': operation,
+        'out.host': requestUrl?.hostname,
+      },
+    }, ctx)
+
+    // PostgrestBuilder.then owns both the request and consumer callbacks. Finish the request span and
+    // restore its parent before invoking a callback so application failures and latency stay outside it.
+    const onFulfilled = ctx.arguments?.[0]
+    if (typeof onFulfilled === 'function') {
+      const plugin = this
+      ctx.arguments[0] = function (result) {
+        ctx.result = result
+        finishSafely(plugin, ctx)
+        return storage('legacy').run(ctx.parentStore, () => onFulfilled.apply(this, arguments))
+      }
+    }
+
+    const onRejected = ctx.arguments?.[1]
+    if (typeof onRejected === 'function') {
+      const plugin = this
+      ctx.arguments[1] = function (error) {
+        ctx.error = error
+        finishSafely(plugin, ctx, true)
+        return storage('legacy').run(ctx.parentStore, () => onRejected.apply(this, arguments))
+      }
+    }
+
+    return ctx.currentStore
+  }
+
+  /** @param {PostgrestContext} ctx */
+  asyncEnd (ctx) {
+    this.finish(ctx)
+  }
+
+  /** @param {PostgrestContext} ctx */
+  error (ctx) {
+    if (ctx[spanFinished]) return
+    super.error(ctx)
+  }
+
+  // You may modify this method, but the guard below is REQUIRED and MUST NOT be removed!
+  /** @param {PostgrestContext} ctx */
+  finish (ctx) {
+    // CRITICAL GUARD - DO NOT REMOVE: Ensures span only finishes when operation completes
+    if (ctx[spanFinished] || !ctx.hasOwnProperty('result') && !ctx.hasOwnProperty('error')) return
+
+    const error = normalizeError(ctx.result?.error, 'PostgrestError')
+    if (error) {
+      ctx.error = error
+      super.error(ctx)
+    }
+
+    ctx[spanFinished] = true
+    super.finish(ctx)
+  }
+}
+
+module.exports = SupabasePostgrestBuilderThenPlugin

package/packages/datadog-plugin-supabase/src/supabase-realtime-js-realtimechannel-send.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
+const normalizeError = require('./error')
+
+/**
+ * @typedef {{
+ *   self: { subTopic: string },
+ *   currentStore?: { span: import('../../..').Span },
+ *   result?: 'ok' | 'error' | 'timed out',
+ *   error?: unknown
+ * }} RealtimeContext
+ */
+
+class SupabaseRealtimeChannelSendPlugin extends ProducerPlugin {
+  static id = 'supabase'
+  static prefix = 'tracing:orchestrion:@supabase/realtime-js:RealtimeChannel_send'
+  static peerServicePrecursors = ['messaging.destination.name']
+
+  /** @param {RealtimeContext} ctx */
+  bindStart (ctx) {
+    const destination = ctx.self?.subTopic
+
+    this.startSpan({
+      service: { name: this.tracer._service },
+      type: 'messaging',
+      resource: destination,
+      meta: {
+        component: 'supabase',
+        'span.kind': 'producer',
+        'messaging.system': 'supabase',
+        'messaging.destination.name': destination,
+        'messaging.destination.kind': 'topic',
+        'messaging.operation': 'send',
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  operationName () {
+    return 'supabase.messaging.send'
+  }
+
+  /** @param {RealtimeContext} ctx */
+  asyncEnd (ctx) {
+    this.finish(ctx)
+  }
+
+  // You may modify this method, but the guard below is REQUIRED and MUST NOT be removed!
+  /** @param {RealtimeContext} ctx */
+  finish (ctx) {
+    // CRITICAL GUARD - DO NOT REMOVE: Ensures span only finishes when operation completes
+    if (!ctx.hasOwnProperty('result') && !ctx.hasOwnProperty('error')) return
+
+    const result = ctx.result
+    if (result === 'error' || result === 'timed out') {
+      ctx.error = normalizeError(result, 'RealtimeSendError', `Realtime send returned ${result}`)
+      super.error(ctx)
+    }
+
+    super.finish(ctx)
+  }
+}
+
+module.exports = SupabaseRealtimeChannelSendPlugin

package/packages/datadog-plugin-supabase/src/supabase-storage-js-handle-request.js

@@ -0,0 +1,93 @@
+'use strict'
+
+const StoragePlugin = require('../../dd-trace/src/plugins/storage')
+const { extractPathFromUrl } = require('../../dd-trace/src/plugins/util/url')
+const { stripQueryAndFragment } = require('../../dd-trace/src/util')
+const getHostname = require('./url')
+
+/**
+ * @typedef {{
+ *   arguments: { [index: number]: unknown, length: number, 1: string, 2: string | URL },
+ *   currentStore?: { span: import('../../..').Span },
+ *   result?: unknown,
+ *   error?: Error & { status?: number }
+ * }} StorageContext
+ */
+
+const storageRoutes = [
+  'object/upload/sign',
+  'object/list-v2',
+  'object/list',
+  'object/sign',
+  'object/info',
+  'object/copy',
+  'object/move',
+  'render/image',
+  'bucket',
+  'object',
+  'cdn',
+]
+
+/**
+ * Returns a low-cardinality storage route for a request URL.
+ *
+ * @param {string|URL} url Request URL.
+ */
+function getStorageRoute (url) {
+  const path = extractPathFromUrl(stripQueryAndFragment(String(url)))
+  const marker = '/storage/v1/'
+  const markerIndex = path.indexOf(marker)
+  const storagePath = markerIndex === -1 ? path.replace(/^\/+/, '') : path.slice(markerIndex + marker.length)
+
+  for (const route of storageRoutes) {
+    if (storagePath === route || storagePath.startsWith(`${route}/`)) return route
+  }
+
+  return 'storage'
+}
+
+class SupabaseStorageHandleRequestPlugin extends StoragePlugin {
+  static id = 'supabase'
+  static prefix = 'tracing:orchestrion:@supabase/storage-js:handleRequest'
+
+  /** @param {StorageContext} ctx */
+  bindStart (ctx) {
+    const method = String(ctx.arguments?.[1] || 'GET').toUpperCase()
+    const url = ctx.arguments?.[2]
+
+    this.startSpan('supabase.storage.request', {
+      service: { name: this.tracer._service },
+      type: 'storage',
+      resource: `${method} ${getStorageRoute(url)}`,
+      meta: {
+        component: 'supabase',
+        'span.kind': 'client',
+        'http.method': method,
+        'http.url': stripQueryAndFragment(String(url)),
+        'out.host': getHostname(url),
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  /** @param {StorageContext} ctx */
+  error (ctx) {
+    const status = ctx.error?.status
+    if (status) ctx.currentStore?.span.setTag('http.status_code', status)
+    super.error(ctx)
+  }
+
+  /** @param {StorageContext} ctx */
+  asyncEnd (ctx) {
+    this.finish(ctx)
+  }
+
+  /** @param {StorageContext} ctx */
+  finish (ctx) {
+    if (!ctx.hasOwnProperty('result') && !ctx.hasOwnProperty('error')) return
+    super.finish(ctx)
+  }
+}
+
+module.exports = SupabaseStorageHandleRequestPlugin

package/packages/datadog-plugin-supabase/src/url.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const { URL } = require('node:url')
+
+/**
+ * Extracts a hostname without allowing malformed SDK input to break instrumentation.
+ *
+ * @param {string|URL} url Request URL.
+ * @returns {string|undefined} Parsed hostname.
+ */
+function getHostname (url) {
+  try {
+    return new URL(url).hostname
+  } catch {}
+}
+
+module.exports = getHostname

package/packages/datadog-plugin-vitest/src/index.js

@@ -44,6 +44,7 @@ const {
   TEST_ITR_UNSKIPPABLE,
   TEST_ITR_FORCED_RUN,
   ITR_CORRELATION_ID,
+  setExpectedEmptyTestSessionTags,
 } = require('../../dd-trace/src/plugins/util/test')
 const { COMPONENT } = require('../../dd-trace/src/constants')
 const id = require('../../dd-trace/src/id')
@@ -579,6 +580,7 @@ class VitestPlugin extends CiPlugin {
       requestErrorTags,
       vitestPool,
       isVitestNoWorkerInitActive,
+      testSessionEmptyReason,
       onDone,
     }) => {
       for (const [tag, value] of Object.entries(requestErrorTags)) {
@@ -587,6 +589,13 @@ class VitestPlugin extends CiPlugin {
       }
       this.testSessionSpan.setTag(TEST_STATUS, status)
       this.testModuleSpan.setTag(TEST_STATUS, status)
+      if (testSessionEmptyReason) {
+        setExpectedEmptyTestSessionTags(
+          this.testSessionSpan,
+          this.testModuleSpan,
+          testSessionEmptyReason
+        )
+      }
       if (error) {
         this.testModuleSpan.setTag('error', error)
         this.testSessionSpan.setTag('error', error)

package/packages/datadog-plugin-ws/src/producer.js

@@ -21,7 +21,7 @@ class WSProducerPlugin extends TracingPlugin {
 
   bindStart (ctx) {
     const { byteLength, socket, binary } = ctx
-    if (!socket.spanContext) return
+    if (!socket?.spanContext) return
 
     const spanTags = socket.spanTags
     const path = getSegment(spanTags['resource.name'], ' ', 1)

package/packages/datadog-plugin-ws/src/util.js

@@ -36,7 +36,6 @@ function createWebSocketSpanContext (spanContext) {
 /**
  * Returns whether distributed trace headers are present.
  * @param {Record<string, string | string[] | undefined>} headers
- * @returns {boolean}
  */
 function hasTraceHeaders (headers) {
   return !!(headers && (readDatadogTraceId(headers) || readTraceparent(headers)))
@@ -59,7 +58,6 @@ function initWebSocketMessageCounters (socket) {
  * Increments and returns the WebSocket message counter.
  * @param {object} socket - The WebSocket socket object
  * @param {string} counterType - Either 'receiveCounter' or 'sendCounter'
- * @returns {number} The incremented counter value
  */
 function incrementWebSocketCounter (socket, counterType) {
   if (!socketCounters.has(socket)) {
@@ -81,7 +79,6 @@ function incrementWebSocketCounter (socket, counterType) {
  * @param {number} counter - The message counter
  * @param {boolean} isServer - Whether this is a server (true) or client (false)
  * @param {boolean} isIncoming - Whether this is an incoming message (true) or outgoing (false)
- * @returns {string} The span pointer hash
  */
 function buildWebSocketSpanPointerHash (handshakeTraceId, handshakeSpanId, counter, isServer, isIncoming) {
   // Determine prefix based on server/client and incoming/outgoing
@@ -110,7 +107,6 @@ function buildWebSocketSpanPointerHash (handshakeTraceId, handshakeSpanId, count
  *
  * @param {DatadogSpanContext} spanContext - The handshake span context
  * @param {{ hasTraceHeaders?: boolean } | undefined} socket - The WebSocket socket object
- * @returns {boolean} True if the span has distributed tracing context
  */
 function hasDistributedTracingContext (spanContext, socket) {
   if (!spanContext) return false

package/packages/datadog-shimmer/src/shimmer.js

@@ -53,8 +53,15 @@ function copyProperties (original, wrapped) {
       const descriptor = /** @type {Descriptor} */ (Object.getOwnPropertyDescriptor(original, key))
       if (descriptor.writable && descriptor.enumerable && descriptor.configurable) {
         wrapped[key] = original[key]
-      } else if (descriptor.writable || descriptor.configurable || !Object.hasOwn(wrapped, key)) {
-        Object.defineProperty(wrapped, key, descriptor)
+      } else {
+        try {
+          Object.defineProperty(wrapped, key, descriptor)
+        } catch (error) {
+          const wrappedDescriptor = Object.getOwnPropertyDescriptor(wrapped, key)
+          if (wrappedDescriptor?.configurable !== false || wrappedDescriptor.writable) {
+            throw error
+          }
+        }
       }
     }
   }
@@ -320,19 +327,16 @@ function assertMethod (target, name, method) {
 }
 
 /**
- * Asserts that a target is not a class constructor.
+ * Asserts that a target is not an identifiable class constructor.
  *
  * @param {Function} target - The target function.
- * @throws {Error} If the target is a class constructor.
+ * @throws {TypeError} If the target is an identifiable class constructor.
  */
 function assertNotClass (target) {
-  // Class constructors have a non-writable `prototype` property; functions have a
-  // writable one and arrows / async / method-shorthand have none at all. The
-  // `'prototype' in target` gate skips the descriptor lookup for the no-prototype
-  // shapes; the `in` operator is cheaper than reading `target.prototype` since
-  // it returns a boolean instead of materialising the prototype reference.
+  // Frozen functions also have a non-writable `prototype`; inspect their source only then.
   if ('prototype' in target &&
-      Object.getOwnPropertyDescriptor(target, 'prototype').writable === false) {
+      Object.getOwnPropertyDescriptor(target, 'prototype').writable === false &&
+      (!Object.isFrozen(target) || Function.prototype.toString.call(target).startsWith('class'))) {
     throw new TypeError('Target is a native class constructor and cannot be wrapped.')
   }
 }

package/packages/datadog-turbopack/index.js

@@ -6,6 +6,7 @@ const path = require('node:path')
 
 const satisfies = require('../../vendor/dist/semifies')
 const hooks = require('../datadog-instrumentations/src/helpers/hooks')
+const { getRewriteTargetNames } = require('../datadog-instrumentations/src/helpers/rewriter/targets')
 const { SYNTHETIC_EXTENSION } = require('./src/constants')
 
 const BUILTIN_MODULES = new Set(Module.builtinModules)
@@ -74,7 +75,6 @@ function normalizeConfig (config) {
 
 /**
  * @param {unknown} value
- * @returns {boolean}
  */
 function isObject (value) {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
@@ -146,7 +146,6 @@ function createLoader () {
 
 /**
  * @param {unknown} value
- * @returns {boolean}
  */
 function hasDatadogLoader (value) {
   if (Array.isArray(value)) return value.some(hasDatadogLoader)
@@ -160,7 +159,9 @@ function hasDatadogLoader (value) {
  */
 function createPackagePathPattern () {
   const names = []
-  for (const name of Object.keys(hooks)) {
+  const targetPackages = new Set(Object.keys(hooks))
+  for (const name of getRewriteTargetNames()) targetPackages.add(name)
+  for (const name of targetPackages) {
     if (!name.startsWith('.') && !BUILTIN_MODULES.has(name)) names.push(escapeRegExp(name))
   }
   names.sort()
@@ -169,15 +170,11 @@ function createPackagePathPattern () {
 
 /**
  * @param {string} value
- * @returns {string}
  */
 function escapeRegExp (value) {
   return value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)
 }
 
-/**
- * @returns {number}
- */
 function getNextMajor () {
   const entrypoints = []
   if (require.main?.filename) entrypoints.push(require.main.filename)

package/packages/datadog-turbopack/src/loader.js

@@ -11,7 +11,10 @@ const hooks = require('../../datadog-instrumentations/src/helpers/hooks')
 const instrumentations = require('../../datadog-instrumentations/src/helpers/instrumentations')
 const { filename, matchesInstrumentation } = require('../../datadog-instrumentations/src/helpers/instrumentation-utils')
 const { createBundlerRewriter } = require('../../datadog-instrumentations/src/helpers/rewriter')
-const { getRewriteTarget } = require('../../datadog-instrumentations/src/helpers/rewriter/targets')
+const {
+  getRewriteTarget,
+  getRewriteTargetNames,
+} = require('../../datadog-instrumentations/src/helpers/rewriter/targets')
 const { isESMFile } = require('../../datadog-esbuild/src/utils')
 const { SYNTHETIC_EXTENSION } = require('./constants')
 
@@ -21,6 +24,7 @@ const MODULE_BINDING = 2
 const REQUIRE_BINDING = 4
 const COMMONJS_BINDINGS = MODULE_BINDING | REQUIRE_BINDING
 const targetPackages = new Set(Object.keys(hooks))
+for (const name of getRewriteTargetNames()) targetPackages.add(name)
 const entrypoints = new Map()
 const loadedHooks = new Set()
 const packageCache = new Map()
@@ -98,7 +102,7 @@ module.exports = function loader (source, inputSourceMap) {
     }
 
     if (publications.length > 0) code = appendCommonJsPublications(code, publications, dcModule)
-    if (rewritten && publications.length === 0) {
+    if (rewritten && publications.length === 0 && (rewriteTarget.activate || hooks[rewriteTarget.moduleName])) {
       if (!esm && hasUnsafeCommonJsBindings(code)) {
         this.emitWarning?.(new Error(`Skipped CommonJS activation for unsafe wrapper bindings in ${resourcePath}`))
         this.callback(undefined, source, inputSourceMap)
@@ -120,7 +124,6 @@ module.exports = function loader (source, inputSourceMap) {
 
 /**
  * @param {LoaderContext} context
- * @returns {string}
  */
 function getResourcePath (context) {
   const { resourcePath } = context
@@ -185,7 +188,6 @@ function getPublications (resourcePath, packageInfo) {
 /**
  * @param {string} name
  * @param {string} packageJsonPath
- * @returns {string}
  */
 function getCommonJsEntrypoint (name, packageJsonPath) {
   const cached = entrypoints.get(packageJsonPath)
@@ -228,7 +230,6 @@ function getRewriter (dcModule) {
 
 /**
  * @param {string} source
- * @returns {boolean}
  */
 function hasUnsafeCommonJsBindings (source) {
   try {
@@ -248,7 +249,6 @@ function hasUnsafeCommonJsBindings (source) {
  * @param {number} shadowedBindings
  * @param {object} [parent]
  * @param {string} [parentKey]
- * @returns {boolean}
  */
 function hasUnsafeNode (node, functionDepth, shadowedBindings, parent, parentKey) {
   if (functionDepth === 0 && hasCommonJsDeclaration(node, parent)) return true
@@ -286,7 +286,6 @@ function hasUnsafeNode (node, functionDepth, shadowedBindings, parent, parentKey
 /**
  * @param {object} node
  * @param {object} [parent]
- * @returns {boolean}
  */
 function hasCommonJsDeclaration (node, parent) {
   if (node.type === 'VariableDeclarator') {
@@ -301,7 +300,6 @@ function hasCommonJsDeclaration (node, parent) {
 /**
  * @param {object} node
  * @param {number} shadowedBindings
- * @returns {boolean}
  */
 function mutatesCommonJsBinding (node, shadowedBindings) {
   return Boolean(getBindingMask(node) & COMMONJS_BINDINGS & ~shadowedBindings)
@@ -309,7 +307,6 @@ function mutatesCommonJsBinding (node, shadowedBindings) {
 
 /**
  * @param {object} node
- * @returns {number}
  */
 function getBindingMask (node) {
   if (!node) return 0
@@ -337,7 +334,6 @@ function getBindingMask (node) {
 
 /**
  * @param {object} node
- * @returns {number}
  */
 function getFunctionBindings (node) {
   let bindings = node.type === 'ArrowFunctionExpression' ? 0 : ARGUMENTS_BINDING
@@ -348,7 +344,6 @@ function getFunctionBindings (node) {
 
 /**
  * @param {object} node
- * @returns {number}
  */
 function getVarBindings (node) {
   if (node.type === 'ArrowFunctionExpression' || node.type === 'FunctionDeclaration' ||
@@ -373,7 +368,6 @@ function getVarBindings (node) {
 
 /**
  * @param {object} node
- * @returns {number}
  */
 function getLexicalBindings (node) {
   let bindings = 0
@@ -397,7 +391,6 @@ function getLexicalBindings (node) {
 
 /**
  * @param {object} node
- * @returns {number}
  */
 function getStatementBindings (node) {
   if (node.type === 'VariableDeclaration') return getLexicalDeclarationBindings(node)
@@ -407,7 +400,6 @@ function getStatementBindings (node) {
 
 /**
  * @param {object} [node]
- * @returns {number}
  */
 function getLexicalDeclarationBindings (node) {
   if (node?.type !== 'VariableDeclaration' || node.kind === 'var') return 0
@@ -419,7 +411,6 @@ function getLexicalDeclarationBindings (node) {
 /**
  * @param {object} parent
  * @param {string} parentKey
- * @returns {boolean}
  */
 function isReferencedIdentifier (parent, parentKey) {
   if (parent.type === 'MemberExpression' && parentKey === 'property' && !parent.computed) return false
@@ -434,7 +425,6 @@ function isReferencedIdentifier (parent, parentKey) {
  * @param {string} source
  * @param {Array<{ package: string, path: string, version: string }>} payloads
  * @param {string} dcModule
- * @returns {string}
  */
 function appendCommonJsPublications (source, payloads, dcModule) {
   let publications = ''
@@ -466,7 +456,6 @@ ${publications}  }
  * @param {{ package: string, path: string, version: string }} payload
  * @param {string} dcModule
  * @param {boolean} esm
- * @returns {string}
  */
 function appendActivation (source, payload, dcModule, esm) {
   if (esm) {
@@ -491,7 +480,6 @@ import ddTraceTurbopackDc from ${JSON.stringify(dcModule)}
 /**
  * @param {string} from
  * @param {string} to
- * @returns {string}
  */
 function relativeImport (from, to) {
   let value = path.relative(from, to).replaceAll('\\', '/')

package/packages/datadog-webpack/src/loader.js

@@ -7,7 +7,6 @@ const CHANNEL = 'dd-trace:bundler:load'
  * Called for each module-of-interest identified by DatadogWebpackPlugin.
  *
  * @param {string} source
- * @returns {string}
  */
 module.exports = function loader (source) {
   this.cacheable(false)

package/packages/dd-trace/src/agent/info.js

@@ -17,21 +17,22 @@ module.exports = {
  * Fetches agent information from the /info endpoint
  * @param {URL} url - The agent URL
  * @param {Function} callback - Callback function with signature (err, agentInfo)
- * @param {{ deadline?: number, signal?: AbortSignal }} [options] - Request finalization options
+ * @param {{ deadline?: number, signal?: AbortSignal, path?: string, retry?: boolean }} [options]
+ * Request finalization and routing options
  * @param {Function} [makeRequest] - Request implementation
  */
 function fetchAgentInfo (url, callback, options = {}, makeRequest = request) {
-  const urlKey = url.href
+  const urlKey = JSON.stringify([url.href, options.path ?? '/info'])
 
   if (cachedUrl !== null && cachedUrl !== urlKey) {
-    // Clear cache if URL changes
+    // Different consumers may query different paths on the same Agent URL.
     clearCache()
   } else if (cachedData !== null && (Date.now() - cachedTimestamp) < CACHE_TTL_MS) {
     // Return cached result if still valid
     return process.nextTick(callback, null, cachedData)
   }
 
-  options.path = '/info'
+  options.path ??= '/info'
   options.url = url
   makeRequest('', options, (err, res) => {
     if (err) {

package/packages/dd-trace/src/aiguard/client.js

@@ -9,7 +9,6 @@ const TAGS = require('./tags')
  * Resolves the AI Guard host for a Datadog site.
  *
  * @param {string} site
- * @returns {string}
  */
 function aiGuardHost (site) {
   return site.split('.').length === 2 ? `app.${site}` : site
@@ -60,9 +59,9 @@ class AIGuardClient {
       'DD-AI-GUARD-SOURCE': 'SDK',
       'DD-AI-GUARD-LANGUAGE': 'nodejs',
     }
-    const endpoint = config.experimental.aiguard.endpoint || `https://${aiGuardHost(config.site)}/api/v2/ai-guard`
+    const endpoint = config.aiguard.DD_AI_GUARD_ENDPOINT || `https://${aiGuardHost(config.site)}/api/v2/ai-guard`
     this.#evaluateUrl = `${endpoint}/evaluate`
-    this.#timeout = config.experimental.aiguard.timeout
+    this.#timeout = config.aiguard.DD_AI_GUARD_TIMEOUT
   }
 
   /**