dd-trace 5.68.0 → 5.70.0

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

@@ -0,0 +1,173 @@
+'use strict'
+
+const NoopAIGuard = require('./noop')
+const executeRequest = require('./client')
+const {
+  AI_GUARD_RESOURCE,
+  AI_GUARD_TARGET_TAG_KEY,
+  AI_GUARD_REASON_TAG_KEY,
+  AI_GUARD_ACTION_TAG_KEY,
+  AI_GUARD_BLOCKED_TAG_KEY,
+  AI_GUARD_META_STRUCT_KEY,
+  AI_GUARD_TOOL_NAME_TAG_KEY
+} = require('./tags')
+const log = require('../log')
+
+const ALLOW = 'ALLOW'
+
+class AIGuardAbortError extends Error {
+  constructor (reason) {
+    super(reason)
+    this.name = 'AIGuardAbortError'
+    this.reason = reason
+  }
+}
+
+class AIGuardClientError extends Error {
+  constructor (message, opts = {}) {
+    super(message)
+    this.name = 'AIGuardClientError'
+    if (opts.errors) {
+      this.errors = opts.errors
+    }
+    if (opts.cause) {
+      this.cause = opts.cause
+    }
+  }
+}
+
+class AIGuard extends NoopAIGuard {
+  #initialized
+  #tracer
+  #headers
+  #evaluateUrl
+  #timeout
+  #maxMessagesLength
+  #maxContentSize
+  #meta
+
+  constructor (tracer, config) {
+    super()
+
+    if (!config.apiKey || !config.appKey) {
+      log.error('AIGuard: missing api and/or app keys, use env DD_API_KEY and DD_APP_KEY')
+      this.#initialized = false
+      return
+    }
+    this.#tracer = tracer
+    this.#headers = {
+      'DD-API-KEY': config.apiKey,
+      'DD-APPLICATION-KEY': config.appKey,
+    }
+    const endpoint = config.experimental.aiguard.endpoint || `https://app.${config.site}/api/v2/ai-guard`
+    this.#evaluateUrl = `${endpoint}/evaluate`
+    this.#timeout = config.experimental.aiguard.timeout
+    this.#maxMessagesLength = config.experimental.aiguard.maxMessagesLength
+    this.#maxContentSize = config.experimental.aiguard.maxContentSize
+    this.#meta = { service: config.service, env: config.env }
+    this.#initialized = true
+  }
+
+  #truncate (messages) {
+    const size = Math.min(messages.length, this.#maxMessagesLength)
+    const result = messages.slice(-size)
+
+    for (let i = 0; i < size; i++) {
+      const message = result[i]
+      if (message.content?.length > this.#maxContentSize) {
+        result[i] = { ...message, content: message.content.slice(0, this.#maxContentSize) }
+      }
+    }
+    return result
+  }
+
+  #isToolCall (message) {
+    return message.tool_calls || message.tool_call_id
+  }
+
+  #getToolName (message, history) {
+    // 1. assistant message with tool calls
+    if (message.tool_calls) {
+      const names = message.tool_calls.map((tool) => tool.function.name)
+      return names.length === 0 ? null : names.join(',')
+    }
+    // 2. assistant message with tool output (search the linked tool call in reverse order)
+    const id = message.tool_call_id
+    for (let i = history.length - 2; i >= 0; i--) {
+      const item = history[i]
+      if (item.tool_calls) {
+        for (const toolCall of item.tool_calls) {
+          if (toolCall.id === id) {
+            return toolCall.function.name
+          }
+        }
+      }
+    }
+    return null
+  }
+
+  evaluate (messages, opts) {
+    if (!this.#initialized) {
+      return super.evaluate(messages, opts)
+    }
+    const { block = false } = opts ?? {}
+    return this.#tracer.trace(AI_GUARD_RESOURCE, {}, async (span) => {
+      const last = messages[messages.length - 1]
+      const target = this.#isToolCall(last) ? 'tool' : 'prompt'
+      span.setTag(AI_GUARD_TARGET_TAG_KEY, target)
+      if (target === 'tool') {
+        const name = this.#getToolName(last, messages)
+        if (name) {
+          span.setTag(AI_GUARD_TOOL_NAME_TAG_KEY, name)
+        }
+      }
+      span.meta_struct = {
+        [AI_GUARD_META_STRUCT_KEY]: {
+          messages: this.#truncate(messages)
+        }
+      }
+      let response
+      try {
+        const payload = {
+          data: {
+            attributes: {
+              messages,
+              meta: this.#meta,
+            }
+          }
+        }
+        response = await executeRequest(
+          payload,
+          { url: this.#evaluateUrl, headers: this.#headers, timeout: this.#timeout })
+      } catch (e) {
+        throw new AIGuardClientError('Unexpected error calling AI Guard service', { cause: e })
+      }
+      if (response.status !== 200) {
+        throw new AIGuardClientError(
+          `AI Guard service call failed, status ${response.status}`,
+          { errors: response.body?.errors })
+      }
+      let action, reason, blockingEnabled
+      try {
+        const attr = response.body.data.attributes
+        if (!attr.action) {
+          throw new Error('Action missing from response')
+        }
+        action = attr.action
+        reason = attr.reason
+        blockingEnabled = attr.is_blocking_enabled ?? false
+      } catch (e) {
+        throw new AIGuardClientError(`AI Guard service returned unexpected response : ${response.body}`, { cause: e })
+      }
+      span.setTag(AI_GUARD_ACTION_TAG_KEY, action)
+      span.setTag(AI_GUARD_REASON_TAG_KEY, reason)
+      if (block && blockingEnabled && action !== ALLOW) {
+        span.setTag(AI_GUARD_BLOCKED_TAG_KEY, 'true')
+        throw new AIGuardAbortError(reason)
+      }
+      return { action, reason }
+    })
+  }
+}
+
+module.exports = AIGuard

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

