dd-trace 5.102.0 → 5.103.0

package/packages/dd-trace/src/exporters/electron/index.js

@@ -0,0 +1,49 @@
+'use strict'
+
+const { channel } = require('dc-polyfill')
+const { truncateSpan, normalizeSpan } = require('../../encode/tags-processors')
+
+const traceChannel = channel('datadog:apm:electron:export')
+
+class ElectronExporter {
+  #timer
+  #traces = []
+
+  constructor (config) {
+    this._config = config
+
+    globalThis[Symbol.for('dd-trace')].beforeExitHandlers.add(this.flush.bind(this))
+  }
+
+  export (spans) {
+    this.#traces.push(spans)
+
+    const { flushInterval } = this._config
+
+    if (flushInterval === 0) {
+      this.flush()
+    } else if (this.#timer === undefined) {
+      this.#timer = setTimeout(() => {
+        this.flush()
+        this.#timer = undefined
+      }, flushInterval)
+      this.#timer.unref?.()
+    }
+  }
+
+  flush (done = () => {}) {
+    clearTimeout(this.#timer)
+    this.#timer = undefined
+
+    const traces = this.#traces.splice(0)
+
+    if (traces.length > 0 && traceChannel.hasSubscribers) {
+      const formattedTraces = traces.map(spans => spans.map(span => normalizeSpan(truncateSpan(span))))
+      traceChannel.publish(formattedTraces)
+    }
+
+    done()
+  }
+}
+
+module.exports = ElectronExporter

package/packages/dd-trace/src/external-logger/src/index.js

@@ -26,7 +26,8 @@ class ExternalLogger {
     }
     this.timer = setInterval(() => {
       this.flush()
-    }, this.interval).unref()
+    }, this.interval)
+    this.timer.unref?.()
 
     tracerLogger.debug(`started log writer to https://${this.intake}${this.endpoint}`)
   }

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

@@ -12,19 +12,21 @@ const {
   resolveGitHeadSHA,
 } = require('./config/git_properties')
 
