@aidra/pmx-io 0.0.0-stage → 9.13.0

package/lib/itg/dbcomment.js

@@ -0,0 +1,114 @@
+// Copyright (c) 2026 Mike Warriner. All rights reserved. Proprietary — see LICENSE.
+'use strict'
+
+// Database trace tag (96 §10 SVM-500…505, 82 ITG-015/ITG-016, 02 D-47/D-49; same results as
+// pmx-io). `tracing.db.comment` = `on` (default) | `off` | `force`: the W3C context
+// of the database CLIENT span is prepended to SQL statements as a sqlcommenter-encoded block
+// comment (`/*traceparent='00-<trace>-<span>-01',application='<app>'*/ `), and set as the `comment`
+// of MongoDB commands that have none, so database-side records (pmx service modules) join the
+// trace. Only for sampled traces; never for named/cached prepared statements unless `force`.
+// `tracing.db.applicationName` (default true) fills PostgreSQL `application_name` / MongoDB
+// `appName` with the pmx app name when the app set none.
+
+const APP_NAME_MAX = 63 // PostgreSQL NAMEDATALEN - 1 (bytes)
+
+/** sqlcommenter value encoding: URL-encoded, `!'()*` too (same as Python's quote(v, safe='')). */
+function encode (v) {
+  return encodeURIComponent(String(v)).replace(/[!'()*]/g, (ch) => '%' + ch.charCodeAt(0).toString(16).toUpperCase())
+}
+
+/** The pmx app name (env `name`, set by pmx), else the tracer's service name; '' when unknown. */
+function appName (t) {
+  const n = process.env.name || (t && t.serviceName) || ''
+  return typeof n === 'string' ? n : ''
+}
+
+/** `s` cut to at most `max` UTF-8 bytes, never inside a character. */
+function cutBytes (s, max) {
+  if (Buffer.byteLength(s) <= max) return s
+  let out = ''
+  let len = 0
+  for (const ch of s) {
+    const b = Buffer.byteLength(ch)
+    if (len + b > max) break
+    out += ch
+    len += b
+  }
+  return out
+}
+
+/** The application_name / appName to set, or '' (option off or no name). */
+function connectionAppName (t) {
+  if (!t || !t.db || t.db.applicationName === false) return ''
+  return cutBytes(appName(t), APP_NAME_MAX)
+}
+
+const TRACE_ID = /^[0-9a-f]{32}$/
+const SPAN_ID = /^[0-9a-f]{16}$/
+
+/** W3C ids only: 32 / 16 lowercase hex digits, not all zero (anything else is never tagged). */
+function validIds (traceId, spanId) {
+  return typeof traceId === 'string' && typeof spanId === 'string' &&
+    TRACE_ID.test(traceId) && SPAN_ID.test(spanId) &&
+    traceId !== '00000000000000000000000000000000' && spanId !== '0000000000000000'
+}
+
+function spanIds (span) {
+  if (!span) return null
+  try {
+    const sc = typeof span.spanContext === 'function' ? span.spanContext() : span
+    if (!sc || !validIds(sc.traceId, sc.spanId)) return null
+    const sampled = typeof sc.traceFlags === 'number' ? (sc.traceFlags & 1) === 1 : Boolean(span.sampled)
+    return sampled ? sc : null
+  } catch (_) {
+    return null
+  }
+}
+
+/** The comment body (`traceparent='…'[,application='…']`) for `traceId`/`spanId`. */
+function body (t, traceId, spanId) {
+  let s = "traceparent='" + encode('00-' + traceId + '-' + spanId + '-01') + "'"
+  const app = appName(t)
+  if (app) s += ",application='" + encode(app) + "'"
+  return s
+}
+
+/**
+ * SVM-501: true when the statement `text` of `span` gets the comment. `prepared` = the driver
+ * uses a named/cached prepared statement for it (skipped unless `force`).
+ */
+function wants (t, span, text, prepared) {
+  const mode = t && t.db ? t.db.comment : 'off'
+  if (mode !== 'on' && mode !== 'force') return false
+  if (typeof text !== 'string' || text.includes('traceparent=')) return false
+  if (prepared && mode !== 'force') return false
+  return spanIds(span) !== null
+}
+
+/** SVM-502: the SQL prefix for `span` (`/*…*\/ `). Call only after wants() returned true. */
+function sqlPrefix (t, span) {
+  const sc = spanIds(span)
+  return '/*' + body(t, sc.traceId, sc.spanId) + '*/ '
+}
+
+/** SVM-503: the MongoDB `comment` value for `traceId`/`spanId`. */
+function mongoComment (t, traceId, spanId) {
+  return body(t, traceId, spanId)
+}
+
+/** True when mode is `force`. */
+function forced (t) {
+  return Boolean(t && t.db && t.db.comment === 'force')
+}
+
+/** `tracing.db.comment` normalised: 'on' | 'off' | 'force' (true → on, false → off). */
+function normMode (v) {
+  if (v === false) return 'off'
+  if (v === true || v === undefined || v === null) return 'on'
+  const s = String(v).trim().toLowerCase()
+  if (s === 'off' || s === 'false' || s === '0' || s === 'no') return 'off'
+  if (s === 'force') return 'force'
+  return 'on'
+}
+
+module.exports = { validIds, encode, appName, connectionAppName, cutBytes, wants, sqlPrefix, mongoComment, forced, normMode, spanIds, APP_NAME_MAX }

package/lib/itg/index.js

@@ -0,0 +1,103 @@
+// Copyright (c) 2026 Mike Warriner. All rights reserved. Proprietary — see LICENSE.
+'use strict'
+
+// The database and broker integrations of 82-integrations.md (80 NIO-250), declared for the
+// module-loading interception of modules.js: { pkg, for, files: { '<file in package>': patch } }.
+// `for` is 'db', 'messaging' or 'db+messaging' (82 ITG-001: a library is wrapped only while tracing
+// and its switch are on). Each library's module is required only when one of its files is loaded
+// by the app (ITG-002); a patch that does not find its entry points disables itself (ITG-004).
+
+const debug = require('../debug')('axm:tracing')
+
+function lazy (mod, fn) {
+  return (exports, info) => {
+    try {
+      require('./common').setLib(info && info.pkg)
+      return require('./' + mod)[fn](exports, info || {})
+    } catch (err) {
+      let version = '?'
+      try {
+        version = require(require('path').join(info.dir, 'package.json')).version
+      } catch (_) {}
+      debug('%s %s: instrumentation disabled (%s)', info && info.pkg, version, err && err.message)
+      return undefined
+    }
+  }
+}
+
+function list () {
+  const pgClient = lazy('pg', 'patchClient')
+  const pgjsQuery = lazy('postgres', 'patchQuery')
+  const pgjsIndex = lazy('postgres', 'patchIndex')
+  const ioRedis = lazy('ioredis', 'patchRedis')
+  const ioPipeline = lazy('ioredis', 'patchPipeline')
+  const myConn = lazy('mysql2', 'patchConnection')
+  const myPool = lazy('mysql2', 'patchPool')
+  const natsConn = lazy('nats', 'patchConnection')
+  const natsIter = lazy('nats', 'patchIterator')
+  const natsJs = lazy('nats', 'patchJsClient')
+  const natsCons = lazy('nats', 'patchConsumer')
+  const amqp = lazy('amqplib', 'patchModel')
+  const bullQueue = lazy('bullmq', 'patchQueue')
+  const bullWorker = lazy('bullmq', 'patchWorker')
+  const boss = lazy('pgqueue', 'patchBoss')
+  return [
+    { pkg: 'pg', for: 'db', files: { 'lib/client.js': pgClient, 'lib/native/client.js': pgClient } },
+    { pkg: 'pg-pool', for: 'db', files: { 'index.js': lazy('pg', 'patchPool') } },
+    {
+      pkg: 'postgres',
+      for: 'db',
+      files: { 'cjs/src/query.js': pgjsQuery, 'cjs/src/index.js': pgjsIndex, 'src/query.js': pgjsQuery, 'src/index.js': pgjsIndex }
+    },
+    {
+      pkg: 'ioredis',
+      for: 'db+messaging',
+      files: {
+        'built/Redis.js': ioRedis,
+        'built/redis/index.js': ioRedis,
+        'built/cluster/index.js': lazy('ioredis', 'patchCluster'),
+        'built/Pipeline.js': ioPipeline,
+        'built/pipeline.js': ioPipeline
+      }
+    },
+    { pkg: '@redis/client', for: 'db+messaging', files: { 'dist/lib/client/index.js': lazy('noderedis', 'patchClient') } },
+    {
+      pkg: 'mysql2',
+      for: 'db',
+      files: { 'lib/base/connection.js': myConn, 'lib/connection.js': myConn, 'lib/base/pool.js': myPool, 'lib/pool.js': myPool }
+    },
+    { pkg: 'mongodb', for: 'db', files: { 'lib/mongo_client.js': lazy('mongodb', 'patchClient') } },
+    {
+      pkg: 'nats',
+      for: 'messaging',
+      files: {
+        'lib/nats-base-client/nats.js': natsConn,
+        'lib/nats-base-client/queued_iterator.js': natsIter,
+        'lib/jetstream/jsclient.js': natsJs,
+        'lib/jetstream/consumer.js': natsCons
+      }
+    },
+    { pkg: '@nats-io/nats-core', for: 'messaging', files: { 'lib/nats.js': natsConn, 'lib/queued_iterator.js': natsIter } },
+    { pkg: '@nats-io/jetstream', for: 'messaging', files: { 'lib/jsclient.js': natsJs, 'lib/consumer.js': natsCons } },
+    { pkg: 'kafkajs', for: 'messaging', files: { 'src/index.js': lazy('kafkajs', 'patchClient') } },
+    { pkg: 'amqplib', for: 'messaging', files: { 'lib/channel_model.js': amqp, 'lib/callback_model.js': amqp } },
+    {
+      pkg: 'bullmq',
+      for: 'messaging',
+      files: {
+        'dist/cjs/classes/queue.js': bullQueue,
+        'dist/cjs/classes/worker.js': bullWorker,
+        'dist/esm/classes/queue.js': bullQueue,
+        'dist/esm/classes/worker.js': bullWorker
+      }
+    },
+    { pkg: 'pg-boss', for: 'messaging', files: { 'src/manager.js': boss, 'dist/manager.js': boss } },
+    {
+      pkg: 'graphile-worker',
+      for: 'messaging',
+      files: { 'dist/helpers.js': lazy('pgqueue', 'patchHelpers'), 'dist/worker.js': lazy('pgqueue', 'patchWorker') }
+    }
+  ]
+}
+
+module.exports = { list }

package/lib/itg/ioredis.js

@@ -0,0 +1,212 @@
+// Copyright (c) 2026 Mike Warriner. All rights reserved. Proprietary — see LICENSE.
+'use strict'
+
+// ioredis (82 §6 ITG-121, ITG-123, ITG-032; streams §10 ITG-210). `Redis.prototype.sendCommand`
+// (every typed command, `call`, `send_command`) is one CLIENT span per command, ended when the
+// command's own resolve/reject runs (the returned promise is not touched); `Pipeline.prototype.exec`
+// (from `pipeline()` and `multi()`) is one PIPELINE/MULTI span and its commands make none;
+// `Cluster.prototype.sendCommand` makes the span for cluster clients (the node-level call it
+// leads to makes none, ITG-005). A command is marked once it has a span (or belongs to a batch),
+// so offline-queue replays, retries and redirections never create a second one; a command queued
+// before `ready` is timed from the app's call. Commands sent while the connection is in status
+// `connect` (its handshake and ready check) make no span.
+
+const c = require('./common')
+const r = require('./redis-common')
+
+const MARK = Symbol('pmx-ioredis')
+
+function peerTags (client) {
+  const tags = {}
+  try {
+    if (client && client.isCluster) {
+      const n = Array.isArray(client.startupNodes) ? client.startupNodes[0] : undefined
+      if (n && typeof n === 'object') {
+        if (n.host) tags['net.peer.name'] = String(n.host)
+        if (n.port) tags['net.peer.port'] = String(n.port)
+      } else if (typeof n === 'string') {
+        const m = /^(?:redis:\/\/)?([^:/]+)(?::(\d+))?/.exec(n)
+        if (m) {
+          tags['net.peer.name'] = m[1]
+          if (m[2]) tags['net.peer.port'] = m[2]
+        }
+      } else if (typeof n === 'number') {
+        tags['net.peer.name'] = 'localhost'
+        tags['net.peer.port'] = String(n)
+      }
+      return tags
+    }
+    const o = (client && client.options) || {}
+    if (o.path) tags['net.peer.name'] = String(o.path)
+    else {
+      tags['net.peer.name'] = String(o.host || 'localhost')
+      if (o.port) tags['net.peer.port'] = String(o.port)
+    }
+  } catch (_) {}
+  return tags
+}
+
+function dbTags (client) {
+  const tags = Object.assign({ 'db.system': 'redis' }, peerTags(client))
+  try {
+    if (!client.isCluster) {
+      const sel = client.condition && client.condition.select !== undefined ? client.condition.select : client.options && client.options.db
+      if (sel !== undefined && sel !== null) tags['db.redis.database_index'] = String(sel)
+    }
+  } catch (_) {}
+  return tags
+}
+
+/** Hook a command's own resolve/reject (instance properties) to run `done(result, err)` once. */
+function onSettle (command, done) {
+  const res = command.resolve
+  const rej = command.reject
+  if (typeof res !== 'function' || typeof rej !== 'function') {
+    if (command.promise && typeof command.promise.then === 'function') {
+      // fallback: observe the promise (marks it handled; ioredis also does through its callback helper)
+      command.promise.then((v) => done(v), (e) => done(undefined, e))
+      return
+    }
+    done()
+    return
+  }
+  let settled = false
+  command.resolve = function (v) {
+    if (!settled) {
+      settled = true
+      try { done(v) } catch (_) {}
+    }
+    return res.apply(this, arguments)
+  }
+  command.reject = function (err) {
+    if (!settled) {
+      settled = true
+      try { done(undefined, err) } catch (_) {}
+    }
+    return rej.apply(this, arguments)
+  }
+}
+
+function startCommand (client, command) {
+  const name = String(command.name || '').toUpperCase()
+  const args = Array.isArray(command.args) ? command.args : []
+  if (r.STREAM_COMMANDS.has(name) && c.msgTracer()) {
+    const call = r.streamCall(name, args, peerTags(client))
+    if (call && call.span) {
+      if (call.extra.length) command.args = args.concat(call.extra)
+      onSettle(command, (v, err) => call.done(v, err))
+    }
+    return
+  }
+  const t = c.dbTracer()
+  if (!t) return
+  const tags = dbTags(client)
+  tags['db.operation'] = name
+  const st = r.statement(name, args, t.db.statement)
+  if (st !== undefined) tags['db.statement'] = st
+  const span = c.clientSpan(t, name, tags)
+  if (!span) return
+  onSettle(command, (v, err) => c.end(span, err, err ? r.errorCode(err) : undefined))
+}
+
+function mark (command) {
+  Object.defineProperty(command, MARK, { value: true, configurable: true })
+}
+
+/** True when `command` is the last entry of the client's offline queue (a Denque or an array). */
+function queuedOffline (client, command) {
+  const q = client.offlineQueue
+  if (!q) return false
+  const last = typeof q.peekBack === 'function' ? q.peekBack() : (Array.isArray(q) ? q[q.length - 1] : undefined)
+  return Boolean(last && last.command === command)
+}
+
+function wrapSendCommand (orig) {
+  return function sendCommand (command, stream) {
+    if (!command || typeof command !== 'object' || command[MARK] || stream || !c.tracer()) return orig.apply(this, arguments)
+    if (this.status === 'connect') {
+      // status 'connect': the connection's own handshake (HELLO, AUTH, SELECT, CLIENT SETINFO)
+      // and ready check (INFO) are written now and make no span; a command of the app is queued
+      // (offline queue) and replayed at `ready` — in the context of the connection, not the app's:
+      // its span is made now, in the app's context, timed from the call
+      const r = orig.apply(this, arguments)
+      try {
+        if (!command[MARK] && queuedOffline(this, command)) {
+          mark(command)
+          startCommand(this, command)
+        }
+      } catch (_) {}
+      return r
+    }
+    try {
+      mark(command)
+      startCommand(this, command)
+    } catch (_) {}
+    return orig.apply(this, arguments)
+  }
+}
+
+function wrapExec (orig) {
+  return function exec () {
+    const t = c.dbTracer()
+    const queue = this._queue
+    if (!t || this[MARK] || !Array.isArray(queue) || queue.length === 0 || !c.currentSpan()) return orig.apply(this, arguments)
+    let span = null
+    try {
+      Object.defineProperty(this, MARK, { value: true, configurable: true })
+      const multi = queue[0] && queue[0].name === 'multi'
+      const cmds = []
+      for (const cmd of queue) {
+        try {
+          Object.defineProperty(cmd, MARK, { value: true, configurable: true })
+        } catch (_) {}
+        if (multi && (cmd.name === 'multi' || cmd.name === 'exec')) continue
+        cmds.push([String(cmd.name || '').toUpperCase(), Array.isArray(cmd.args) ? cmd.args : []])
+      }
+      const name = multi ? 'MULTI' : 'PIPELINE'
+      const tags = dbTags(this.redis)
+      tags['db.operation'] = name
+      const st = r.pipelineStatement(cmds, t.db.statement)
+      if (st !== undefined) tags['db.statement'] = st
+      tags['db.batch_size'] = String(cmds.length)
+      span = c.clientSpan(t, name, tags)
+    } catch (_) {
+      span = null
+    }
+    let p
+    try {
+      p = orig.apply(this, arguments)
+    } catch (err) {
+      c.end(span, err)
+      throw err
+    }
+    if (span && c.isThenable(p)) {
+      p.then(() => c.end(span), (err) => c.end(span, err, r.errorCode(err)))
+    } else c.end(span)
+    return p
+  }
+}
+
+/** built/Redis.js (5.x, 6.x) and built/redis/index.js (4.x): Redis.prototype.sendCommand. */
+function patchRedis (exports) {
+  const Redis = exports && (exports.default || exports)
+  if (typeof Redis !== 'function' || !Redis.prototype || typeof Redis.prototype.sendCommand !== 'function') {
+    c.disabled('ioredis', 'Redis.prototype.sendCommand not found')
+    return
+  }
+  c.wrap(Redis.prototype, 'sendCommand', wrapSendCommand)
+}
+
+function patchCluster (exports) {
+  const Cluster = exports && (exports.default || exports)
+  if (typeof Cluster !== 'function' || !Cluster.prototype || typeof Cluster.prototype.sendCommand !== 'function') return
+  c.wrap(Cluster.prototype, 'sendCommand', wrapSendCommand)
+}
+
+function patchPipeline (exports) {
+  const Pipeline = exports && (exports.default || exports)
+  if (typeof Pipeline !== 'function' || !Pipeline.prototype || typeof Pipeline.prototype.exec !== 'function') return
+  c.wrap(Pipeline.prototype, 'exec', wrapExec)
+}
+
+module.exports = { patchRedis, patchCluster, patchPipeline }

package/lib/itg/kafkajs.js

@@ -0,0 +1,205 @@
+// Copyright (c) 2026 Mike Warriner. All rights reserved. Proprietary — see LICENSE.
+'use strict'
+
+// kafkajs (82 §12 ITG-232, ITG-233; links ITG-024). The client class (`Kafka`, src/index.js) is
+// wrapped in a Proxy that remembers the bootstrap brokers of each instance; its `producer()` and
+// `consumer()` return the library's objects with these methods wrapped:
+//  * producer.send / sendBatch (and the same methods of `transaction()` objects) → one PRODUCER
+//    `publish <topic>` span per call (`publish multiple` for several topics), the span's trace
+//    headers set in copies of the messages (and of their `headers` objects);
+//  * consumer.run({ eachMessage }) → callback style per message, parent extracted from the
+//    message headers; run({ eachBatch }) → one CONSUMER `process <topic>` span per batch call with
+//    one link per message (at most `messaging.maxLinks`).
+// Header values may be strings, Buffers or arrays of them: extraction takes the first value.
+
+const c = require('./common')
+
+const SYSTEM = 'kafka'
+const BROKERS = new WeakMap()
+// producer/consumer objects are wrapped when created: not tracked per library (85 OTX-020 looks at
+// Kafka.prototype.producer/consumer, which OpenTelemetry's kafkajs instrumentation wraps)
+const RUNTIME = { lib: 'kafkajs', track: false }
+
+function peer (client) {
+  const tags = {}
+  const b = client && BROKERS.get(client)
+  const first = Array.isArray(b) ? b[0] : undefined
+  if (typeof first === 'string') {
+    const i = first.lastIndexOf(':')
+    if (i > 0) {
+      tags['net.peer.name'] = first.slice(0, i)
+      tags['net.peer.port'] = first.slice(i + 1)
+    } else tags['net.peer.name'] = first
+  }
+  return tags
+}
+
+function withHeaders (messages, span) {
+  if (!Array.isArray(messages)) return messages
+  const trace = c.traceHeaders(span)
+  return messages.map((m) => {
+    if (!m || typeof m !== 'object') return m
+    const h = Object.assign({}, m.headers || {})
+    const present = new Set(Object.keys(h).map((k) => k.toLowerCase()))
+    for (const [k, v] of trace) if (!present.has(k)) h[k] = v
+    return Object.assign({}, m, { headers: h })
+  })
+}
+
+function sizeOf (messages) {
+  if (!Array.isArray(messages) || messages.length !== 1) return undefined
+  return c.bodySize(messages[0] && messages[0].value)
+}
+
+function wrapSend (client) {
+  return (orig) => function send (record) {
+    if (!c.msgTracer() || !record || typeof record !== 'object') return orig.apply(this, arguments)
+    const messages = Array.isArray(record.messages) ? record.messages : []
+    const tags = peer(client)
+    if (messages.length > 1) tags['messaging.batch.message_count'] = String(messages.length)
+    const size = sizeOf(messages)
+    if (size !== undefined) tags['messaging.message.body.size'] = String(size)
+    const span = c.producer(SYSTEM, record.topic, tags)
+    if (!span) return orig.apply(this, arguments)
+    let r
+    try {
+      r = orig.call(this, Object.assign({}, record, { messages: withHeaders(messages, span) }))
+    } catch (err) {
+      c.end(span, err)
+      throw err
+    }
+    if (!c.isThenable(r)) {
+      c.end(span)
+      return r
+    }
+    return c.settle(r, span, (res) => partitionOf(span, res))
+  }
+}
+
+function partitionOf (span, res) {
+  if (Array.isArray(res) && res.length === 1 && res[0] && res[0].partition !== undefined) {
+    span.setAttribute('messaging.kafka.destination.partition', String(res[0].partition))
+  }
+}
+
+function wrapSendBatch (client) {
+  return (orig) => function sendBatch (batch) {
+    if (!c.msgTracer() || !batch || typeof batch !== 'object' || !Array.isArray(batch.topicMessages)) return orig.apply(this, arguments)
+    const topics = new Set(batch.topicMessages.map((t) => t && t.topic))
+    const count = batch.topicMessages.reduce((n, t) => n + (t && Array.isArray(t.messages) ? t.messages.length : 0), 0)
+    const tags = peer(client)
+    if (count > 1) tags['messaging.batch.message_count'] = String(count)
+    const span = c.producer(SYSTEM, topics.size === 1 ? Array.from(topics)[0] : undefined, tags)
+    if (!span) return orig.apply(this, arguments)
+    let r
+    try {
+      const tm = batch.topicMessages.map((t) => (t && typeof t === 'object' ? Object.assign({}, t, { messages: withHeaders(t.messages, span) }) : t))
+      r = orig.call(this, Object.assign({}, batch, { topicMessages: tm }))
+    } catch (err) {
+      c.end(span, err)
+      throw err
+    }
+    if (!c.isThenable(r)) {
+      c.end(span)
+      return r
+    }
+    return c.settle(r, span)
+  }
+}
+
+function wrapProducerObject (p, client) {
+  if (!p || typeof p !== 'object') return p
+  try {
+    if (typeof p.send === 'function') c.wrap(p, 'send', wrapSend(client), RUNTIME)
+    if (typeof p.sendBatch === 'function') c.wrap(p, 'sendBatch', wrapSendBatch(client), RUNTIME)
+    if (typeof p.transaction === 'function') {
+      c.wrap(p, 'transaction', (orig) => function transaction () {
+        const r = orig.apply(this, arguments)
+        if (c.isThenable(r)) return r.then((tx) => wrapProducerObject(tx, client))
+        return r
+      }, RUNTIME)
+    }
+  } catch (_) {}
+  return p
+}
+
+function consumerTags (client, group, topic, partition) {
+  const tags = peer(client)
+  if (group) tags['messaging.consumer.group.name'] = String(group)
+  if (partition !== undefined && partition !== null) tags['messaging.kafka.destination.partition'] = String(partition)
+  return tags
+}
+
+function wrapRun (client, group) {
+  return (orig) => function run (config) {
+    if (!config || typeof config !== 'object') return orig.apply(this, arguments)
+    const copy = Object.assign({}, config)
+    if (typeof config.eachMessage === 'function') {
+      const fn = config.eachMessage
+      copy.eachMessage = function (payload) {
+        if (!c.msgTracer() || !payload || !payload.message) return fn.apply(this, arguments)
+        const m = payload.message
+        const tags = consumerTags(client, group, payload.topic, payload.partition)
+        if (m.offset !== undefined) tags['messaging.kafka.message.offset'] = String(m.offset)
+        const size = c.bodySize(m.value)
+        if (size !== undefined) tags['messaging.message.body.size'] = String(size)
+        const span = c.consumer(SYSTEM, payload.topic, c.extract(m.headers), tags)
+        return c.runConsumer(span, fn, this, arguments)
+      }
+    }
+    if (typeof config.eachBatch === 'function') {
+      const fn = config.eachBatch
+      copy.eachBatch = function (payload) {
+        const batch = payload && payload.batch
+        if (!c.msgTracer() || !batch) return fn.apply(this, arguments)
+        const messages = Array.isArray(batch.messages) ? batch.messages : []
+        const tags = consumerTags(client, group, batch.topic, batch.partition)
+        if (messages.length > 1) tags['messaging.batch.message_count'] = String(messages.length)
+        const contexts = messages.map((m) => c.extract(m && m.headers))
+        const span = c.batchConsumer(SYSTEM, batch.topic, contexts, tags, 'process')
+        return c.runConsumer(span, fn, this, arguments)
+      }
+    }
+    return orig.call(this, copy)
+  }
+}
+
+function wrapConsumerObject (cons, client, group) {
+  if (cons && typeof cons === 'object' && typeof cons.run === 'function') {
+    try {
+      c.wrap(cons, 'run', wrapRun(client, group), RUNTIME)
+    } catch (_) {}
+  }
+  return cons
+}
+
+/** src/index.js: module.exports = class Client. */
+function patchClient (Client) {
+  if (typeof Client !== 'function' || !Client.prototype || typeof Client.prototype.producer !== 'function') {
+    c.disabled('kafkajs', 'Kafka.prototype.producer not found')
+    return
+  }
+  const proto = Client.prototype
+  c.wrap(proto, 'producer', (orig) => function producer () {
+    const p = orig.apply(this, arguments)
+    return c.tracer() ? wrapProducerObject(p, this) : p
+  })
+  if (typeof proto.consumer === 'function') {
+    c.wrap(proto, 'consumer', (orig) => function consumer (opts) {
+      const cons = orig.apply(this, arguments)
+      return c.tracer() ? wrapConsumerObject(cons, this, opts && opts.groupId) : cons
+    })
+  }
+  return new Proxy(Client, {
+    construct (target, args, newTarget) {
+      const client = Reflect.construct(target, args, newTarget)
+      try {
+        const o = args[0]
+        if (o && Array.isArray(o.brokers)) BROKERS.set(client, o.brokers.slice())
+      } catch (_) {}
+      return client
+    }
+  })
+}
+
+module.exports = { patchClient }