@@ -0,0 +1,11 @@
+'use strict'
+
+module.exports = {
+  AI_GUARD_RESOURCE: 'ai_guard',
+  AI_GUARD_TARGET_TAG_KEY: 'ai_guard.target',
+  AI_GUARD_TOOL_NAME_TAG_KEY: 'ai_guard.tool_name',
+  AI_GUARD_ACTION_TAG_KEY: 'ai_guard.action',
+  AI_GUARD_REASON_TAG_KEY: 'ai_guard.reason',
+  AI_GUARD_BLOCKED_TAG_KEY: 'ai_guard.blocked',
+  AI_GUARD_META_STRUCT_KEY: 'ai_guard'
+}

package/packages/dd-trace/src/appsec/iast/path-line.js

@@ -3,6 +3,7 @@
 const path = require('path')
 const process = require('process')
 const { ddBasePath } = require('../../util')
+const { getOriginalPathAndLineFromSourceMap } = require('./taint-tracking/rewriter')
 const pathLine = {
   getNodeModulesPaths,
   getRelativePath,
@@ -30,8 +31,24 @@ function getNonDDCallSiteFrames (callSiteFrames, externallyExcludedPaths) {
   const result = []
 
   for (const callsite of callSiteFrames) {
-    const filepath = callsite.file
-    if (!isExcluded(callsite, externallyExcludedPaths) && !filepath.includes(pathLine.ddBasePath)) {
+    let filepath = callsite.file
+
+    if (globalThis.__DD_ESBUILD_IAST_WITH_SM) {
+      const callsiteLocation = {
+        path: getRelativePath(filepath),
+        line: callsite.line,
+        column: callsite.column
+      }
+      const { path: originalPath, line, column } = getOriginalPathAndLineFromSourceMap(callsiteLocation)
+      callsite.path = filepath = originalPath
+      callsite.line = line
+      callsite.column = column
+    }
+
+    if (
+      !isExcluded(callsite, externallyExcludedPaths) &&
+      (!filepath.includes(pathLine.ddBasePath) || globalThis.__DD_ESBUILD_IAST_WITH_NO_SM)
+    ) {
       callsite.path = getRelativePath(filepath)
       callsite.isInternal = !path.isAbsolute(filepath)
 
@@ -43,12 +60,12 @@ function getNonDDCallSiteFrames (callSiteFrames, externallyExcludedPaths) {
 }
 
 function getRelativePath (filepath) {
-  return path.relative(process.cwd(), filepath)
+  return filepath && path.relative(process.cwd(), filepath)
 }
 
 function isExcluded (callsite, externallyExcludedPaths) {
   if (callsite.isNative) return true
-  const filename = callsite.file
+  const filename = globalThis.__DD_ESBUILD_IAST_WITH_SM ? callsite.path : callsite.file
   if (!filename) {
     return true
   }

package/packages/dd-trace/src/appsec/iast/taint-tracking/rewriter.js

@@ -44,7 +44,7 @@ function setGetOriginalPathAndLineFromSourceMapFunction (chainSourceMap, { getOr
     ? (path, line, column) => {
       // if --enable-source-maps is present stacktraces of the rewritten files contain the original path, file and
       // column because the sourcemap chaining is done during the rewriting process so we can skip it
-        return isPrivateModule(path) && !isDdTrace(path)
+        return !globalThis.__DD_ESBUILD_IAST_WITH_SM && isPrivateModule(path) && !isDdTrace(path)
           ? { path, line, column }
           : getOriginalPathAndLineFromSourceMap(path, line, column)
       }
@@ -170,7 +170,10 @@ function enableRewriter (telemetryVerbosity) {
       const rewriter = getRewriter(telemetryVerbosity)
       if (rewriter) {
         shimPrepareStackTrace()
-        shimmer.wrap(Module.prototype, '_compile', compileMethod => getCompileMethodFn(compileMethod))
+        if (!globalThis.__DD_ESBUILD_IAST_WITH_SM && !globalThis.__DD_ESBUILD_IAST_WITH_NO_SM) {
+          // Avoid rewriting twice when application has been bundled
+          shimmer.wrap(Module.prototype, '_compile', compileMethod => getCompileMethodFn(compileMethod))
+        }
       }
     }
 
@@ -264,5 +267,5 @@ function enable (configArg) {
 }
 
 module.exports = {
-  enable, disable, getOriginalPathAndLineFromSourceMap
+  enable, disable, getOriginalPathAndLineFromSourceMap, getRewriter
 }

package/packages/dd-trace/src/appsec/stack_trace.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const { ddBasePath } = require('../util')
+const { getOriginalPathAndLineFromSourceMap } = require('./iast/taint-tracking/rewriter')
 
 const LIBRARY_FRAMES_BUFFER = 20
 
@@ -32,7 +33,25 @@ function getCallSiteList (maxDepth = 100, constructorOpt) {
 }
 
 function filterOutFramesFromLibrary (callSiteList) {
-  return callSiteList.filter(callSite => !callSite.getFileName()?.startsWith(ddBasePath))
+  return callSiteList.filter(callSite => {
+    if (globalThis.__DD_ESBUILD_IAST_WITH_NO_SM) {
+      // bundled and no SourceMap, not possible to discriminate if the frame comes from dd-trace code or not
+      return true
+    }
+
+    if (globalThis.__DD_ESBUILD_IAST_WITH_SM) {
+      // bundled with SourceMap, get original file and line to discriminate if comes from dd-trace or not
+      const callSiteLocation = {
+        path: callSite.getFileName(),
+        line: callSite.getLineNumber(),
+        column: callSite.getColumnNumber()
+      }
+      const { path } = getOriginalPathAndLineFromSourceMap(callSiteLocation)
+      return !path?.startsWith(ddBasePath)
+    }
+
+    return !callSite.getFileName()?.startsWith(ddBasePath)
+  })
 }
 
 function getCallsiteFrames (maxDepth = 32, constructorOpt = getCallsiteFrames, callSiteListGetter = getCallSiteList) {

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

@@ -5,6 +5,13 @@
 const { deprecate } = require('util')
 const { supportedConfigurations, aliases, deprecations } = require('./supported-configurations.json')
 
+/**
+ * Types for environment variable handling.
+ *
+ * @typedef {keyof typeof supportedConfigurations} SupportedEnvKey
+ * @typedef {Partial<typeof process.env> & Partial<Record<SupportedEnvKey, string|undefined>>} TracerEnv
+ */
+
 const aliasToCanonical = {}
 for (const canonical of Object.keys(aliases)) {
   for (const alias of aliases[canonical]) {
@@ -32,7 +39,7 @@ module.exports = {
    * Returns the environment variables that are supported by the tracer
    * (including all non-Datadog/OTEL specific environment variables)
    *
-   * @returns {Partial<process.env>} The environment variables
+   * @returns {TracerEnv} The environment variables
    */
   getEnvironmentVariables () {
     const configs = {}

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

@@ -286,6 +286,7 @@ class Config {
     checkIfBothOtelAndDdEnvVarSet()
 
     const DD_API_KEY = getEnvironmentVariable('DD_API_KEY')
+    const DD_APP_KEY = getEnvironmentVariable('DD_APP_KEY')
 
     if (getEnvironmentVariable('DD_TRACE_PROPAGATION_STYLE') && (
       getEnvironmentVariable('DD_TRACE_PROPAGATION_STYLE_INJECT') ||
@@ -338,6 +339,7 @@ class Config {
 
     // TODO: refactor
     this.apiKey = DD_API_KEY
+    this.appKey = DD_APP_KEY
 
     // sent in telemetry event app-started
     this.installSignature = {
@@ -485,6 +487,11 @@ class Config {
     const {
       AWS_LAMBDA_FUNCTION_NAME,
       DD_AGENT_HOST,
+      DD_AI_GUARD_ENABLED,
+      DD_AI_GUARD_ENDPOINT,
+      DD_AI_GUARD_MAX_CONTENT_SIZE,
+      DD_AI_GUARD_MAX_MESSAGES_LENGTH,
+      DD_AI_GUARD_TIMEOUT,
       DD_API_SECURITY_ENABLED,
       DD_API_SECURITY_SAMPLE_DELAY,
       DD_API_SECURITY_ENDPOINT_COLLECTION_ENABLED,
@@ -713,6 +720,14 @@ class Config {
     this._envUnprocessed['dynamicInstrumentation.uploadInterval'] = DD_DYNAMIC_INSTRUMENTATION_UPLOAD_INTERVAL_SECONDS
     this._setString(env, 'env', DD_ENV || tags.env)
     this._setBoolean(env, 'traceEnabled', DD_TRACE_ENABLED)
+    this._setBoolean(env, 'experimental.aiguard.enabled', DD_AI_GUARD_ENABLED)
+    this._setString(env, 'experimental.aiguard.endpoint', DD_AI_GUARD_ENDPOINT)
+    env['experimental.aiguard.maxContentSize'] = maybeInt(DD_AI_GUARD_MAX_CONTENT_SIZE)
+    this._envUnprocessed['experimental.aiguard.maxContentSize'] = DD_AI_GUARD_MAX_CONTENT_SIZE
+    env['experimental.aiguard.maxMessagesLength'] = maybeInt(DD_AI_GUARD_MAX_MESSAGES_LENGTH)
+    this._envUnprocessed['experimental.aiguard.maxMessagesLength'] = DD_AI_GUARD_MAX_MESSAGES_LENGTH
+    env['experimental.aiguard.timeout'] = maybeInt(DD_AI_GUARD_TIMEOUT)
+    this._envUnprocessed['experimental.aiguard.timeout'] = DD_AI_GUARD_TIMEOUT
     this._setBoolean(env, 'experimental.enableGetRumData', DD_TRACE_EXPERIMENTAL_GET_RUM_DATA_ENABLED)
     this._setString(env, 'experimental.exporter', DD_TRACE_EXPERIMENTAL_EXPORTER)
     if (AWS_LAMBDA_FUNCTION_NAME) env.flushInterval = 0
@@ -943,6 +958,14 @@ class Config {
     this._optsUnprocessed['dynamicInstrumentation.uploadIntervalSeconds'] =
       options.dynamicInstrumentation?.uploadIntervalSeconds
     this._setString(opts, 'env', options.env || tags.env)
+    this._setBoolean(opts, 'experimental.aiguard.enabled', options.experimental?.aiguard?.enabled)
+    this._setString(opts, 'experimental.aiguard.endpoint', options.experimental?.aiguard?.endpoint)
+    opts['experimental.aiguard.maxMessagesLength'] = maybeInt(options.experimental?.aiguard?.maxMessagesLength)
+    this._optsUnprocessed['experimental.aiguard.maxMessagesLength'] = options.experimental?.aiguard?.maxMessagesLength
+    opts['experimental.aiguard.maxContentSize'] = maybeInt(options.experimental?.aiguard?.maxContentSize)
+    this._optsUnprocessed['experimental.aiguard.maxContentSize'] = options.experimental?.aiguard?.maxContentSize
+    opts['experimental.aiguard.timeout'] = maybeInt(options.experimental?.aiguard?.timeout)
+    this._optsUnprocessed['experimental.aiguard.timeout'] = options.experimental?.aiguard?.timeout
     this._setBoolean(opts, 'experimental.enableGetRumData', options.experimental?.enableGetRumData)
     this._setString(opts, 'experimental.exporter', options.experimental?.exporter)
     opts.flushInterval = maybeInt(options.flushInterval)

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

@@ -68,6 +68,11 @@ module.exports = {
   'dynamicInstrumentation.redactionExcludedIdentifiers': [],
   'dynamicInstrumentation.uploadIntervalSeconds': 1,
   env: undefined,
+  'experimental.aiguard.enabled': false,
+  'experimental.aiguard.endpoint': undefined,
+  'experimental.aiguard.maxMessagesLength': 16,
+  'experimental.aiguard.maxContentSize': 512 * 1024,
+  'experimental.aiguard.timeout': 10_000, // ms
   'experimental.enableGetRumData': false,
   'experimental.exporter': undefined,
   flushInterval: 2000,

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

@@ -11,7 +11,14 @@ const {
 // plugins instead of having dedicated DSM plugins that are themselves
 // lazy loaded.
 //
-// TODO: Remove this when DSM has been moved to dedicaed plugins.
+// TODO: Remove this when DSM has been moved to dedicated plugins.
+/**
+ * @template T extends new (...args: any[]) => any
+ * @param {() => T} classGetter
+ * @param {string[]} methods
+ * @param {string[]} staticMethods
+ * @returns {T}
+ */
 function lazyClass (classGetter, methods = [], staticMethods = []) {
   let constructorArgs
   let ActiveClass
@@ -50,22 +57,34 @@ function lazyClass (classGetter, methods = [], staticMethods = []) {
   return LazyClass
 }
 
+/**
+ * @type {typeof import('./pathway').DsmPathwayCodec}
+ */
 const DsmPathwayCodec = lazyClass(() => require('./pathway').DsmPathwayCodec, [], [
   'encode',
   'decode'
 ])
 
+/**
+ * @type {typeof import('./checkpointer').DataStreamsCheckpointer}
+ */
 const DataStreamsCheckpointer = lazyClass(() => require('./checkpointer').DataStreamsCheckpointer, [
   'setProduceCheckpoint',
   'setConsumeCheckpoint'
 ])
 
+/**
+ * @type {typeof import('./manager').DataStreamsManager}
+ */
 const DataStreamsManager = lazyClass(() => require('./manager').DataStreamsManager, [
   'setCheckpoint',
   'decodeDataStreamsContext'
 ])
 
 // TODO: Are all those methods actually public?
+/**
+ * @type {typeof import('./processor').DataStreamsProcessor}
+ */
 const DataStreamsProcessor = lazyClass(() => require('./processor').DataStreamsProcessor, [
   'onInterval',
   'bucketFromTimestamp',
@@ -79,6 +98,9 @@ const DataStreamsProcessor = lazyClass(() => require('./processor').DataStreamsP
   'getSchema'
 ])
 
+/**
+ * @type {typeof import('./schemas/schema_builder').SchemaBuilder}
+ */
 const SchemaBuilder = lazyClass(() => require('./schemas/schema_builder').SchemaBuilder, [
   'build',
   'addProperty',

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

@@ -80,7 +80,7 @@ class VercelAILLMObsPlugin extends BaseLLMObsPlugin {
    * We use the tool description as the next best identifier for a tool.
    *
    * @param {string} toolDescription
-   * @returns {string}
+   * @returns {string | undefined}
    */
   findToolName (toolDescription) {
     for (const availableTool of this.#availableTools) {
@@ -91,6 +91,9 @@ class VercelAILLMObsPlugin extends BaseLLMObsPlugin {
     }
   }
 
+  /**
+   * @override
+   */
   getLLMObsSpanRegisterOptions (ctx) {
     const span = ctx.currentStore?.span
     const operation = getOperation(span)
@@ -100,6 +103,9 @@ class VercelAILLMObsPlugin extends BaseLLMObsPlugin {
     return { kind, name: getLlmObsSpanName(operation, ctx.attributes['ai.telemetry.functionId']) }
   }
 
+  /**
+   * @override
+   */
   setLLMObsTags (ctx) {
     const span = ctx.currentStore?.span
     if (!span) return
@@ -212,6 +218,10 @@ class VercelAILLMObsPlugin extends BaseLLMObsPlugin {
     this._tagger.tagMetadata(span, metadata)
   }
 
+  /**
+   * @param {import('../../../opentracing/span')} span
+   * @param {Record<string, unknown>} tags
+   */
   setLLMOperationTags (span, tags) {
     const toolsForModel = tags['ai.prompt.tools']?.map(getJsonStringValue)
 

package/packages/dd-trace/src/llmobs/plugins/ai/util.js

@@ -34,7 +34,7 @@ function getSpanTags (ctx) {
  * getOperation(span) // 'doGenerate'
  *
  * @param {import('../../../opentracing/span')} span
- * @returns {string}
+ * @returns {string | undefined}
  */
 function getOperation (span) {
   const name = span._name
@@ -45,8 +45,9 @@ function getOperation (span) {
 
 /**
  * Get the LLM token usage from the span tags
- * @param {Record<string, string>} tags
- * @returns {{inputTokens: number, outputTokens: number, totalTokens: number}}
+ * @template T extends {inputTokens: number, outputTokens: number, totalTokens: number}
+ * @param {T} tags
+ * @returns {Pick<T, 'inputTokens' | 'outputTokens' | 'totalTokens'>}
  */
 function getUsage (tags) {
   const usage = {}
@@ -64,9 +65,10 @@ function getUsage (tags) {
 
 /**
  * Safely JSON parses a string value with a default fallback
+ * @template T typeof defaultValue
  * @param {string} str
- * @param {any} defaultValue
- * @returns {Record<string, any> | string | Array<any>}
+ * @param {T} defaultValue
+ * @returns {Record<string, unknown> | string | Array<unknown> | null | T}
  */
 function getJsonStringValue (str, defaultValue) {
   let maybeValue = defaultValue
@@ -81,7 +83,7 @@ function getJsonStringValue (str, defaultValue) {
 
 /**
  * Get the model metadata from the span tags (top_p, top_k, temperature, etc.)
- * @param {import('../../../opentracing/span')} span
+ * @param {Record<string, unknown>} tags
  * @returns {Record<string, string> | null}
  */
 function getModelMetadata (tags) {

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

@@ -111,11 +111,11 @@ const log = {
 
   isEnabled (fleetStableConfigValue, localStableConfigValue) {
     return isTrue(
-      (fleetStableConfigValue ??
+      fleetStableConfigValue ??
       getEnvironmentVariable('DD_TRACE_DEBUG') ??
-      getEnvironmentVariable('OTEL_LOG_LEVEL') === 'debug') ||
-      (localStableConfigValue ??
-      config.enabled)
+      (getEnvironmentVariable('OTEL_LOG_LEVEL') === 'debug' || undefined) ??
+      localStableConfigValue ??
+      config.enabled
     )
   },
 

package/packages/dd-trace/src/noop/proxy.js

@@ -4,18 +4,22 @@ const NoopTracer = require('./tracer')
 const NoopAppsecSdk = require('../appsec/sdk/noop')
 const NoopDogStatsDClient = require('./dogstatsd')
 const NoopLLMObsSDK = require('../llmobs/noop')
+const NoopAIGuardSDK = require('../aiguard/noop')
 
 const noop = new NoopTracer()
 const noopAppsec = new NoopAppsecSdk()
 const noopDogStatsDClient = new NoopDogStatsDClient()
 const noopLLMObs = new NoopLLMObsSDK(noop)
+const noopAIGuard = new NoopAIGuardSDK()
 
+/** @type {import('../../src/index')} Proxy */
 class NoopProxy {
   constructor () {
     this._tracer = noop
     this.appsec = noopAppsec
     this.dogstatsd = noopDogStatsDClient
     this.llmobs = noopLLMObs
+    this.aiguard = noopAIGuard
     this.setBaggageItem = () => {}
     this.getBaggageItem = () => {}
     this.getAllBaggageItems = () => {}

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

@@ -146,7 +146,7 @@ class DatadogSpan {
   }
 
   /**
-   * @returns {DatadogSpanContext}
+   * @returns {import('../priority_sampler').DatadogSpanContext}
    */
   context () {
     return this._spanContext

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

@@ -3,6 +3,14 @@
 const aws = require('./aws.json')
 const sdks = { aws }
 
+/**
+ * Builds rules per service for a given SDK, appending user-provided rules.
+ *
+ * @param {Record<string, { request: string[], response: string[], expand: string[] }>} sdk
+ * @param {string[]} requestInput
+ * @param {string[]} responseInput
+ * @returns {Record<string, { request: string[], response: string[], expand: string[] }>}
+ */
 function getSDKRules (sdk, requestInput, responseInput) {
   const sdkServiceRules = {}
   for (const [service, serviceRules] of Object.entries(sdk)) {
@@ -17,6 +25,14 @@ function getSDKRules (sdk, requestInput, responseInput) {
   return sdkServiceRules
 }
 
+/**
+ * Appends input rules to all supported SDKs and returns a structure mapping SDK
+ * names to per-service rules.
+ *
+ * @param {string[]} [requestInput=[]]
+ * @param {string[]} [responseInput=[]]
+ * @returns {Record<string, Record<string, { request: string[], response: string[], expand: string[] }>>}
+ */
 function appendRules (requestInput = [], responseInput = []) {
   const sdkRules = {}
   for (const [name, sdk] of Object.entries(sdks)) {