dd-trace 5.101.0 → 5.103.0

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)

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

@@ -6,8 +6,8 @@ const { wrapThen } = require('./helpers/promise')
 
 function createGetNewLibraryCopyWrap (originalLib) {
   return function wrapGetNewLibraryCopy (getNewLibraryCopy) {
-    return function getNewLibraryCopyWithTrace () {
-      const libraryCopy = getNewLibraryCopy.apply(this, arguments)
+    return function getNewLibraryCopyWithTrace (...args) {
+      const libraryCopy = getNewLibraryCopy.apply(this, args)
       shimmer.wrap(libraryCopy.prototype, '_then', wrapThen)
       shimmer.wrap(libraryCopy, 'getNewLibraryCopy', createGetNewLibraryCopyWrap(originalLib))
       return libraryCopy

package/packages/datadog-instrumentations/src/body-parser.js

@@ -6,7 +6,7 @@ const { channel, addHook, AsyncResource } = require('./helpers/instrument')
 const bodyParserReadCh = channel('datadog:body-parser:read:finish')
 
 function publishRequestBodyAndNext (req, res, next) {
-  return shimmer.wrapFunction(next, next => function () {
+  return shimmer.wrapFunction(next, next => function (...args) {
     if (bodyParserReadCh.hasSubscribers && req) {
       const abortController = new AbortController()
       const body = req.body
@@ -16,7 +16,7 @@ function publishRequestBodyAndNext (req, res, next) {
       if (abortController.signal.aborted) return
     }
 
-    return next.apply(this, arguments)
+    return next.apply(this, args)
   })
 }
 

package/packages/datadog-instrumentations/src/cassandra-driver.js

@@ -100,13 +100,13 @@ addHook({ name: 'cassandra-driver', versions: ['3 - 4.3'], patchDefault: false }
 })
 
 addHook({ name: 'cassandra-driver', versions: ['>=3.3'], file: 'lib/request-execution.js' }, RequestExecution => {
-  shimmer.wrap(RequestExecution.prototype, '_sendOnConnection', _sendOnConnection => function () {
+  shimmer.wrap(RequestExecution.prototype, '_sendOnConnection', _sendOnConnection => function (...args) {
     if (!startCh.hasSubscribers) {
-      return _sendOnConnection.apply(this, arguments)
+      return _sendOnConnection.apply(this, args)
     }
     startCtx = { hostname: this._connection.address, port: this._connection.port, ...startCtx }
     connectCh.publish(startCtx)
-    return _sendOnConnection.apply(this, arguments)
+    return _sendOnConnection.apply(this, args)
   })
   return RequestExecution
 })
@@ -122,9 +122,9 @@ addHook({ name: 'cassandra-driver', versions: ['3.3 - 4.3'], file: 'lib/request-
       return start.apply(this, arguments)
     }
 
-    arguments[0] = function () {
+    arguments[0] = function (...args) {
       startCtx = { hostname: execution._connection.address, port: execution._connection.port, ...startCtx }
-      return connectCh.runStores(startCtx, getHostCallback, this, ...arguments)
+      return connectCh.runStores(startCtx, getHostCallback, this, ...args)
     }
 
     return start.apply(this, arguments)
@@ -143,9 +143,9 @@ addHook({ name: 'cassandra-driver', versions: ['3 - 3.2'], file: 'lib/request-ha
       return send.apply(this, arguments)
     }
 
-    arguments[2] = function () {
+    arguments[2] = function (...args) {
       startCtx = { hostname: handler.connection.address, port: handler.connection.port, ...startCtx }
-      return connectCh.runStores(startCtx, callback, this, ...arguments)
+      return connectCh.runStores(startCtx, callback, this, ...args)
     }
 
     return send.apply(this, arguments)

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

@@ -82,12 +82,12 @@ function createContextFromChildProcessInfo (childProcessInfo) {
 
 function wrapChildProcessSyncMethod (returnError, shell = false) {
   return function wrapMethod (childProcessMethod) {
-    return function () {
-      if (!childProcessChannel.start.hasSubscribers || arguments.length === 0) {
-        return childProcessMethod.apply(this, arguments)
+    return function (...args) {
+      if (!childProcessChannel.start.hasSubscribers || args.length === 0) {
+        return childProcessMethod.apply(this, args)
       }
 
-      const callArgs = [...arguments]
+      const callArgs = [...args]
       const childProcessInfo = normalizeArgs(callArgs, shell)
       const context = createContextFromChildProcessInfo(childProcessInfo)
       context.callArgs = callArgs
@@ -118,12 +118,12 @@ function wrapChildProcessSyncMethod (returnError, shell = false) {
 }
 
 function wrapChildProcessCustomPromisifyMethod (customPromisifyMethod, shell) {
-  return function () {
-    if (!childProcessChannel.start.hasSubscribers || arguments.length === 0) {
-      return customPromisifyMethod.apply(this, arguments)
+  return function (...args) {
+    if (!childProcessChannel.start.hasSubscribers || args.length === 0) {
+      return customPromisifyMethod.apply(this, args)
     }
 
-    const callArgs = [...arguments]
+    const callArgs = [...args]
     const childProcessInfo = normalizeArgs(callArgs, shell)
 
     const context = createContextFromChildProcessInfo(childProcessInfo)
@@ -170,12 +170,12 @@ function wrapChildProcessCustomPromisifyMethod (customPromisifyMethod, shell) {
 
 function wrapChildProcessAsyncMethod (ChildProcess, shell = false) {
   return function wrapMethod (childProcessMethod) {
-    function wrappedChildProcessMethod () {
-      if (!childProcessChannel.start.hasSubscribers || arguments.length === 0) {
-        return childProcessMethod.apply(this, arguments)
+    function wrappedChildProcessMethod (...args) {
+      if (!childProcessChannel.start.hasSubscribers || args.length === 0) {
+        return childProcessMethod.apply(this, args)
       }
 
-      const callArgs = [...arguments]
+      const callArgs = [...args]
       const childProcessInfo = normalizeArgs(callArgs, shell)
 
       const context = createContextFromChildProcessInfo(childProcessInfo)

package/packages/datadog-instrumentations/src/confluentinc-kafka-javascript.js

@@ -7,6 +7,7 @@ const {
   addHook,
   channel,
 } = require('./helpers/instrument')
+const { cloneMessages } = require('./helpers/kafka')
 
 // Create channels for Confluent Kafka JavaScript
 const channels = {
@@ -47,8 +48,8 @@ function instrumentBaseModule (module) {
   // Helper function to wrap producer classes
   function wrapProducerClass (ProducerClass, className) {
     return shimmer.wrap(module, className, function wrapProducer (Original) {
-      return function wrappedProducer () {
-        const producer = new Original(...arguments)
+      return function wrappedProducer (...args) {
+        const producer = new Original(...args)
 
         // Hook the produce method
         if (typeof producer?.produce === 'function') {
@@ -94,9 +95,9 @@ function instrumentBaseModule (module) {
   // Helper function to wrap consumer classes
   function wrapConsumerClass (ConsumerClass, className) {
     return shimmer.wrap(module, className, function wrapConsumer (Original) {
-      return function wrappedConsumer () {
-        const consumer = new Original(...arguments)
-        const groupId = this.groupId || (arguments[0]?.['group.id'])
+      return function wrappedConsumer (...args) {
+        const consumer = new Original(...args)
+        const groupId = this.groupId || (args[0]?.['group.id'])
 
         // Wrap the consume method
         if (typeof consumer?.consume === 'function') {
@@ -196,11 +197,11 @@ function instrumentKafkaJS (kafkaJS) {
         // Wrap the producer method if it exists
         if (typeof kafka?.producer === 'function') {
           shimmer.wrap(kafka, 'producer', function wrapProducerMethod (producerMethod) {
-            return function wrappedProducerMethod () {
-              const producer = producerMethod.apply(this, arguments)
+            return function wrappedProducerMethod (...args) {
+              const producer = producerMethod.apply(this, args)
 
-              if (!brokers && arguments?.[0]?.['bootstrap.servers']) {
-                kafka._ddBrokers = arguments[0]['bootstrap.servers']
+              if (!brokers && args?.[0]?.['bootstrap.servers']) {
+                kafka._ddBrokers = args[0]['bootstrap.servers']
               }
 
               // Wrap the send method of the producer
@@ -211,46 +212,62 @@ function instrumentKafkaJS (kafkaJS) {
                       return send.apply(this, arguments)
                     }
 
+                    const disableHeaderInjection = disabledHeaderWeakSet.has(producer)
+
+                    // Hand the underlying client a shallow clone so neither
+                    // injection nor the client's auto-fields (it sets
+                    // `headers: null` on messages without headers) ever
+                    // touch caller-owned objects. With injection disabled the
+                    // clone must not seed `headers: {}` either: brokers that
+                    // reject any header field cannot recover otherwise.
+                    let outgoingPayload = payload
+                    if (payload && Array.isArray(payload.messages)) {
+                      outgoingPayload = {
+                        ...payload,
+                        messages: cloneMessages(payload.messages, !disableHeaderInjection),
+                      }
+                    }
+
                     const ctx = {
-                      topic: payload?.topic,
-                      messages: payload?.messages || [],
+                      topic: outgoingPayload?.topic,
+                      messages: outgoingPayload?.messages || [],
                       bootstrapServers: kafka._ddBrokers,
-                      disableHeaderInjection: disabledHeaderWeakSet.has(producer),
+                      disableHeaderInjection,
                     }
 
                     return channels.producerStart.runStores(ctx, () => {
                       try {
-                        const result = send.apply(this, arguments)
+                        const result = send.call(this, outgoingPayload)
 
                         result.then((res) => {
                           ctx.result = res
                           channels.producerCommit.publish(ctx)
                           channels.producerFinish.publish(ctx)
-                        }, (err) => {
-                          if (err) {
-                            // Fixes bug where we would inject message headers for kafka brokers
-                            // that don't support headers (version <0.11). On the error, we disable
-                            // header injection. Tnfortunately the error name / type is not more specific.
-                            // This approach is implemented by other tracers as well.
-                            if (err.name === 'KafkaJSError' && err.type === 'ERR_UNKNOWN') {
+                        }, (error) => {
+                          if (error) {
+                            // KafkaJS-compat reports `ERR_UNKNOWN` for brokers
+                            // <0.11 that cannot parse headers. Stop injecting
+                            // for this producer; subsequent sends to the same
+                            // broker succeed.
+                            if (error.name === 'KafkaJSError' && error.type === 'ERR_UNKNOWN') {
                               disabledHeaderWeakSet.add(producer)
                               log.error(
                                 // eslint-disable-next-line @stylistic/max-len
                                 'Kafka Broker responded with UNKNOWN_SERVER_ERROR (-1). Please look at broker logs for more information. Tracer message header injection for Kafka is disabled.'
                               )
                             }
-                            ctx.error = err
+                            ctx.error = error
                             channels.producerError.publish(ctx)
                           }
                           channels.producerFinish.publish(ctx)
                         })
 
                         return result
-                      } catch (e) {
-                        ctx.error = e
+                      } catch (error) {
+                        ctx.error = error
                         channels.producerError.publish(ctx)
                         channels.producerFinish.publish(ctx)
-                        throw e
+                        throw error
                       }
                     })
                   }