dd-trace 5.101.0 → 5.102.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.101.0",
+  "version": "5.102.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -8,6 +8,7 @@
     "env": "bash ./plugin-env",
     "prepare": "cd vendor && npm ci --include=dev",
     "preinstall": "node scripts/preinstall.js",
+    "prepack": "node scripts/release/swap-v5-types.js",
     "bench": "node benchmark/index.js",
     "bench:e2e:test-optimization": "node benchmark/e2e-test-optimization/benchmark-run.js",
     "dependencies:dedupe": "yarn-deduplicate yarn.lock",
@@ -18,8 +19,8 @@
     "type:check": "tsc --noEmit -p tsconfig.dev.json",
     "type:doc:build": "cd docs && yarn && yarn build",
     "type:doc:test": "cd docs && yarn && yarn test",
-    "lint": "node scripts/check_licenses.js && node scripts/check-no-coverage-artifacts.js && node scripts/check-no-mcr-images.js && eslint . --concurrency=auto --max-warnings 0",
-    "lint:fix": "node scripts/check_licenses.js && node scripts/check-no-coverage-artifacts.js && node scripts/check-no-mcr-images.js && eslint . --concurrency=auto --max-warnings 0 --fix",
+    "lint": "node scripts/check_licenses.js && node scripts/check-no-coverage-artifacts.js && node scripts/check-no-mcr-images.js && node scripts/check-docker-image-shas.js && eslint . --concurrency=auto --max-warnings 0",
+    "lint:fix": "node scripts/check_licenses.js && node scripts/check-no-coverage-artifacts.js && node scripts/check-no-mcr-images.js && node scripts/check-docker-image-shas.js && eslint . --concurrency=auto --max-warnings 0 --fix",
     "lint:inspect": "npx @eslint/config-inspector@latest",
     "lint:codeowners": "codeowners-audit",
     "lint:codeowners:ci": "codeowners-audit --glob='**/*.spec.js' --glob='benchmark/sirun/**'",
@@ -83,16 +84,16 @@
     "test:integration:webpack": "mocha --timeout 60000 \"integration-tests/webpack/*.spec.js\"",
     "test:integration:openfeature": "mocha --timeout 60000 \"integration-tests/openfeature/*.spec.js\"",
     "test:integration:openfeature:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 60000 \"integration-tests/openfeature/*.spec.js\"",
-    "test:integration:jest": "mocha --timeout 60000 \"integration-tests/jest/*.spec.js\"",
-    "test:integration:jest:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 60000 \"integration-tests/jest/*.spec.js\"",
+    "test:integration:jest": "mocha --timeout 60000 \"integration-tests/jest/${SPEC:-jest*}.spec.js\"",
+    "test:integration:jest:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 60000 \"integration-tests/jest/${SPEC:-jest*}.spec.js\"",
     "test:integration:mocha": "mocha --timeout 60000 \"integration-tests/mocha/*.spec.js\"",
     "test:integration:mocha:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 60000 \"integration-tests/mocha/*.spec.js\"",
     "test:integration:playwright": "mocha --timeout 60000 \"integration-tests/playwright/${SPEC:-playwright-*}.spec.js\"",
     "test:integration:playwright:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 60000 \"integration-tests/playwright/${SPEC:-playwright-*}.spec.js\"",
     "test:integration:selenium": "mocha --timeout 60000 \"integration-tests/selenium/*.spec.js\"",
     "test:integration:selenium:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 60000 \"integration-tests/selenium/*.spec.js\"",
-    "test:integration:vitest": "mocha --timeout 60000 \"integration-tests/vitest/*.spec.js\"",
-    "test:integration:vitest:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 60000 \"integration-tests/vitest/*.spec.js\"",
+    "test:integration:vitest": "mocha --timeout 60000 \"integration-tests/vitest/${SPEC:-vitest*}.spec.js\"",
+    "test:integration:vitest:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 60000 \"integration-tests/vitest/${SPEC:-vitest*}.spec.js\"",
     "test:integration:testopt": "mocha --timeout 120000 \"integration-tests/ci-visibility/*.spec.js\"",
     "test:integration:testopt:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 120000 \"integration-tests/ci-visibility/*.spec.js\"",
     "test:integration:profiler": "mocha --timeout 180000 \"integration-tests/profiler/*.spec.js\"",
