@aidra/pmx-io 0.0.0-stage → 9.13.0

package/lib/itg/amqplib.js

@@ -0,0 +1,169 @@
+// Copyright (c) 2026 Mike Warriner. All rights reserved. Proprietary — see LICENSE.
+'use strict'
+
+// amqplib (RabbitMQ, AMQP 0-9-1; 82 §13 ITG-242, ITG-243), promise API (lib/channel_model.js) and
+// callback API (lib/callback_model.js), normal and confirm channels:
+//  * publish(exchange, routingKey, content, options) and sendToQueue(queue, content, options) →
+//    PRODUCER `publish <exchange>` (the routing key / queue for the default exchange), trace headers
+//    in a copy of `options.headers`; the span ends when the call returns (also on confirm
+//    channels, not at the broker confirm);
+//  * consume(queue, onMessage, options) → callback style per delivery (a `null` delivery, the
+//    consumer being cancelled, makes none), parent extracted from `properties.headers`;
+//  * get(queue) → batch pull of one (`receive <queue>`, one link), only when a message came back.
+
+const c = require('./common')
+
+const SYSTEM = 'rabbitmq'
+
+function peer (ch) {
+  const tags = {}
+  try {
+    const s = ch && ch.connection && ch.connection.stream
+    if (s && s.remoteAddress) {
+      tags['net.peer.name'] = String(s.remoteAddress)
+      if (s.remotePort) tags['net.peer.port'] = String(s.remotePort)
+    }
+  } catch (_) {}
+  return tags
+}
+
+function publishSpan (ch, exchange, routingKey, content, options) {
+  const tags = peer(ch)
+  if (routingKey !== undefined && routingKey !== null) tags['messaging.rabbitmq.destination.routing_key'] = String(routingKey)
+  if (options && options.messageId !== undefined) tags['messaging.message.id'] = String(options.messageId)
+  const size = c.bodySize(content)
+  if (size !== undefined) tags['messaging.message.body.size'] = String(size)
+  const dest = exchange ? String(exchange) : (routingKey !== undefined && routingKey !== null ? String(routingKey) : undefined)
+  return c.producer(SYSTEM, dest, tags)
+}
+
+function withHeaders (options, span) {
+  const o = Object.assign({}, options || {})
+  o.headers = c.headersObject(span, options && options.headers)
+  return o
+}
+
+function wrapPublish (orig) {
+  return function publish (exchange, routingKey, content, options) {
+    if (!c.msgTracer() || c.nested()) return orig.apply(this, arguments)
+    const span = publishSpan(this, exchange, routingKey, content, options)
+    if (!span) return c.outer(orig, this, arguments)
+    const args = Array.prototype.slice.call(arguments)
+    while (args.length < 4) args.push(undefined)
+    args[3] = withHeaders(options, span)
+    try {
+      const r = c.outer(orig, this, args)
+      c.end(span)
+      return r
+    } catch (err) {
+      c.end(span, err)
+      throw err
+    }
+  }
+}
+
+function wrapSendToQueue (orig) {
+  return function sendToQueue (queue, content, options) {
+    if (!c.msgTracer() || c.nested()) return orig.apply(this, arguments)
+    const span = publishSpan(this, '', queue, content, options)
+    if (!span) return c.outer(orig, this, arguments)
+    const args = Array.prototype.slice.call(arguments)
+    while (args.length < 3) args.push(undefined)
+    args[2] = withHeaders(options, span)
+    try {
+      const r = c.outer(orig, this, args)
+      c.end(span)
+      return r
+    } catch (err) {
+      c.end(span, err)
+      throw err
+    }
+  }
+}
+
+function msgTags (ch, msg, queue) {
+  const tags = peer(ch)
+  const f = msg.fields || {}
+  const p = msg.properties || {}
+  if (f.routingKey !== undefined) tags['messaging.rabbitmq.destination.routing_key'] = String(f.routingKey)
+  if (p.messageId !== undefined && p.messageId !== null) tags['messaging.message.id'] = String(p.messageId)
+  const size = c.bodySize(msg.content)
+  if (size !== undefined) tags['messaging.message.body.size'] = String(size)
+  return tags
+}
+
+function wrapConsume (orig) {
+  return function consume (queue, onMessage) {
+    if (!c.msgTracer() || typeof onMessage !== 'function') return orig.apply(this, arguments)
+    const ch = this
+    const args = Array.prototype.slice.call(arguments)
+    args[1] = function (msg) {
+      if (msg === null || msg === undefined || !c.msgTracer()) return onMessage.apply(this, arguments)
+      const headers = msg.properties && msg.properties.headers
+      const span = c.consumer(SYSTEM, String(queue), c.extract(headers), msgTags(ch, msg, queue))
+      return c.runConsumer(span, onMessage, this, arguments)
+    }
+    return orig.apply(this, args)
+  }
+}
+
+function receiveDone (span, msg) {
+  if (!span) return
+  if (!msg) return // nothing returned: no span (ITG-023)
+  try {
+    c.addLink(span, c.extract(msg.properties && msg.properties.headers))
+  } catch (_) {}
+  c.end(span)
+}
+
+function wrapGet (orig) {
+  return function get (queue, options, cb) {
+    if (!c.msgTracer()) return orig.apply(this, arguments)
+    const span = c.batchConsumer(SYSTEM, String(queue), null, peer(this), 'receive')
+    if (!span) return orig.apply(this, arguments)
+    const args = Array.prototype.slice.call(arguments)
+    const cbIndex = typeof options === 'function' ? 1 : (typeof cb === 'function' ? 2 : -1)
+    if (cbIndex !== -1) {
+      const fn = c.bind(args[cbIndex])
+      args[cbIndex] = function (err, msg) {
+        if (err) c.end(span, err)
+        else receiveDone(span, msg)
+        return fn.apply(this, arguments)
+      }
+      return orig.apply(this, args)
+    }
+    let r
+    try {
+      r = orig.apply(this, args)
+    } catch (err) {
+      c.end(span, err)
+      throw err
+    }
+    if (!c.isThenable(r)) return r
+    return r.then((msg) => {
+      receiveDone(span, msg)
+      return msg
+    }, (err) => {
+      c.end(span, err)
+      throw err
+    })
+  }
+}
+
+function patchModel (exports, info) {
+  let any = false
+  for (const name of ['Channel', 'ConfirmChannel']) {
+    const K = exports && exports[name]
+    const proto = K && K.prototype
+    if (!proto) continue
+    for (const [m, w] of [['publish', wrapPublish], ['sendToQueue', wrapSendToQueue], ['consume', wrapConsume], ['get', wrapGet]]) {
+      if (Object.prototype.hasOwnProperty.call(proto, m) && typeof proto[m] === 'function') {
+        c.wrap(proto, m, w)
+        any = true
+      }
+    }
+  }
+  if (!any) c.disabled('amqplib', 'Channel.publish not found in ' + info.file)
+}
+
+module.exports = { patchModel }

