perf(redis): tighten per-command instrumentation (#8310)

Per-command tracer overhead is a measurable fraction of redis
sub-millisecond latency. The following improvements are implemented:

1. Cache `{connectionOptions, connectionName}` per client; the lookup
   was per-command despite being stable for the client's lifetime.
2. Pass the original command array with `argsStartIndex=1` in the v4
   path so `formatCommand` iterates without a per-command slice.
3. `formatArg` short-circuits short strings; longer ones slice directly
   to `97 + '...'`.
4. `wrapCallback` drops `shimmer.wrapFunction`; the wrapped callback is
   internal.
5. Drop the redundant `try`/`catch` around ioredis `sendCommand`.

Bench (Node 24.13 / V8 13.6, n=1 M+ x 7 trials, drop best+worst):
  formatArg always-trim                 31.70 ns/op
  formatArg short-string fast path      10.84 ns/op   speedup: 2.92x
  connectionInfo probe + WeakMap.get     6.58 ns/op
  connectionInfo cached symbol-key       4.30 ns/op   speedup: 1.53x

Author: BridgeAR

packages/datadog-instrumentations/src/ioredis.js

@@ -10,28 +10,32 @@ const startCh = channel('apm:ioredis:command:start')
 const finishCh = channel('apm:ioredis:command:finish')
 const errorCh = channel('apm:ioredis:command:error')
 
+const connectionOptionsCache = new WeakMap()
+
 function wrapRedis (Redis) {
   shimmer.wrap(Redis.prototype, 'sendCommand', sendCommand => function (command, stream) {
     if (!startCh.hasSubscribers) return sendCommand.apply(this, arguments)
 
     if (!command || !command.promise) return sendCommand.apply(this, arguments)
 
     const options = this.options || {}
-    const connectionName = options.connectionName
-    const db = options.db
-    const connectionOptions = { host: options.host, port: options.port }
-
-    const ctx = { db, command: command.name, args: command.args, connectionOptions, connectionName }
+    let connectionOptions = connectionOptionsCache.get(this)
+    if (connectionOptions === undefined) {
+      connectionOptions = { host: options.host, port: options.port }
+      connectionOptionsCache.set(this, connectionOptions)
+    }
+
+    const ctx = {
+      db: options.db,
+      command: command.name,
+      args: command.args,
+      connectionOptions,
+      connectionName: options.connectionName,
+    }
     return startCh.runStores(ctx, () => {
       command.promise.then(() => finish(finishCh, errorCh, ctx), err => finish(finishCh, errorCh, ctx, err))
 
-      try {
-        return sendCommand.apply(this, arguments)
-      } catch (err) {
-        errorCh.publish(err)
-
-        throw err
-      }
+      return sendCommand.apply(this, arguments)
     })
   })
   return Redis

packages/datadog-instrumentations/src/redis.js

@@ -13,17 +13,15 @@ const errorCh = channel('apm:redis:command:error')
 let createClientUrl
 let createClientName
 const instanceInfo = new WeakMap()
+const connectionInfoCache = new WeakMap()
 
 function wrapAddCommand (addCommand) {
   return function (command) {
     if (!startCh.hasSubscribers) {
       return addCommand.apply(this, arguments)
     }
 
-    const name = command[0]
-    const args = command.slice(1)
-
-    const ctx = getStartCtx(this, name, args)
+    const ctx = getStartCtx(this, command[0], command, 1)
     return startCh.runStores(ctx, () => {
       const res = addCommand.apply(this, arguments)
 
@@ -136,22 +134,33 @@ addHook({ name: 'redis', versions: ['>=0.12 <2.6'] }, redis => {
   return redis
 })
 
-function getStartCtx (client, command, args) {
-  const { url, connectionName } = instanceInfo.get(client) || {}
+function getStartCtx (client, command, args, argsStartIndex) {
+  let cached = connectionInfoCache.get(client)
+  if (cached === undefined) {
+    const info = instanceInfo.get(client)
+    cached = {
+      connectionOptions:
+        client.connection_options || client.connection_option || client.connectionOption || info?.url,
+      connectionName: info?.connectionName,
+    }
+    connectionInfoCache.set(client, cached)
+  }
 
   return {
     db: client.selected_db,
     command,
     args,
-    connectionOptions: client.connection_options || client.connection_option || client.connectionOption || url,
-    connectionName,
+    argsStartIndex,
+    connectionOptions: cached.connectionOptions,
+    connectionName: cached.connectionName,
   }
 }
 
 function wrapCallback (finishCh, errorCh, ctx, callback) {
-  return shimmer.wrapFunction(callback, callback => function (err) {
+  if (typeof callback !== 'function') return callback
+  return function (err) {
     return finish(finishCh, errorCh, ctx, err, callback, this, arguments)
-  })
+  }
 }
 
 function finish (finishCh, errorCh, ctx, error, callback, thisArg, args) {

packages/datadog-plugin-ioredis/test/index.spec.js

@@ -55,6 +55,22 @@ describe('Plugin', () => {
           }, { spanResourceMatch: /^get$/ })
         })
 
+        it('formats numeric args without coercing to ?', async () => {
+          await redis.expire('foo', 60)
+
+          await agent.assertFirstTraceSpan({
+            meta: { 'redis.raw_command': 'EXPIRE foo 60' },
+          }, { spanResourceMatch: /^expire$/ })
+        })
+
+        it('redacts non-string non-number args as ?', async () => {
+          await redis.set('foo', Buffer.from('binary-value'))
+
+          await agent.assertFirstTraceSpan({
+            meta: { 'redis.raw_command': 'SET foo ?' },
+          }, { spanResourceMatch: /^set$/ })
+        })
+
         it('should run the callback in the parent context', () => {
           const span = tracer.startSpan('test')
 

packages/datadog-plugin-redis/src/index.js

@@ -4,6 +4,9 @@ const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
 const CachePlugin = require('../../dd-trace/src/plugins/cache')
 const urlFilter = require('../../dd-trace/src/plugins/util/urlfilter')
 
+const MAX_ARG_LENGTH = 100
+const MAX_COMMAND_LENGTH = 1000
+
 class RedisPlugin extends CachePlugin {
   static id = 'redis'
   static system = 'redis'
@@ -14,7 +17,7 @@ class RedisPlugin extends CachePlugin {
   }
 
   bindStart (ctx) {
-    const { db, command, args, connectionOptions, connectionName } = ctx
+    const { db, command, args, argsStartIndex, connectionOptions, connectionName } = ctx
 
     const resource = command
     const normalizedCommand = command.toUpperCase()
@@ -29,7 +32,7 @@ class RedisPlugin extends CachePlugin {
       meta: {
         'db.type': this._spanType,
         'db.name': db || '0',
-        [`${this._spanType}.raw_command`]: formatCommand(normalizedCommand, args),
+        [`${this._spanType}.raw_command`]: formatCommand(normalizedCommand, args, argsStartIndex),
         'out.host': connectionOptions.host,
         [CLIENT_PORT_KEY]: connectionOptions.port,
       },
@@ -43,36 +46,28 @@ class RedisPlugin extends CachePlugin {
   }
 }
 
-function formatCommand (command, args) {
+function formatCommand (command, args, argsStartIndex = 0) {
   if (!args || command === 'AUTH') return command
 
-  for (let i = 0, l = args.length; i < l; i++) {
-    if (typeof args[i] === 'function') continue
-
-    command = `${command} ${formatArg(args[i])}`
+  let result = command
+  for (let i = argsStartIndex, l = args.length; i < l; i++) {
+    const arg = args[i]
+    if (typeof arg === 'function') continue
 
-    if (command.length > 1000) return trim(command, 1000)
+    result = `${result} ${formatArg(arg)}`
+    if (result.length > MAX_COMMAND_LENGTH) return result.slice(0, MAX_COMMAND_LENGTH - 3) + '...'
   }
 
-  return command
+  return result
 }
 
 function formatArg (arg) {
-  switch (typeof arg) {
-    case 'string':
-    case 'number':
-      return trim(String(arg), 100)
-    default:
-      return '?'
-  }
-}
-
-function trim (str, maxlen) {
-  if (str.length > maxlen) {
-    str = str.slice(0, maxlen - 3) + '...'
+  if (typeof arg === 'string') {
+    return arg.length > MAX_ARG_LENGTH ? arg.slice(0, MAX_ARG_LENGTH - 3) + '...' : arg
   }
-
-  return str
+  // Number stringification is bounded (~23 chars max), so it never hits MAX_ARG_LENGTH.
+  if (typeof arg === 'number') return String(arg)
+  return '?'
 }
 
 function normalizeConfig (config) {

packages/datadog-plugin-redis/test/client.spec.js

@@ -90,6 +90,51 @@ describe('Plugin', () => {
           await Promise.all([client.get('foo'), promise])
         })
 
+        it('keeps every arg when formatting a multi-arg command', async () => {
+          const promise = agent.assertSomeTraces(traces => {
+            assert.strictEqual(traces[0][0].meta['redis.raw_command'], 'SET multi-arg-key multi-arg-value')
+          }, { spanResourceMatch: /^SET$/ })
+
+          await Promise.all([client.set('multi-arg-key', 'multi-arg-value'), promise])
+        })
+
+        it('trims a string arg longer than 100 chars', async () => {
+          const longValue = 'x'.repeat(150)
+          const promise = agent.assertSomeTraces(traces => {
+            const rawCommand = traces[0][0].meta['redis.raw_command']
+            assert.strictEqual(rawCommand, `SET long-key ${'x'.repeat(97)}...`)
+            assert.strictEqual(rawCommand.length, 'SET long-key '.length + 100)
+          }, { spanResourceMatch: /^SET$/ })
+
+          await Promise.all([client.set('long-key', longValue), promise])
+        })
+
+        it('redacts the AUTH password from the raw command', async () => {
+          const promise = agent.assertSomeTraces(traces => {
+            assert.strictEqual(traces[0][0].meta['redis.raw_command'], 'AUTH')
+          }, { spanResourceMatch: /^AUTH$/ })
+
+          await Promise.all([
+            client.sendCommand(['AUTH', 'super-secret-password']).catch(() => {}),
+            promise,
+          ])
+        })
+
+        it('caps the joined raw command at 1000 chars across many args', async () => {
+          const args = []
+          for (let index = 0; index < 200; index++) {
+            args.push(`key${index}`, `value${index}`)
+          }
+          const promise = agent.assertSomeTraces(traces => {
+            const rawCommand = traces[0][0].meta['redis.raw_command']
+            assert.strictEqual(rawCommand.length, 1000)
+            assert.ok(rawCommand.startsWith('MSET '))
+            assert.ok(rawCommand.endsWith('...'))
+          }, { spanResourceMatch: /^MSET$/ })
+
+          await Promise.all([client.sendCommand(['MSET', ...args]), promise])
+        })
+
         withPeerService(
           () => tracer,
           'redis',