-/** @type {{ commitSHA: string | undefined, repositoryUrl: string | undefined } | undefined} */
-let cached
+/**
+ * @typedef {{ commitSHA: string | undefined, repositoryUrl: string | undefined }} GitMetadata
+ * @type {{ enabled?: GitMetadata, disabled?: GitMetadata }}
+ */
+const cache = {}
 
 /**
  * @param {import('./config/config-types').ConfigProperties} config
  */
 function getGitMetadata (config) {
-  if (cached) return cached
-
   if (!config.DD_TRACE_GIT_METADATA_ENABLED) {
-    cached = { commitSHA: undefined, repositoryUrl: undefined }
-    return cached
+    cache.disabled ??= { commitSHA: undefined, repositoryUrl: undefined }
+    return cache.disabled
   }
+  if (cache.enabled) return cache.enabled
 
   let repositoryUrl = removeUserSensitiveInfo(config.DD_GIT_REPOSITORY_URL ?? config.tags[GIT_REPOSITORY_URL])
   let commitSHA = config.DD_GIT_COMMIT_SHA ?? config.tags[GIT_COMMIT_SHA]
@@ -59,8 +61,8 @@ function getGitMetadata (config) {
 
   commitSHA ??= resolveGitHeadSHA(gitFolderPath)
 
-  cached = { commitSHA, repositoryUrl }
-  return cached
+  cache.enabled = { commitSHA, repositoryUrl }
+  return cache.enabled
 }
 
 module.exports = getGitMetadata

package/packages/dd-trace/src/lambda/handler-paths.js

@@ -0,0 +1,52 @@
+/**
+ * Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Modifications copyright 2022 Datadog, Inc.
+ *
+ * Some functions are part of aws-lambda-nodejs-runtime-interface-client
+ * https://github.com/aws/aws-lambda-nodejs-runtime-interface-client/blob/v2.1.0/src/utils/UserFunction.ts
+ */
+'use strict'
+
+const path = require('path')
+
+/**
+ * Example: `'./api/src/index.nested.handler'` → `['./api/src/', 'index.nested.handler']`.
+ *
+ * @param {string} fullHandler
+ */
+function extractModuleRootAndHandler (fullHandler) {
+  const handlerString = path.basename(fullHandler)
+  const moduleRoot = fullHandler.slice(0, Math.max(0, fullHandler.indexOf(handlerString)))
+  return [moduleRoot, handlerString]
+}
+
+/**
+ * Example: `'index.nested.handler'` → `['index', 'nested.handler']`.
+ *
+ * @param {string} handler
+ * @throws {Error} When the handler is not of the form `<module>.<path>`.
+ */
+function extractModuleNameAndHandlerPath (handler) {
+  const match = handler.match(/^([^.]*)\.(.*)$/)
+  if (!match || match.length !== 3) {
+    throw new Error(`Malformed handler name: ${handler}`)
+  }
+  return [match[1], match[2]]
+}
+
+/**
+ * @param {string} lambdaStylePath `LAMBDA_TASK_ROOT` joined with the module root and module name.
+ */
+function getLambdaFilePaths (lambdaStylePath) {
+  return [
+    `${lambdaStylePath}.js`,
+    `${lambdaStylePath}.mjs`,
+    `${lambdaStylePath}.cjs`,
+  ]
+}
+
+module.exports = {
+  extractModuleRootAndHandler,
+  extractModuleNameAndHandlerPath,
+  getLambdaFilePaths,
+}

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

@@ -1,17 +1,65 @@
 'use strict'
 
-const { getValueFromEnvSources } = require('../config/helper')
-const { registerLambdaHook } = require('./runtime/ritm')
-
-/**
- * It is safe to do it this way, since customers will never be expected to disable
- * this specific instrumentation through the init config object.
- */
-const _DD_TRACE_DISABLED_INSTRUMENTATIONS = getValueFromEnvSources('DD_TRACE_DISABLED_INSTRUMENTATIONS') || ''
-const _disabledInstrumentations = new Set(
-  _DD_TRACE_DISABLED_INSTRUMENTATIONS ? _DD_TRACE_DISABLED_INSTRUMENTATIONS.split(',') : []
-)
-
-if (!_disabledInstrumentations.has('lambda')) {
-  registerLambdaHook()
+const path = require('path')
+
+const log = require('../log')
+const { getEnvironmentVariable, getValueFromEnvSources } = require('../config/helper')
+const Hook = require('../../../datadog-instrumentations/src/helpers/hook')
+const instrumentations = require('../../../datadog-instrumentations/src/helpers/instrumentations')
+const {
+  filename,
+  pathSepExpr,
+} = require('../../../datadog-instrumentations/src/helpers/register')
+const {
+  extractModuleNameAndHandlerPath,
+  extractModuleRootAndHandler,
+  getLambdaFilePaths,
+} = require('./handler-paths')
+
+if (!getValueFromEnvSources('DD_TRACE_DISABLED_INSTRUMENTATIONS')?.split(',').includes('lambda')) {
+  const lambdaTaskRoot = getEnvironmentVariable('LAMBDA_TASK_ROOT')
+  const originalLambdaHandler = getValueFromEnvSources('DD_LAMBDA_HANDLER')
+
+  if (originalLambdaHandler !== undefined && lambdaTaskRoot !== undefined) {
+    const [moduleRoot, moduleAndHandler] = extractModuleRootAndHandler(originalLambdaHandler)
+    const [moduleName] = extractModuleNameAndHandlerPath(moduleAndHandler)
+
+    const lambdaStylePath = path.resolve(lambdaTaskRoot, moduleRoot, moduleName)
+    const lambdaFilePaths = getLambdaFilePaths(lambdaStylePath)
+
+    // TODO: Redo this like any other instrumentation.
+    Hook(lambdaFilePaths, (moduleExports, name, _, moduleVersion) => {
+      require('./runtime/patch')
+
+      for (const { hook } of instrumentations[name]) {
+        try {
+          moduleExports = hook(moduleExports, moduleVersion) ?? moduleExports
+        } catch (error) {
+          log.error('Error executing lambda hook', error)
+        }
+      }
+
+      return moduleExports
+    })
+    return
+  }
+
+  const moduleToPatch = 'datadog-lambda-js'
+  Hook([moduleToPatch], (moduleExports, moduleName, _, moduleVersion) => {
+    moduleName = moduleName.replace(pathSepExpr, '/')
+    require('./runtime/patch')
+
+    for (const { file, hook } of instrumentations[moduleToPatch]) {
+      const fullFilename = filename(moduleToPatch, file)
+      if (moduleName === fullFilename) {
+        try {
+          moduleExports = hook(moduleExports, moduleVersion) ?? moduleExports
+        } catch (error) {
+          log.error('Error executing lambda hook for datadog-lambda-js', error)
+        }
+      }
+    }
+
+    return moduleExports
+  })
 }

package/packages/dd-trace/src/lambda/runtime/patch.js

@@ -6,54 +6,32 @@ const { datadog } = require('../handler')
 const { addHook } = require('../../../../datadog-instrumentations/src/helpers/instrument')
 const shimmer = require('../../../../datadog-shimmer')
 const { getEnvironmentVariable, getValueFromEnvSources } = require('../../config/helper')
-const { _extractModuleNameAndHandlerPath, _extractModuleRootAndHandler, _getLambdaFilePaths } = require('./ritm')
-
-/**
- * Patches a Datadog Lambda module by calling `patchDatadogLambdaHandler`
- * with the handler name `datadog`.
- *
- * @param {object} datadogLambdaModule node module to be patched.
- * @returns a Datadog Lambda module with the `datadog` function from
- * `datadog-lambda-js` patched.
- */
-const patchDatadogLambdaModule = (datadogLambdaModule) => {
+const {
+  extractModuleNameAndHandlerPath,
+  extractModuleRootAndHandler,
+  getLambdaFilePaths,
+} = require('../handler-paths')
+
+/** @param {object} datadogLambdaModule */
+function patchDatadogLambdaModule (datadogLambdaModule) {
   shimmer.wrap(datadogLambdaModule, 'datadog', patchDatadogLambdaHandler)
-
   return datadogLambdaModule
 }
 
-/**
- * Patches a Datadog Lambda handler in order to do
- * Datadog instrumentation by getting the Lambda handler from its
- * arguments.
- *
- * @param {Function} datadogHandler the Datadog Lambda handler to destructure.
- * @returns the datadogHandler with its arguments patched.
- */
+/** @param {Function} datadogHandler */
 function patchDatadogLambdaHandler (datadogHandler) {
-  return (userHandler) => {
-    return datadogHandler(datadog(userHandler))
-  }
+  return userHandler => datadogHandler(datadog(userHandler))
 }
 
-/**
- * Patches a Lambda module on the given handler path.
- *
- * @param {string} handlerPath path of the handler to be patched.
- * @returns a module with the given handler path patched.
- */
-const patchLambdaModule = (handlerPath) => (lambdaModule) => {
-  shimmer.wrap(lambdaModule, handlerPath, patchLambdaHandler)
-
-  return lambdaModule
+/** @param {string} handlerPath */
+function patchLambdaModule (handlerPath) {
+  return lambdaModule => {
+    shimmer.wrap(lambdaModule, handlerPath, patchLambdaHandler)
+    return lambdaModule
+  }
 }
 
-/**
- * Patches a Lambda handler in order to do Datadog instrumentation.
- *
- * @param {Function} lambdaHandler the Lambda handler to be patched.
- * @returns a function which patches the given Lambda handler.
- */
+/** @param {Function} lambdaHandler */
 function patchLambdaHandler (lambdaHandler) {
   return datadog(lambdaHandler)
 }
@@ -62,16 +40,13 @@ const lambdaTaskRoot = getEnvironmentVariable('LAMBDA_TASK_ROOT')
 const originalLambdaHandler = getValueFromEnvSources('DD_LAMBDA_HANDLER')
 
 if (originalLambdaHandler === undefined) {
-  // Instrumentation is done manually.
   addHook({ name: 'datadog-lambda-js' }, patchDatadogLambdaModule)
 } else {
-  const [moduleRoot, moduleAndHandler] = _extractModuleRootAndHandler(originalLambdaHandler)
-  const [_module, handlerPath] = _extractModuleNameAndHandlerPath(moduleAndHandler)
-
-  const lambdaStylePath = path.resolve(lambdaTaskRoot, moduleRoot, _module)
-  const lambdaFilePaths = _getLambdaFilePaths(lambdaStylePath)
+  const [moduleRoot, moduleAndHandler] = extractModuleRootAndHandler(originalLambdaHandler)
+  const [moduleName, handlerPath] = extractModuleNameAndHandlerPath(moduleAndHandler)
 
-  for (const lambdaFilePath of lambdaFilePaths) {
+  const lambdaStylePath = path.resolve(lambdaTaskRoot, moduleRoot, moduleName)
+  for (const lambdaFilePath of getLambdaFilePaths(lambdaStylePath)) {
     addHook({ name: lambdaFilePath }, patchLambdaModule(handlerPath))
   }
 }

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

@@ -108,6 +108,10 @@ function disable () {
 // since LLMObs traces can extend between services and be the same trace,
 // we need to propagate the parent id and mlApp.
 function handleLLMObsParentIdInjection ({ carrier }) {
+  // Respect the standard propagator's gate: when trace tag propagation is
+  // disabled, don't write `x-datadog-tags` for LLMObs either.
+  if (globalTracerConfig.DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH === 0) return
+
   const parent = storage.getStore()?.span
   const mlObsSpanTags = LLMObsTagger.tagMap.get(parent)
 
@@ -118,8 +122,15 @@ function handleLLMObsParentIdInjection ({ carrier }) {
     parentContext?._trace?.tags?.[PROPAGATED_ML_APP_KEY] ||
     globalTracerConfig.llmobs.mlApp
 
-  if (parentId) carrier['x-datadog-tags'] += `,${PROPAGATED_PARENT_ID_KEY}=${parentId}`
-  if (mlApp) carrier['x-datadog-tags'] += `,${PROPAGATED_ML_APP_KEY}=${mlApp}`
+  if (!parentId && !mlApp) return
+
+  // `_injectTags` only writes `x-datadog-tags` when the trace has `_dd.p.*`
+  // tags, so it may be undefined here — coalesce before appending.
+  const existing = carrier['x-datadog-tags']
+  let tags = existing || ''
+  if (parentId) tags += `${tags ? ',' : ''}${PROPAGATED_PARENT_ID_KEY}=${parentId}`
+  if (mlApp) tags += `${tags ? ',' : ''}${PROPAGATED_ML_APP_KEY}=${mlApp}`
+  if (tags !== existing) carrier['x-datadog-tags'] = tags
 }
 
 function handleFlush () {

package/packages/dd-trace/src/llmobs/plugins/bedrockruntime.js

@@ -14,7 +14,17 @@ const llmobsStore = storage('llmobs')
 
 const ENABLED_OPERATIONS = new Set(['invokeModel', 'invokeModelWithResponseStream'])
 
-const requestIdsToTokens = {}
+/**
+ * @typedef {{
+ *   inputTokensFromHeaders?: number,
+ *   outputTokensFromHeaders?: number,
+ *   cacheReadTokensFromHeaders?: number,
+ *   cacheWriteTokensFromHeaders?: number,
+ * }} HeaderTokens
+ */
+
+/** @type {Map<string, HeaderTokens>} */
+const pendingTokenHeaders = new Map()
 
 class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
   constructor () {
@@ -24,33 +34,39 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
       const { response } = ctx
       const request = response.request
       const operation = request.operation
+
+      // Release the cached headers even for operations the plugin does not tag,
+      // so non-LLM Bedrock calls do not leak entries into pendingTokenHeaders.
+      const tokensFromHeaders = consumeTokenHeaders(response.$metadata?.requestId)
+
       // avoids instrumenting other non supported runtime operations
-      if (!ENABLED_OPERATIONS.has(operation)) {
-        return
-      }
+      if (!ENABLED_OPERATIONS.has(operation)) return
+
       const { modelProvider, modelName } = parseModelId(request.params.modelId)
 
       // avoids instrumenting non llm type
-      if (modelName.includes('embed')) {
-        return
-      }
+      if (modelName.includes('embed')) return
+
       const span = ctx.currentStore?.span
-      this.setLLMObsTags({ ctx, request, span, response, modelProvider, modelName })
+      this.setLLMObsTags({ ctx, request, span, response, modelProvider, modelName, tokensFromHeaders })
     })
 
     this.addSub('apm:aws:response:deserialize:bedrockruntime', ({ headers }) => {
       const requestId = headers['x-amzn-requestid']
+      // No request id means no way to correlate with the :complete: event.
+      if (!requestId) return
+
       const inputTokenCount = headers['x-amzn-bedrock-input-token-count']
       const outputTokenCount = headers['x-amzn-bedrock-output-token-count']
       const cacheReadTokenCount = headers['x-amzn-bedrock-cache-read-input-token-count']
       const cacheWriteTokenCount = headers['x-amzn-bedrock-cache-write-input-token-count']
 
-      requestIdsToTokens[requestId] = {
+      pendingTokenHeaders.set(requestId, {
         inputTokensFromHeaders: inputTokenCount && Number.parseInt(inputTokenCount),
         outputTokensFromHeaders: outputTokenCount && Number.parseInt(outputTokenCount),
         cacheReadTokensFromHeaders: cacheReadTokenCount && Number.parseInt(cacheReadTokenCount),
         cacheWriteTokensFromHeaders: cacheWriteTokenCount && Number.parseInt(cacheWriteTokenCount),
-      }
+      })
     })
 
     this.addSub('apm:aws:response:streamed-chunk:bedrockruntime', ({ ctx, chunk }) => {
@@ -60,7 +76,7 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
     })
   }
 
-  setLLMObsTags ({ ctx, request, span, response, modelProvider, modelName }) {
+  setLLMObsTags ({ ctx, request, span, response, modelProvider, modelName, tokensFromHeaders }) {
     const isStream = request?.operation?.toLowerCase().includes('stream')
     telemetry.incrementLLMObsSpanStartCount({ autoinstrumented: true, integration: 'bedrock' })
 
@@ -97,7 +113,7 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
 
     // add token metrics
     const { inputTokens, outputTokens, totalTokens, cacheReadTokens, cacheWriteTokens } = extractTokens({
-      requestId: response.$metadata.requestId,
+      tokensFromHeaders,
       usage: textAndResponseReason.usage,
     })
     this._tagger.tagMetrics(span, {
@@ -110,14 +126,28 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
   }
 }
 
-function extractTokens ({ requestId, usage }) {
+/**
+ * @param {string | undefined} requestId
+ * @returns {HeaderTokens | undefined}
+ */
+function consumeTokenHeaders (requestId) {
+  const tokens = pendingTokenHeaders.get(requestId)
+  pendingTokenHeaders.delete(requestId)
+  return tokens
+}
+
+/**
+ * Combine response-body usage with header-derived counts, preferring the body.
+ *
+ * @param {{ tokensFromHeaders: HeaderTokens | undefined, usage: Record<string, number | undefined> }} options
+ */
+function extractTokens ({ tokensFromHeaders, usage }) {
   const {
     inputTokensFromHeaders,
     outputTokensFromHeaders,
     cacheReadTokensFromHeaders,
     cacheWriteTokensFromHeaders,
-  } = requestIdsToTokens[requestId] || {}
-  delete requestIdsToTokens[requestId]
+  } = tokensFromHeaders ?? {}
 
   const inputTokens = usage.inputTokens || inputTokensFromHeaders || 0
   const outputTokens = usage.outputTokens || outputTokensFromHeaders || 0

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

@@ -54,7 +54,8 @@ class BaseLLMObsWriter {
 
     this._periodic = setInterval(() => {
       this.flush()
-    }, this._interval).unref()
+    }, this._interval)
+    this._periodic.unref?.()
 
     const destroyer = this.destroy.bind(this)
     globalThis[Symbol.for('dd-trace')].beforeExitHandlers.add(destroyer)

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

@@ -55,7 +55,8 @@ class BaseFFEWriter {
 
     this._periodic = setInterval(() => {
       this.flush()
-    }, this._interval).unref()
+    }, this._interval)
+    this._periodic.unref?.()
 
     const destroyer = this.destroy.bind(this)
     globalThis[Symbol.for('dd-trace')].beforeExitHandlers.add(destroyer)

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

@@ -167,7 +167,8 @@ class PeriodicMetricReader {
 
     this.#timer = setInterval(() => {
       this.#collectAndExport()
-    }, this.#exportInterval).unref()
+    }, this.#exportInterval)
+    this.#timer.unref?.()
   }
 
   /**

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

@@ -9,6 +9,7 @@ const tags = require('../../../../../ext/tags')
 const { getConfiguredEnvName } = require('../../config/helper')
 const { setAllBaggageItems, getAllBaggageItems, removeAllBaggageItems } = require('../../baggage')
 const telemetryMetrics = require('../../telemetry/metrics')
+const { DD_MAJOR } = require('../../../../../version')
 
 const { AUTO_KEEP, AUTO_REJECT, USER_KEEP } = require('../../../../../ext/priority')
 const TraceState = require('./tracestate')
@@ -78,10 +79,17 @@ class TextMapPropagator {
   constructor (config) {
     this._config = config
 
-    // TODO: should match "b3 single header" in next major
-    const envName = getConfiguredEnvName('DD_TRACE_PROPAGATION_STYLE')
-    // eslint-disable-next-line eslint-rules/eslint-env-aliases
-    this.#extractB3Context = envName === 'OTEL_PROPAGATORS' ? this._extractB3SingleContext : this._extractB3MultiContext
+    // v6: `'b3'` is always single-header. v5: env-name decides — OTEL_PROPAGATORS callers expect
+    // single, the legacy `DD_TRACE_PROPAGATION_STYLE` callers expect multi.
+    if (DD_MAJOR >= 6) {
+      this.#extractB3Context = this._extractB3SingleContext
+    } else {
+      const envName = getConfiguredEnvName('DD_TRACE_PROPAGATION_STYLE')
+      // eslint-disable-next-line eslint-rules/eslint-env-aliases
+      this.#extractB3Context = envName === 'OTEL_PROPAGATORS'
+        ? this._extractB3SingleContext
+        : this._extractB3MultiContext
+    }
   }
 
   /**
@@ -262,9 +270,10 @@ class TextMapPropagator {
   }
 
   _injectB3MultipleHeaders (spanContext, carrier) {
-    const hasB3 = this._hasPropagationStyle('inject', 'b3')
-    const hasB3multi = this._hasPropagationStyle('inject', 'b3multi')
-    if (!(hasB3 || hasB3multi)) return
+    // v5 also accepts the legacy `'b3'` spelling for multi; v6 routes `'b3'` to single-header.
+    const hasB3multi = this._hasPropagationStyle('inject', 'b3multi') ||
+      (DD_MAJOR < 6 && this._hasPropagationStyle('inject', 'b3'))
+    if (!hasB3multi) return
 
     carrier[b3TraceKey] = this._getB3TraceId(spanContext)
     carrier[b3SpanKey] = spanContext._spanId.toString(16)
@@ -280,7 +289,9 @@ class TextMapPropagator {
   }
 
   _injectB3SingleHeader (spanContext, carrier) {
-    const hasB3SingleHeader = this._hasPropagationStyle('inject', 'b3 single header')
+    // v6 keeps `'b3 single header'` as a back-compat alias for callers that bypass parser normalisation.
+    const hasB3SingleHeader = this._hasPropagationStyle('inject', 'b3 single header') ||
+      (DD_MAJOR >= 6 && this._hasPropagationStyle('inject', 'b3'))
     if (!hasB3SingleHeader) return null
 
     const traceId = this._getB3TraceId(spanContext)
@@ -394,7 +405,7 @@ class TextMapPropagator {
         case 'tracecontext':
           extractedContext = this._extractTraceparentContext(carrier)
           break
-        case 'b3 single header': // TODO: delete in major after singular "b3"
+        case 'b3 single header':
           extractedContext = this._extractB3SingleContext(carrier)
           break
         case 'b3':

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

@@ -30,8 +30,8 @@ function getSDKRules (sdk, requestInput, responseInput) {
  * Appends input rules to all supported SDKs and returns a structure mapping SDK
  * names to per-service rules.
  *
- * @param {string[]} [requestInput=[]]
- * @param {string[]} [responseInput=[]]
+ * @param {string[]} [requestInput]
+ * @param {string[]} [responseInput]
  * @returns {Record<string, SDKRules>}
  */
 function appendRules (requestInput = [], responseInput = []) {