package/lib/itg/bullmq.js

@@ -0,0 +1,141 @@
+// Copyright (c) 2026 Mike Warriner. All rights reserved. Proprietary — see LICENSE.
+'use strict'
+
+// BullMQ (82 §10 ITG-212). Producer: `Queue.prototype.add(name, data, opts)` → PRODUCER
+// `publish <queue name>` (current during the call, so BullMQ's Redis commands are its children,
+// ITG-005), the carrier `pmxTrace` = { traceparent, tracestate?, baggage? } in a copy of `opts`
+// (BullMQ stores job options with the job); `addBulk(jobs)` → one PRODUCER span with
+// `messaging.batch.message_count`, every job carrying that span's context. Worker: the export
+// `Worker` is replaced by a Proxy whose construct trap wraps a processor function (CONSUMER
+// `process <queue name>`, callback style until its promise settles, parent from
+// `job.opts.pmxTrace`, `messaging.pmx.attempt` = attemptsMade + 1 on BullMQ ≥ 5, attemptsMade on
+// 4.x). Sandboxed processors (a file
+// path) are covered when the child that runs them is instrumented (80 NIO-290–296). BullMQ's own
+// `telemetry` option is left untouched.
+
+const c = require('./common')
+
+const SYSTEM = 'bullmq'
+const KEY = 'pmxTrace'
+
+function withCarrier (opts, span) {
+  // a repeatable job (`repeat`) is a schedule: BullMQ copies its options into every job it creates
+  // from it, which would make each run (for days) a child of this one call. Its runs start new
+  // traces, as jobs from `upsertJobScheduler` do.
+  if (opts && typeof opts === 'object' && opts.repeat) return opts
+  const o = Object.assign({}, opts || {})
+  if (o[KEY] === undefined) o[KEY] = c.traceCarrier(span)
+  return o
+}
+
+function wrapAdd (orig) {
+  return function add (name, data, opts) {
+    if (!c.msgTracer()) return orig.apply(this, arguments)
+    const tags = {}
+    if (name !== undefined) tags['messaging.bullmq.job.name'] = String(name)
+    const span = c.producer(SYSTEM, this.name, tags)
+    if (!span) return orig.apply(this, arguments)
+    const args = Array.prototype.slice.call(arguments)
+    while (args.length < 3) args.push(undefined)
+    args[2] = withCarrier(opts, span)
+    let p
+    try {
+      p = c.withSpan(span, orig, this, args)
+    } catch (err) {
+      c.end(span, err)
+      throw err
+    }
+    if (!c.isThenable(p)) {
+      c.end(span)
+      return p
+    }
+    return c.settle(p, span, (job) => {
+      if (job && job.id !== undefined) span.setAttribute('messaging.message.id', String(job.id))
+    })
+  }
+}
+
+function wrapAddBulk (orig) {
+  return function addBulk (jobs) {
+    if (!c.msgTracer() || !Array.isArray(jobs)) return orig.apply(this, arguments)
+    const tags = {}
+    if (jobs.length > 1) tags['messaging.batch.message_count'] = String(jobs.length)
+    const span = c.producer(SYSTEM, this.name, tags)
+    if (!span) return orig.apply(this, arguments)
+    const copy = jobs.map((j) => (j && typeof j === 'object' ? Object.assign({}, j, { opts: withCarrier(j.opts, span) }) : j))
+    let p
+    try {
+      p = c.withSpan(span, orig, this, [copy])
+    } catch (err) {
+      c.end(span, err)
+      throw err
+    }
+    if (!c.isThenable(p)) {
+      c.end(span)
+      return p
+    }
+    return c.settle(p, span)
+  }
+}
+
+function wrapProcessor (queueName, processor) {
+  const w = function (job) {
+    if (!c.msgTracer() || !job) return processor.apply(this, arguments)
+    const tags = {}
+    if (job.id !== undefined) tags['messaging.message.id'] = String(job.id)
+    if (job.name !== undefined) tags['messaging.bullmq.job.name'] = String(job.name)
+    // BullMQ ≥ 5 counts failed attempts in attemptsMade (and has attemptsStarted); 4.x increments
+    // attemptsMade when the job starts, so it already is the 1-based attempt number
+    if (typeof job.attemptsMade === 'number') {
+      tags['messaging.pmx.attempt'] = String(typeof job.attemptsStarted === 'number' ? job.attemptsMade + 1 : Math.max(1, job.attemptsMade))
+    }
+    const carrier = job.opts && job.opts[KEY]
+    const span = c.consumer(SYSTEM, queueName, carrier ? c.extract(carrier) : null, tags)
+    return c.runConsumer(span, processor, this, arguments)
+  }
+  return c.copyMeta(w, processor)
+}
+
+function proxyWorker (Worker) {
+  return new Proxy(Worker, {
+    construct (target, args, newTarget) {
+      let a = args
+      try {
+        if (typeof args[1] === 'function' && c.tracer()) {
+          a = args.slice()
+          a[1] = wrapProcessor(String(args[0]), args[1])
+        }
+      } catch (_) {
+        a = args
+      }
+      return Reflect.construct(target, a, newTarget)
+    }
+  })
+}
+
+/** classes/queue.js: Queue.prototype.add / addBulk. */
+function patchQueue (exports) {
+  const Queue = exports && exports.Queue
+  const proto = Queue && Queue.prototype
+  if (!proto || typeof proto.add !== 'function') {
+    c.disabled('bullmq', 'Queue.prototype.add not found')
+    return
+  }
+  c.wrap(proto, 'add', wrapAdd)
+  if (typeof proto.addBulk === 'function') c.wrap(proto, 'addBulk', wrapAddBulk)
+}
+
+/** classes/worker.js: the Worker export. */
+function patchWorker (exports) {
+  const Worker = exports && exports.Worker
+  if (typeof Worker !== 'function') {
+    c.disabled('bullmq', 'Worker not found')
+    return
+  }
+  const P = proxyWorker(Worker)
+  const d = Object.getOwnPropertyDescriptor(exports, 'Worker')
+  if (d && d.writable) exports.Worker = P
+  else Object.defineProperty(exports, 'Worker', { value: P, writable: true, enumerable: true, configurable: true })
+}
+
+module.exports = { patchQueue, patchWorker }