@@ -198,6 +199,7 @@
     "eslint-plugin-mocha": "^11.2.0",
     "eslint-plugin-n": "^17.23.2",
     "eslint-plugin-promise": "^7.3.0",
+    "eslint-plugin-sonarjs": "^4.0.3",
     "eslint-plugin-unicorn": "^64.0.0",
     "express": "^5.1.0",
     "glob": "^10.4.5",

package/packages/datadog-instrumentations/src/aerospike.js

@@ -12,8 +12,8 @@ const ch = tracingChannel('apm:aerospike:command')
 function wrapCreateCommand (createCommand) {
   if (typeof createCommand !== 'function') return createCommand
 
-  return function commandWithTrace () {
-    const CommandClass = createCommand.apply(this, arguments)
+  return function commandWithTrace (...args) {
+    const CommandClass = createCommand.apply(this, args)
 
     if (!CommandClass) return CommandClass
 

package/packages/datadog-instrumentations/src/ai.js

@@ -119,17 +119,17 @@ function wrapTracer (tracer) {
   tracers.add(tracer)
 
   shimmer.wrap(tracer, 'startActiveSpan', function (startActiveSpan) {
-    return function () {
-      const name = arguments[0]
-      const options = arguments.length > 2 ? (arguments[1] ?? {}) : {} // startActiveSpan(name, fn)
-      const cb = arguments[arguments.length - 1]
+    return function (...args) {
+      const name = args[0]
+      const options = args.length > 2 ? (args[1] ?? {}) : {} // startActiveSpan(name, fn)
+      const cb = args[args.length - 1]
 
       const ctx = {
         name,
         attributes: options.attributes ?? {},
       }
 
-      arguments[arguments.length - 1] = shimmer.wrapFunction(cb, function (originalCb) {
+      args[args.length - 1] = shimmer.wrapFunction(cb, function (originalCb) {
         return function (span) {
           // the below is necessary in the case that the span is vercel ai's noopSpan.
           // while we don't want to patch the noopSpan more than once, we do want to treat each as a
@@ -138,9 +138,9 @@ function wrapTracer (tracer) {
           const freshSpan = Object.create(span) // TODO: does this cause memory leaks?
 
           shimmer.wrap(freshSpan, 'end', function (spanEnd) {
-            return function () {
+            return function (...args) {
               vercelAiTracingChannel.asyncEnd.publish(ctx)
-              return spanEnd.apply(this, arguments)
+              return spanEnd.apply(this, args)
             }
           })
 
@@ -164,7 +164,7 @@ function wrapTracer (tracer) {
       })
 
       return vercelAiTracingChannel.start.runStores(ctx, () => {
-        const result = startActiveSpan.apply(this, arguments)
+        const result = startActiveSpan.apply(this, args)
         vercelAiTracingChannel.end.publish(ctx)
         return result
       })

package/packages/datadog-instrumentations/src/amqplib.js

@@ -35,14 +35,13 @@ addHook({ name: 'amqplib', file: 'lib/defs.js', versions: [MIN_VERSION] }, defs
 addHook({ name: 'amqplib', file: 'lib/channel_model.js', versions: [MIN_VERSION] }, x => {
   shimmer.wrap(x.Channel.prototype, 'get', getMessage => function (queue, options) {
     return getMessage.apply(this, arguments).then(message => {
-      if (message === null) {
-        return message
+      if (message !== null) {
+        const ctx = { method: 'basic.get', message, fields: message.fields, queue }
+        consumeStartCh.runStores(ctx, () => {
+          // finish right away
+          consumeFinishCh.publish(ctx)
+        })
       }
-      const ctx = { method: 'basic.get', message, fields: message.fields, queue }
-      consumeStartCh.runStores(ctx, () => {
-        // finish right away
-        consumeFinishCh.publish(ctx)
-      })
       return message
     })
   })

package/packages/datadog-instrumentations/src/anthropic.js

@@ -8,10 +8,10 @@ const anthropicTracingChannel = tracingChannel('apm:anthropic:request')
 const onStreamedChunkCh = channel('apm:anthropic:request:chunk')
 
 function wrapStreamIterator (iterator, ctx) {
-  return function () {
-    const itr = iterator.apply(this, arguments)
-    shimmer.wrap(itr, 'next', next => function () {
-      return next.apply(this, arguments)
+  return function (...args) {
+    const itr = iterator.apply(this, args)
+    shimmer.wrap(itr, 'next', next => function (...args) {
+      return next.apply(this, args)
         .then(res => {
           const { done, value: chunk } = res
           onStreamedChunkCh.publish({ ctx, chunk, done })
@@ -33,12 +33,12 @@ function wrapStreamIterator (iterator, ctx) {
 }
 
 function wrapCreate (create) {
-  return function () {
+  return function (...args) {
     if (!anthropicTracingChannel.start.hasSubscribers) {
-      return create.apply(this, arguments)
+      return create.apply(this, args)
     }
 
-    const options = arguments[0]
+    const options = args[0]
     const stream = options.stream
 
     const ctx = { options, resource: 'create', baseUrl: this._client?.baseURL }
@@ -46,14 +46,14 @@ function wrapCreate (create) {
     return anthropicTracingChannel.start.runStores(ctx, () => {
       let apiPromise
       try {
-        apiPromise = create.apply(this, arguments)
+        apiPromise = create.apply(this, args)
       } catch (error) {
         finish(ctx, null, error)
         throw error
       }
 
-      shimmer.wrap(apiPromise, 'parse', parse => function () {
-        return parse.apply(this, arguments)
+      shimmer.wrap(apiPromise, 'parse', parse => function (...args) {
+        return parse.apply(this, args)
           .then(response => {
             if (stream) {
               shimmer.wrap(response, Symbol.asyncIterator, iterator => wrapStreamIterator(iterator, ctx))

package/packages/datadog-instrumentations/src/apollo-server-core.js

@@ -10,9 +10,9 @@ addHook({ name: 'apollo-server-core', file: 'dist/runHttpQuery.js', versions: ['
   const HttpQueryError = runHttpQueryModule.HttpQueryError
 
   shimmer.wrap(runHttpQueryModule, 'runHttpQuery', function wrapRunHttpQuery (originalRunHttpQuery) {
-    return function runHttpQuery () {
+    return function runHttpQuery (...args) {
       if (!requestChannel.start.hasSubscribers) {
-        return originalRunHttpQuery.apply(this, arguments)
+        return originalRunHttpQuery.apply(this, args)
       }
 
       const abortController = new AbortController()
@@ -22,7 +22,7 @@ addHook({ name: 'apollo-server-core', file: 'dist/runHttpQuery.js', versions: ['
         originalRunHttpQuery,
         { abortController, abortData },
         this,
-        ...arguments)
+        ...args)
 
       const abortPromise = new Promise((resolve, reject) => {
         abortController.signal.addEventListener('abort', (event) => {

package/packages/datadog-instrumentations/src/apollo-server.js

@@ -13,9 +13,9 @@ const requestChannel = dc.tracingChannel('datadog:apollo:request')
 let HeaderMap
 
 function wrapExecuteHTTPGraphQLRequest (originalExecuteHTTPGraphQLRequest) {
-  return function executeHTTPGraphQLRequest () {
+  return function executeHTTPGraphQLRequest (...args) {
     if (!HeaderMap || !requestChannel.start.hasSubscribers) {
-      return originalExecuteHTTPGraphQLRequest.apply(this, arguments)
+      return originalExecuteHTTPGraphQLRequest.apply(this, args)
     }
 
     const abortController = new AbortController()
@@ -25,7 +25,7 @@ function wrapExecuteHTTPGraphQLRequest (originalExecuteHTTPGraphQLRequest) {
       originalExecuteHTTPGraphQLRequest,
       { abortController, abortData },
       this,
-      ...arguments)
+      ...args)
 
     const abortPromise = new Promise((resolve, reject) => {
       abortController.signal.addEventListener('abort', (event) => {
@@ -89,10 +89,10 @@ function wrapEmit (emit) {
 }
 
 function wrapListen (originalListen) {
-  return function wrappedListen () {
+  return function wrappedListen (...args) {
     shimmer.wrap(this, 'emit', wrapEmit)
 
-    return originalListen.apply(this, arguments)
+    return originalListen.apply(this, args)
   }
 }
 

package/packages/datadog-instrumentations/src/avsc.js

@@ -8,21 +8,21 @@ const serializeChannel = dc.channel('apm:avsc:serialize-start')
 const deserializeChannel = dc.channel('apm:avsc:deserialize-end')
 
 function wrapSerialization (Type) {
-  shimmer.wrap(Type.prototype, 'toBuffer', original => function () {
+  shimmer.wrap(Type.prototype, 'toBuffer', original => function (...args) {
     if (!serializeChannel.hasSubscribers) {
-      return original.apply(this, arguments)
+      return original.apply(this, args)
     }
     serializeChannel.publish({ messageClass: this })
-    return original.apply(this, arguments)
+    return original.apply(this, args)
   })
 }
 
 function wrapDeserialization (Type) {
-  shimmer.wrap(Type.prototype, 'fromBuffer', original => function () {
+  shimmer.wrap(Type.prototype, 'fromBuffer', original => function (...args) {
     if (!deserializeChannel.hasSubscribers) {
-      return original.apply(this, arguments)
+      return original.apply(this, args)
     }
-    const result = original.apply(this, arguments)
+    const result = original.apply(this, args)
     deserializeChannel.publish({ messageClass: result })
     return result
   })

package/packages/datadog-instrumentations/src/aws-sdk.js

@@ -4,48 +4,146 @@ const shimmer = require('../../datadog-shimmer')
 const { channel, addHook } = require('./helpers/instrument')
 
 const patchedClientConfigProtocols = new WeakSet()
+const patchedCommandPrototypes = new WeakSet()
+
+// Resource identifiers that already match the channel-suffix slug. Anything
+// else falls back to `'default'`. Hoisted out of the per-call hot path so we
+// don't allocate a fresh Array literal + run `.includes` on every AWS send.
+const KNOWN_CHANNEL_SUFFIXES = new Set([
+  'cloudwatchlogs',
+  'dynamodb',
+  'eventbridge',
+  'kinesis',
+  'lambda',
+  'redshift',
+  's3',
+  'sfn',
+  'sns',
+  'sqs',
+  'states',
+  'stepfunctions',
+  'bedrockruntime',
+])
+
+/**
+ * @typedef {object} ChannelBag
+ * @property {ReturnType<typeof channel>} start
+ * @property {ReturnType<typeof channel>} complete
+ * @property {ReturnType<typeof channel>} region
+ * @property {ReturnType<typeof channel>} responseStart
+ * @property {ReturnType<typeof channel>} responseFinish
+ * @property {ReturnType<typeof channel>} deserialize
+ * @property {ReturnType<typeof channel>} streamedChunk
+ */
+
+/** @type {Map<string, ChannelBag>} */
+const channelBags = new Map()
+
+/**
+ * Returns the cached set of diagnostic-channel handles for a given AWS
+ * service slug. Each `channel(...)` call hashes the channel name into a
+ * shared registry and allocates a per-call template-literal string; doing
+ * that ~8 times per AWS send was a measurable per-request cost.
+ *
+ * @param {string} suffix
+ * @returns {ChannelBag}
+ */
+function getChannelBag (suffix) {
+  let bag = channelBags.get(suffix)
+  if (bag === undefined) {
+    bag = {
+      start: channel(`apm:aws:request:start:${suffix}`),
+      complete: channel(`apm:aws:request:complete:${suffix}`),
+      region: channel(`apm:aws:request:region:${suffix}`),
+      responseStart: channel(`apm:aws:response:start:${suffix}`),
+      responseFinish: channel(`apm:aws:response:finish:${suffix}`),
+      deserialize: channel(`apm:aws:response:deserialize:${suffix}`),
+      streamedChunk: channel(`apm:aws:response:streamed-chunk:${suffix}`),
+    }
+    channelBags.set(suffix, bag)
+  }
+  return bag
+}
+
+/** @type {WeakMap<Function, string>} */
+const clientNameCache = new WeakMap()
+
+/**
+ * @param {Function} clientCtor
+ * @returns {string}
+ */
+function getClientName (clientCtor) {
+  let name = clientNameCache.get(clientCtor)
+  if (name === undefined) {
+    name = clientCtor.name.replace(/Client$/, '')
+    clientNameCache.set(clientCtor, name)
+  }
+  return name
+}
+
+/** @type {WeakMap<Function, string>} */
+const operationCache = new WeakMap()
+
+/**
+ * @param {Function} commandCtor
+ * @returns {string}
+ */
+function getOperationName (commandCtor) {
+  let operation = operationCache.get(commandCtor)
+  if (operation === undefined) {
+    const commandName = commandCtor.name
+    operation = `${commandName[0].toLowerCase()}${commandName.slice(1).replace(/Command$/, '')}`
+    operationCache.set(commandCtor, operation)
+  }
+  return operation
+}
 
 function wrapRequest (send) {
+  // V8 deopts both this function and `send.apply(this, arguments)` once
+  // `arguments[0] = wrapCb(...)` materialises the arguments object on the
+  // hot path. Pass the (at most one-arg) call site through explicitly --
+  // `Request.send` only accepts an optional callback in both v2 and v3 SDKs.
   return function wrappedRequest (cb) {
     if (!this.service) return send.apply(this, arguments)
 
     const serviceIdentifier = this.service.serviceIdentifier
     const channelSuffix = getChannelSuffix(serviceIdentifier)
-    const startCh = channel(`apm:aws:request:start:${channelSuffix}`)
-    if (!startCh.hasSubscribers) return send.apply(this, arguments)
+    const channels = getChannelBag(channelSuffix)
+    if (!channels.start.hasSubscribers) return send.apply(this, arguments)
 
+    const cbExists = typeof cb === 'function'
     const ctx = {
       serviceIdentifier,
       operation: this.operation,
       awsRegion: this.service.config && this.service.config.region,
       awsService: this.service.api && this.service.api.className,
       request: this,
-      cbExists: typeof cb === 'function',
+      cbExists,
     }
 
+    // AWS SDK v2 mixes in its own `SequentialExecutor` (no `once`), so stick
+    // to `on('complete')`. The event fires exactly once per Request — even
+    // across retries — so we don't get duplicate publishes.
     this.on('complete', response => {
       ctx.response = response
-      channel(`apm:aws:request:complete:${channelSuffix}`).publish(ctx)
+      channels.complete.publish(ctx)
     })
 
-    if (ctx.cbExists) {
-      arguments[0] = wrapCb(cb, channelSuffix, ctx)
+    if (cbExists) {
+      return channels.start.runStores(ctx, send, this, wrapCb(cb, channels, ctx))
     }
-
-    return startCh.runStores(ctx, send, this, ...arguments)
+    return channels.start.runStores(ctx, send, this)
   }
 }
 
-function wrapDeserialize (deserialize, channelSuffix, responseIndex = 0) {
-  const headersCh = channel(`apm:aws:response:deserialize:${channelSuffix}`)
-
-  return function () {
-    const response = arguments[responseIndex]
+function wrapDeserialize (deserialize, headersCh, responseIndex = 0) {
+  return function (...args) {
+    const response = args[responseIndex]
     if (headersCh.hasSubscribers) {
       headersCh.publish({ headers: response.headers })
     }
 
-    return deserialize.apply(this, arguments)
+    return deserialize.apply(this, args)
   }
 }
 
@@ -54,26 +152,32 @@ function wrapSmithySend (send) {
     const cb = args.at(-1)
     const serviceIdentifier = this.config.serviceId.toLowerCase()
     const channelSuffix = getChannelSuffix(serviceIdentifier)
-    const commandName = command.constructor.name
-    const clientName = this.constructor.name.replace(/Client$/, '')
-    const operation = `${commandName[0].toLowerCase()}${commandName.slice(1).replace(/Command$/, '')}`
+    const channels = getChannelBag(channelSuffix)
+    const clientName = getClientName(this.constructor)
+    const operation = getOperationName(command.constructor)
     const request = {
       operation,
       params: command.input,
     }
 
-    const startCh = channel(`apm:aws:request:start:${channelSuffix}`)
-    const regionCh = channel(`apm:aws:request:region:${channelSuffix}`)
-    const responseStartChannel = channel(`apm:aws:response:start:${channelSuffix}`)
-    const responseFinishChannel = channel(`apm:aws:response:finish:${channelSuffix}`)
-
     if (typeof command.deserialize === 'function') {
-      shimmer.wrap(command, 'deserialize', deserialize => wrapDeserialize(deserialize, channelSuffix))
+      const proto = Object.getPrototypeOf(command)
+      // Wrap once per Command class via the prototype when `deserialize` is
+      // inherited; fall back to per-instance wrap when a command shadows it
+      // as an own property (rare in @aws-sdk v3).
+      if (proto && proto.deserialize === command.deserialize) {
+        if (!patchedCommandPrototypes.has(proto)) {
+          shimmer.wrap(proto, 'deserialize', deserialize => wrapDeserialize(deserialize, channels.deserialize))
+          patchedCommandPrototypes.add(proto)
+        }
+      } else {
+        shimmer.wrap(command, 'deserialize', deserialize => wrapDeserialize(deserialize, channels.deserialize))
+      }
     } else if (this.config?.protocol?.deserializeResponse && !patchedClientConfigProtocols.has(this.config.protocol)) {
       shimmer.wrap(
         this.config.protocol,
         'deserializeResponse',
-        deserializeResponse => wrapDeserialize(deserializeResponse, channelSuffix, 2)
+        deserializeResponse => wrapDeserialize(deserializeResponse, channels.deserialize, 2)
       )
 
       patchedClientConfigProtocols.add(this.config.protocol)
@@ -86,25 +190,25 @@ function wrapSmithySend (send) {
       request,
     }
 
-    return startCh.runStores(ctx, () => {
+    return channels.start.runStores(ctx, () => {
       // When the region is not set this never resolves so we can't await.
       this.config.region().then(region => {
         ctx.region = region
-        regionCh.publish(ctx)
+        channels.region.publish(ctx)
       })
 
       if (typeof cb === 'function') {
         args[args.length - 1] = shimmer.wrapFunction(cb, cb => function (err, result) {
           addResponse(ctx, err, result)
 
-          handleCompletion(result, ctx, channelSuffix)
+          handleCompletion(result, ctx, channels)
 
           const responseCtx = { request, response: ctx.response }
 
-          responseStartChannel.runStores(responseCtx, () => {
+          channels.responseStart.runStores(responseCtx, () => {
             cb.apply(this, arguments)
 
-            responseFinishChannel.publish(responseCtx)
+            channels.responseFinish.publish(responseCtx)
           })
         })
       } else { // always a promise
@@ -112,12 +216,12 @@ function wrapSmithySend (send) {
           .then(
             result => {
               addResponse(ctx, null, result)
-              handleCompletion(result, ctx, channelSuffix)
+              handleCompletion(result, ctx, channels)
               return result
             },
             error => {
               addResponse(ctx, error)
-              handleCompletion(null, ctx, channelSuffix)
+              handleCompletion(null, ctx, channels)
               throw error
             }
           )
@@ -128,35 +232,32 @@ function wrapSmithySend (send) {
   }
 }
 
-function handleCompletion (result, ctx, channelSuffix) {
-  const completeChannel = channel(`apm:aws:request:complete:${channelSuffix}`)
-  const streamedChunkChannel = channel(`apm:aws:response:streamed-chunk:${channelSuffix}`)
-
+function handleCompletion (result, ctx, channels) {
   const iterator = result?.body?.[Symbol.asyncIterator]
   if (!iterator) {
-    completeChannel.publish(ctx)
+    channels.complete.publish(ctx)
     return
   }
 
   shimmer.wrap(result.body, Symbol.asyncIterator, function (asyncIterator) {
-    return function () {
-      const iterator = asyncIterator.apply(this, arguments)
+    return function (...args) {
+      const iterator = asyncIterator.apply(this, args)
       shimmer.wrap(iterator, 'next', function (next) {
-        return function () {
-          return next.apply(this, arguments)
+        return function (...args) {
+          return next.apply(this, args)
             .then(result => {
               const { done, value: chunk } = result
-              streamedChunkChannel.publish({ ctx, chunk, done })
+              channels.streamedChunk.publish({ ctx, chunk, done })
 
               if (done) {
-                completeChannel.publish(ctx)
+                channels.complete.publish(ctx)
               }
 
               return result
             })
             .catch(err => {
               addResponse(ctx, err)
-              completeChannel.publish(ctx)
+              channels.complete.publish(ctx)
               throw err
             })
         }
@@ -167,30 +268,29 @@ function handleCompletion (result, ctx, channelSuffix) {
   })
 }
 
-function wrapCb (cb, serviceName, ctx) {
+function wrapCb (cb, channels, ctx) {
   // eslint-disable-next-line n/handle-callback-err
   return shimmer.wrapFunction(cb, cb => function wrappedCb (err, response) {
     ctx = { request: ctx.request, response }
-    return channel(`apm:aws:response:start:${serviceName}`).runStores(ctx, () => {
-      const finishChannel = channel(`apm:aws:response:finish:${serviceName}`)
+    return channels.responseStart.runStores(ctx, () => {
       try {
         let result = cb.apply(this, arguments)
         if (result && result.then) {
           result = result.then(x => {
-            finishChannel.publish(ctx)
+            channels.responseFinish.publish(ctx)
             return x
           }, e => {
             ctx.error = e
-            finishChannel.publish(ctx)
+            channels.responseFinish.publish(ctx)
             throw e
           })
         } else {
-          finishChannel.publish(ctx)
+          channels.responseFinish.publish(ctx)
         }
         return result
       } catch (e) {
         ctx.error = e
-        finishChannel.publish(ctx)
+        channels.responseFinish.publish(ctx)
         throw e
       }
     })
@@ -211,23 +311,7 @@ function addResponse (ctx, error, result) {
 function getChannelSuffix (name) {
   // some resource identifiers have spaces between ex: bedrock runtime
   name = String(name).replaceAll(' ', '')
-  return [
-    'cloudwatchlogs',
-    'dynamodb',
-    'eventbridge',
-    'kinesis',
-    'lambda',
-    'redshift',
-    's3',
-    'sfn',
-    'sns',
-    'sqs',
-    'states',
-    'stepfunctions',
-    'bedrockruntime',
-  ].includes(name)
-    ? name
-    : 'default'
+  return KNOWN_CHANNEL_SUFFIXES.has(name) ? name : 'default'
 }
 
 addHook({ name: '@smithy/smithy-client', versions: ['>=1.0.3'] }, smithy => {

package/packages/datadog-instrumentations/src/azure-durable-functions.js

@@ -38,14 +38,14 @@ function entityWrapper (method) {
 }
 
 function entityHandler (handler, entityName) {
-  return function () {
-    if (!azureDurableFunctionsChannel.hasSubscribers) return handler.apply(this, arguments)
+  return function (...args) {
+    if (!azureDurableFunctionsChannel.hasSubscribers) return handler.apply(this, args)
 
-    const entityContext = arguments[0]
+    const entityContext = args[0]
     return azureDurableFunctionsChannel.traceSync(
       handler,
       { trigger: 'Entity', functionName: entityName, operationName: entityContext?.df?.operationName },
-      this, ...arguments)
+      this, ...args)
   }
 }
 
@@ -55,19 +55,19 @@ function activityHandler (method) {
       const isAsync =
         handler && handler.constructor && handler.constructor.name === 'AsyncFunction'
 
-      return function () {
-        if (!azureDurableFunctionsChannel.hasSubscribers) return handler.apply(this, arguments)
+      return function (...args) {
+        if (!azureDurableFunctionsChannel.hasSubscribers) return handler.apply(this, args)
 
         // use tracePromise if this is an async handler. otherwise, use traceSync
         return isAsync
           ? azureDurableFunctionsChannel.tracePromise(
             handler,
             { trigger: 'Activity', functionName: activityName },
-            this, ...arguments)
+            this, ...args)
           : azureDurableFunctionsChannel.traceSync(
             handler,
             { trigger: 'Activity', functionName: activityName },
-            this, ...arguments)
+            this, ...args)
       }
     })
     return method.apply(this, arguments)