@aidra/pmx-io 9.19.0 → 9.20.0

package/lib/itg/ioredis.js

@@ -99,14 +99,19 @@ function startCommand (client, command) {
     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))
+  if (t === null && !c.mapOn()) return
+  let span = null
+  if (t !== null) {
+    const tags = dbTags(client)
+    tags['db.operation'] = name
+    const st = r.statement(name, args, t.db.statement)
+    if (st !== undefined) tags['db.statement'] = st
+    span = c.clientSpan(t, name, tags)
+  }
+  // 83 CMP-003: with the call map on every command is recorded (`call` stands in for the span)
+  const call = c.dbCall(span, c.dbKeyOf(client, dbTags))
+  if (!call) return
+  onSettle(command, (v, err) => c.end(call, err, err ? r.errorCode(err) : undefined))
 }
 
 function mark (command) {
@@ -123,7 +128,7 @@ function queuedOffline (client, 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 (!command || typeof command !== 'object' || command[MARK] || stream || (c.tracer() === null && !c.mapOn())) 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
@@ -150,8 +155,13 @@ 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)
+    if ((t === null && !c.mapOn()) || this[MARK] || !Array.isArray(queue) || queue.length === 0) return orig.apply(this, arguments)
+    // a span only under a current span (ITG-010); the call map counts the pipeline either way
+    // (CMP-012: one per pipeline, so its commands are marked and make no record of their own)
+    const traced = t !== null && Boolean(c.currentSpan())
+    if (!traced && !c.mapOn()) return orig.apply(this, arguments)
     let span = null
+    let call = null
     try {
       Object.defineProperty(this, MARK, { value: true, configurable: true })
       const multi = queue[0] && queue[0].name === 'multi'
@@ -160,29 +170,32 @@ function wrapExec (orig) {
         try {
           Object.defineProperty(cmd, MARK, { value: true, configurable: true })
         } catch (_) {}
-        if (multi && (cmd.name === 'multi' || cmd.name === 'exec')) continue
+        if (!traced || (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)
+      if (traced) {
+        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)
+      }
+      call = c.dbCall(span, c.dbKeyOf(this.redis, dbTags))
     } catch (_) {
-      span = null
+      call = span
     }
     let p
     try {
       p = orig.apply(this, arguments)
     } catch (err) {
-      c.end(span, err)
+      c.end(call, 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)
+    if (call && c.isThenable(p)) {
+      p.then(() => c.end(call), (err) => c.end(call, err, r.errorCode(err)))
+    } else c.end(call)
     return p
   }
 }

package/lib/itg/mongodb.js

@@ -14,6 +14,7 @@
 const crypto = require('crypto')
 const c = require('./common')
 const dbc = require('./dbcomment')
+const callmap = require('../callmap')
 
 const MAX_STATEMENT = 2000
 const SKIPPED = new Set(['saslstart', 'saslcontinue', 'authenticate', 'getnonce', 'hello', 'ismaster',
@@ -131,7 +132,18 @@ function started (open, ev) {
   const name = ev.commandName
   if (SKIPPED.has(name.toLowerCase())) return
   const t = c.dbTracer()
-  if (!t || c.suppressedLib('mongodb')) return
+  if (t === null) {
+    // 83 CMP-003: tracing off, call map on: the command is recorded only
+    if (!c.mapOn()) return
+    const call = c.dbCall(null, mapKey(ev))
+    if (call) open.set(keyOf(ev), call)
+    return
+  }
+  if (c.suppressedLib('mongodb')) {
+    const call = c.mapOn() ? c.dbCall(null, mapKey(ev)) : null
+    if (call) open.set(keyOf(ev), call)
+    return
+  }
   let command = ev.command || {}
   // our trace comment (96 SVM-503): the span gets the id the comment carries, and the comment
   // is not part of db.statement
@@ -156,8 +168,29 @@ function started (open, ev) {
     span.spanId = plan.spanId
     span._ctx = null
   }
-  if (span) open.set(keyOf(ev), span)
+  const call = c.dbCall(span, c.mapOn() ? mapKey(ev) : null)
+  if (call) open.set(keyOf(ev), call)
+}
+
+/** CMP-012: (mongodb, host, port, database) of a command event. */
+function mapKey (ev) {
+  const address = typeof ev.address === 'string' ? ev.address : ''
+  const db = ev.databaseName ? String(ev.databaseName) : null
+  let byDb = mapKeys.get(address)
+  if (byDb === undefined) {
+    if (mapKeys.size >= 1000) mapKeys.clear()
+    mapKeys.set(address, (byDb = new Map()))
+  }
+  let k = byDb.get(db)
+  if (k === undefined) {
+    const p = peer(address)
+    const port = p['net.peer.port'] !== undefined ? Number(p['net.peer.port']) : null
+    k = callmap.dbKey('mongodb', p['net.peer.name'] !== undefined ? p['net.peer.name'] : null, Number.isFinite(port) ? port : null, db)
+    byDb.set(db, k)
+  }
+  return k
 }
+const mapKeys = new Map()
 
 function succeeded (open, ev) {
   const k = keyOf(ev)
@@ -259,7 +292,8 @@ function proxyClient (MongoClient) {
     construct (target, args, newTarget) {
       let a = args
       try {
-        if (c.dbTracer()) {
+        // 83 CMP-003: command events are wanted for spans or for the call map
+        if (c.dbTracer() || c.mapOn()) {
           const opts = args[1]
           if (opts === undefined || opts === null || typeof opts === 'object') {
             let next = opts || {}

package/lib/itg/mysql2.js

@@ -109,40 +109,46 @@ function comment (t, span, s, args, prepared) {
 function wrapCall (op) {
   return (orig) => function (s, values, cb) {
     const t = c.dbTracer()
-    if (!t || c.nested() || s === null || s === undefined) return orig.apply(this, arguments)
+    if ((t === null && !c.mapOn()) || c.nested() || s === null || s === undefined) return orig.apply(this, arguments)
     let span = null
     try {
-      const text = textOf(s)
-      const base = connTags(this)
-      const operation = sql.operation(text)
-      const tags = Object.assign({}, base)
-      if (operation) tags['db.operation'] = operation
-      const st = sql.statementTag(text, t.db.statement, true)
-      if (st !== undefined) tags['db.statement'] = st
-      const name = operation ? (base['db.name'] ? operation + ' ' + base['db.name'] : operation) : (base['db.name'] || 'mysql')
-      span = c.clientSpan(t, name, tags)
+      if (t !== null) {
+        const text = textOf(s)
+        const base = connTags(this)
+        const operation = sql.operation(text)
+        const tags = Object.assign({}, base)
+        if (operation) tags['db.operation'] = operation
+        const st = sql.statementTag(text, t.db.statement, true)
+        if (st !== undefined) tags['db.statement'] = st
+        const name = operation ? (base['db.name'] ? operation + ' ' + base['db.name'] : operation) : (base['db.name'] || 'mysql')
+        span = c.clientSpan(t, name, tags)
+      }
     } catch (_) {
       span = null
     }
-    if (!span) return orig.apply(this, arguments)
+    // 83 CMP-003: with the call map on every command is recorded (`call` stands in for the span)
+    const call = c.dbCall(span, c.dbKeyOf(this, connTags))
+    if (!call) return orig.apply(this, arguments)
     const args = Array.prototype.slice.call(arguments)
-    try {
-      comment(t, span, s, args, op === 'execute')
-    } catch (_) {}
-    // callbacks run later from the socket: give them the caller's context
-    for (let i = 1; i < args.length; i++) if (typeof args[i] === 'function') args[i] = c.bind(args[i])
+    if (span) {
+      try {
+        comment(t, span, s, args, op === 'execute')
+      } catch (_) {}
+      // callbacks run later from the socket: give them the caller's context
+      for (let i = 1; i < args.length; i++) if (typeof args[i] === 'function') args[i] = c.bind(args[i])
+    }
     let cmd
     try {
       cmd = c.outer(orig, this, args)
     } catch (err) {
-      c.end(span, err)
+      c.end(call, err)
       throw err
     }
     try {
-      if (cmd && typeof cmd.emit === 'function') observe(cmd, span)
-      else c.end(span)
+      if (cmd && typeof cmd.emit === 'function') observe(cmd, call)
+      else c.end(call)
     } catch (_) {
-      c.end(span)
+      c.end(call)
     }
     return cmd
   }

package/lib/itg/noderedis.js

@@ -62,14 +62,19 @@ function startCommand (client, redisArgs) {
     return { extra: call.extra, done: (v, err) => call.done(v, err) }
   }
   const t = c.dbTracer()
-  if (!t) return null
-  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 null
-  return { extra: [], done: (v, err) => c.end(span, err, err ? r.errorCode(err) : undefined) }
+  if (t === null && !c.mapOn()) return null
+  let span = null
+  if (t !== null) {
+    const tags = dbTags(client)
+    tags['db.operation'] = name
+    const st = r.statement(name, args, t.db.statement)
+    if (st !== undefined) tags['db.statement'] = st
+    span = c.clientSpan(t, name, tags)
+  }
+  // 83 CMP-003: with the call map on every command is recorded (`call` stands in for the span)
+  const call = c.dbCall(span, c.dbKeyOf(client, dbTags))
+  if (!call) return null
+  return { extra: [], done: (v, err) => c.end(call, err, err ? r.errorCode(err) : undefined) }
 }
 
 function finishWith (p, done) {
@@ -88,7 +93,7 @@ function finishWith (p, done) {
 
 function wrapSendCommand (orig) {
   return function sendCommand (args, options) {
-    if (!c.tracer() || c.nested() || !Array.isArray(args)) return orig.apply(this, arguments)
+    if ((c.tracer() === null && !c.mapOn()) || c.nested() || !Array.isArray(args)) return orig.apply(this, arguments)
     let call = null
     try {
       call = startCommand(this, args)
@@ -117,7 +122,7 @@ function wrapSendCommand (orig) {
  */
 function wrapCommandsExecutor (orig, transform, transformReply) {
   return function commandsExecutor (command, args) {
-    if (!c.tracer() || c.nested()) return orig.apply(this, arguments)
+    if ((c.tracer() === null && !c.mapOn()) || c.nested()) return orig.apply(this, arguments)
     let call = null
     let t = null
     try {
@@ -155,7 +160,9 @@ function wrapCommandsExecutor (orig, transform, transformReply) {
 
 function batchSpan (client, commands, multi) {
   const t = c.dbTracer()
-  if (!t || !Array.isArray(commands) || commands.length === 0) return null
+  if (!Array.isArray(commands) || commands.length === 0) return null
+  // 83 CMP-003: with the call map on every batch is recorded (a Call stands in for the span)
+  if (t === null) return c.dbCall(null, c.dbKeyOf(client, dbTags))
   const cmds = []
   for (const cmd of commands) {
     const a = Array.isArray(cmd) ? cmd : cmd && cmd.args
@@ -170,12 +177,12 @@ function batchSpan (client, commands, multi) {
   const st = r.pipelineStatement(cmds, t.db.statement)
   if (st !== undefined) tags['db.statement'] = st
   tags['db.batch_size'] = String(cmds.length)
-  return c.clientSpan(t, name, tags)
+  return c.dbCall(c.clientSpan(t, name, tags), c.dbKeyOf(client, dbTags))
 }
 
 function wrapBatch (multiFromArgs) {
   return (orig) => function (commands) {
-    if (!c.tracer() || c.nested()) return orig.apply(this, arguments)
+    if ((c.tracer() === null && !c.mapOn()) || c.nested()) return orig.apply(this, arguments)
     let span = null
     try {
       span = batchSpan(this, commands, multiFromArgs(arguments))

package/lib/itg/pg.js

@@ -88,25 +88,29 @@ function traceSubmittable (span, q) {
 function wrapQuery (orig) {
   return function query (config, values, callback) {
     const t = c.dbTracer()
-    if (!t || config === null || config === undefined || c.nested()) return orig.apply(this, arguments)
+    if ((t === null && !c.mapOn()) || config === null || config === undefined || c.nested()) return orig.apply(this, arguments)
     let span = null
     let text
     try {
       if (typeof config === 'object') untag(config)
       text = typeof config === 'string' ? config : config.text
       if (typeof text !== 'string' && typeof config.submit === 'function') text = config.text || (config.cursor && config.cursor.text)
-      span = makeSpan(t, this, typeof text === 'string' ? text : '', typeof config === 'object' ? config.name : undefined)
+      if (t !== null) span = makeSpan(t, this, typeof text === 'string' ? text : '', typeof config === 'object' ? config.name : undefined)
     } catch (_) {
       span = null
     }
-    if (!span) return orig.apply(this, arguments)
+    // 83 CMP-003: with the call map on every query is recorded (`call` stands in for the span)
+    const call = c.dbCall(span, c.dbKeyOf(this, connTags))
+    if (!call) return orig.apply(this, arguments)
     const args = Array.prototype.slice.call(arguments)
-    try {
-      comment(t, span, config, text, args)
-    } catch (_) {}
+    if (span) {
+      try {
+        comment(t, span, config, text, args)
+      } catch (_) {}
+    }
     try {
       if (typeof config.submit === 'function') {
-        traceSubmittable(span, config)
+        traceSubmittable(call, config)
         return orig.apply(this, args)
       }
       // callback forms: (text, cb), (text, values, cb), (config, cb), config.callback
@@ -116,8 +120,8 @@ function wrapQuery (orig) {
       if (cbIndex !== -1) {
         const cb = c.bind(args[cbIndex])
         args[cbIndex] = function (err, res) {
-          if (!err) rows(span)(res)
-          c.end(span, err || undefined, codeOf(err))
+          if (!err) rows(call)(res)
+          c.end(call, err || undefined, codeOf(err))
           return cb.apply(this, arguments)
         }
         return orig.apply(this, args)
@@ -126,26 +130,26 @@ function wrapQuery (orig) {
         const cb = c.bind(config.callback)
         args[0] = Object.assign(Object.create(Object.getPrototypeOf(args[0])), args[0], {
           callback (err, res) {
-            if (!err) rows(span)(res)
-            c.end(span, err || undefined, codeOf(err))
+            if (!err) rows(call)(res)
+            c.end(call, err || undefined, codeOf(err))
             return cb.apply(this, arguments)
           }
         })
         return orig.apply(this, args)
       }
     } catch (err) {
-      c.end(span)
+      c.end(call)
       return orig.apply(this, arguments)
     }
     let result
     try {
       result = orig.apply(this, args)
     } catch (err) {
-      c.end(span, err, codeOf(err))
+      c.end(call, err, codeOf(err))
       throw err
     }
-    if (c.isThenable(result)) return c.settle(result, span, rows(span), codeOf)
-    c.end(span)
+    if (c.isThenable(result)) return c.settle(result, call, rows(call), codeOf)
+    c.end(call)
     return result
   }
 }

package/lib/itg/postgres.js

@@ -70,7 +70,7 @@ function instrument (q, span, t) {
       // the trace comment is never part of db.statement (96 SVM-504)
       const prefix = q[PREFIX]
       if (st !== null && prefix && st.startsWith(prefix)) st = st.slice(prefix.length)
-      if (st !== null) {
+      if (st !== null && t) {
         const tag = sql.statementTag(st, t.db.statement, false)
         if (tag !== undefined) span.setAttribute('db.statement', tag)
         if (!span.attributes['db.operation']) {
@@ -145,24 +145,28 @@ function wrapHandle (orig) {
   return function handle () {
     if (this.executed || this[SPAN] !== undefined) return orig.apply(this, arguments)
     const t = c.dbTracer()
-    if (t && !c.nested()) {
+    if ((t !== null || c.mapOn()) && !c.nested()) {
       try {
         const text = templateText(this)
         const op = sql.operation(text)
         const isTx = TX_OPS.has(op) || (op === 'PREPARE' && /^\s*prepare\s+transaction\b/i.test(text))
         if (!isTx) {
-          const base = optionTags(optionsOf(this))
-          const tags = Object.assign({}, base)
-          if (op) tags['db.operation'] = op
-          const st = sql.statementTag(text, t.db.statement, false)
-          if (st !== undefined) tags['db.statement'] = st
-          const name = op ? (base['db.name'] ? op + ' ' + base['db.name'] : op) : (base['db.name'] || 'postgresql')
-          const span = c.clientSpan(t, name, tags)
-          this[SPAN] = span
-          if (span) {
-            instrument(this, span, t)
-            comment(this, t, span, text)
+          let span = null
+          if (t !== null) {
+            const base = optionTags(optionsOf(this))
+            const tags = Object.assign({}, base)
+            if (op) tags['db.operation'] = op
+            const st = sql.statementTag(text, t.db.statement, false)
+            if (st !== undefined) tags['db.statement'] = st
+            const name = op ? (base['db.name'] ? op + ' ' + base['db.name'] : op) : (base['db.name'] || 'postgresql')
+            span = c.clientSpan(t, name, tags)
           }
+          // 83 CMP-003: with the call map on every query is recorded (`call` stands in for the span)
+          const options = optionsOf(this)
+          const call = c.dbCall(span, c.dbKeyOf(options || null, optionTags))
+          this[SPAN] = call
+          if (call) instrument(this, call, t)
+          if (span) comment(this, t, span, text)
         }
       } catch (_) {}
     }

package/lib/modules.js

@@ -12,6 +12,7 @@
 //  * ES modules: hooks registered by preload.mjs when tracing is enabled at spawn (NIO-085,
 //    esm-hooks.mjs) replace a target module by a wrapper module that re-exports it with the
 //    patched exports (globalThis[Symbol.for('@pmx/io:esm')] below).
+// The database integrations are also wanted while the call map is on (83 CMP-003).
 // Integrations are declared in integrations.js: { pkg, files: { '<path in package>': patch } }.
 // A patch receives (exports, info) and returns undefined (patched in place) or a replacement.
 // Wrapping is transparent (82 ITG-003); a module that fails to patch is left untouched.
@@ -32,7 +33,7 @@ const PATCHED = Symbol.for('@pmx/io:patched')
 function registry () {
   let r = globalThis[REGISTRY]
   if (!r) {
-    r = { installed: false, integrations: null, wants: { errors: false, tracing: false }, tracing: null, done: new Set() }
+    r = { installed: false, integrations: null, wants: { errors: false, tracing: false, callmap: false }, tracing: null, done: new Set() }
     Object.defineProperty(globalThis, REGISTRY, { value: r, enumerable: false, configurable: true })
   }
   return r
@@ -73,7 +74,9 @@ function wanted (it) {
   const r = registry()
   const w = r.wants
   if (it.for === 'db' || it.for === 'messaging' || it.for === 'db+messaging') {
-    // 82 ITG-001: database / broker integrations only with tracing and their switch on
+    // 82 ITG-001 / 83 CMP-003: database integrations with tracing and `tracing.db` on, or with the
+    // call map on; broker integrations with tracing and `tracing.messaging` on
+    if (it.for !== 'messaging' && w.callmap === true) return true
     const t = w.tracing && r.tracing && r.tracing._tracer
     if (!t) return false
     return (it.for !== 'messaging' && Boolean(t.db)) || (it.for !== 'db' && Boolean(t.messaging))
@@ -249,6 +252,18 @@ function disableTracing () {
   r.tracing = null
 }
 
+/** 83 CMP-003: the call map wants the database integrations (patched now when loaded already). */
+function enableCallMap () {
+  const r = registry()
+  r.wants.callmap = true
+  install()
+  patchLoaded()
+}
+
+function disableCallMap () {
+  registry().wants.callmap = false
+}
+
 function disableErrors () {
   registry().wants.errors = false
 }
@@ -257,4 +272,4 @@ function wants () {
   return registry().wants
 }
 
-module.exports = { TARGET_PKGS, install, enableErrors, enableTracing, disableTracing, disableErrors, packageOf, applyPatch, wants, registry, ESM_KEY }
+module.exports = { TARGET_PKGS, install, enableErrors, enableTracing, disableTracing, enableCallMap, disableCallMap, disableErrors, packageOf, applyPatch, wants, registry, ESM_KEY }

package/lib/outbound.js

@@ -9,13 +9,14 @@
 //    https.request/get are wrapped instead, each when it is loaded (see below).
 //  * the global fetch: Node's undici diagnostics channels (`undici:request:*`, headers added with
 //    the request's addHeader); Bun: globalThis.fetch is wrapped.
-// Requests made by @aidra/pmx-io itself never use these APIs (raw sockets, transport/ws.js).
+// Requests made by @aidra/pmx-io itself never use these APIs (raw sockets, transport/ws.js), so
+// the call map (83 CMP-010, consumer `callmap`) never counts them.
 
 const hooks = require('./hooks')
 const debug = require('./debug')('axm:tracing')
 
 const OUT = Symbol.for('@pmx/io:outbound-state')
-const consumers = { metrics: null, tracing: null }
+const consumers = { metrics: null, tracing: null, callmap: null }
 // resolved on first use: reading globalThis.performance loads the perf_hooks internals (NIO-024)
 let perf = null
 function pnow () {
@@ -43,8 +44,13 @@ function hasErrorChannel () {
 // ---------------------------------------------------------------------------------------------
 // shared start/end
 
-function startState (canInject, info, inject) {
-  const st = { t0: pnow(), span: null, ended: false }
+function startState (canInject, info, inject, keyOf) {
+  const st = { t0: pnow(), span: null, ended: false, key: null }
+  if (consumers.callmap !== null && keyOf) {
+    try {
+      st.key = keyOf()
+    } catch (_) {}
+  }
   const t = consumers.tracing
   if (t && canInject) {
     try {
@@ -63,12 +69,18 @@ function startState (canInject, info, inject) {
 function endState (st, status, err) {
   if (!st || st.ended) return
   st.ended = true
+  const ms = pnow() - st.t0
   const m = consumers.metrics
   if (m) {
     try {
-      m(pnow() - st.t0)
+      m(ms)
     } catch (_) {}
   }
+  const cm = consumers.callmap
+  if (cm !== null && st.key !== null) {
+    // CMP-010: an error is no response or a status ≥ 500
+    cm.record(st.key, ms, err !== undefined && err !== null ? true : (typeof status !== 'number' || status >= 500))
+  }
   if (st.span && consumers.tracing) {
     try {
       consumers.tracing.endClient(st.span, status, err)
@@ -113,6 +125,12 @@ function onClientCreated (req, canInject) {
         if (req.getHeader(name) === undefined) req.setHeader(name, value)
       } catch (_) { /* headers already sent (array form) */ }
     }
+  }, () => {
+    let authority
+    try {
+      authority = req.getHeader('host')
+    } catch (_) {}
+    return consumers.callmap.httpOutKey(req.protocol || 'http:', req.host || 'localhost', authority)
   })
   setOn(req, st)
   if (!hasErrorChannel() && typeof req.once === 'function') {
@@ -266,7 +284,7 @@ function installUndici (dc) {
       for (const [name, value] of headers) {
         if (!undiciHas(request, name)) request.addHeader(name, value)
       }
-    })
+    }, () => consumers.callmap.originKey(String(request.origin || '')))
     undiciStates.set(request, st)
   })
   dc.subscribe('undici:request:headers', ({ request, response }) => {
@@ -323,7 +341,7 @@ function wrapBunFetch () {
           }
         }
         if (changed) args = [input, Object.assign({}, init || {}, { headers: h })]
-      })
+      }, () => consumers.callmap.urlKey(typeof Request === 'function' && input instanceof Request ? input.url : input))
     } catch (_) {}
     const p = orig.apply(this, args)
     if (!st || !p || typeof p.then !== 'function') return p
@@ -348,7 +366,7 @@ function wrapBunFetch () {
 // ---------------------------------------------------------------------------------------------
 
 function refresh () {
-  if (!consumers.metrics && !consumers.tracing) return
+  if (!consumers.metrics && !consumers.tracing && !consumers.callmap) return
   installDc()
   if (BUN) wrapBunFetch()
   if (consumers.tracing && consumers.tracing.outbound && !hasCreatedChannel()) wantClientWrap()