dd-trace 5.101.0 → 5.103.0

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

@@ -59,16 +59,16 @@ function wrapLayerHandle (layer) {
 
   const original = layer.handle
 
-  return shimmer.wrapFunction(original, original => function () {
-    if (!enterChannel.hasSubscribers) return original.apply(this, arguments)
+  return shimmer.wrapFunction(original, original => function (...args) {
+    if (!enterChannel.hasSubscribers) return original.apply(this, args)
 
-    const lastIndex = arguments.length - 1
+    const lastIndex = args.length - 1
     const name = original._name || original.name
-    const req = arguments[arguments.length > 3 ? 1 : 0]
-    const next = arguments[lastIndex]
+    const req = args[args.length > 3 ? 1 : 0]
+    const next = args[lastIndex]
 
     if (typeof next === 'function') {
-      arguments[lastIndex] = wrapNext(req, next)
+      args[lastIndex] = wrapNext(req, next)
     }
 
     const route = layer.route
@@ -76,7 +76,7 @@ function wrapLayerHandle (layer) {
     enterChannel.publish({ name, req, route })
 
     try {
-      return original.apply(this, arguments)
+      return original.apply(this, args)
     } catch (error) {
       errorChannel.publish({ req, error })
       nextChannel.publish({ req })

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

@@ -6,7 +6,7 @@ const { channel, addHook } = require('./helpers/instrument')
 const cookieParserReadCh = channel('datadog:cookie-parser:read:finish')
 
 function publishRequestCookieAndNext (req, res, next) {
-  return shimmer.wrapFunction(next, next => function cookieParserWrapper () {
+  return shimmer.wrapFunction(next, next => function cookieParserWrapper (...args) {
     if (cookieParserReadCh.hasSubscribers && req) {
       const abortController = new AbortController()
 
@@ -17,7 +17,7 @@ function publishRequestCookieAndNext (req, res, next) {
       if (abortController.signal.aborted) return
     }
 
-    return next.apply(this, arguments)
+    return next.apply(this, args)
   })
 }
 
@@ -25,8 +25,8 @@ addHook({
   name: 'cookie-parser',
   versions: ['>=1.0.0'],
 }, cookieParser => {
-  return shimmer.wrapFunction(cookieParser, cookieParser => function () {
-    const cookieMiddleware = cookieParser.apply(this, arguments)
+  return shimmer.wrapFunction(cookieParser, cookieParser => function (...args) {
+    const cookieMiddleware = cookieParser.apply(this, args)
 
     return shimmer.wrapFunction(cookieMiddleware, cookieMiddleware => function (req, res, next) {
       arguments[2] = publishRequestCookieAndNext(req, res, next)

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

@@ -6,8 +6,8 @@ const { channel, addHook } = require('./helpers/instrument')
 const cookieParseCh = channel('datadog:cookie:parse:finish')
 
 function wrapParse (originalParse) {
-  return function () {
-    const cookies = originalParse.apply(this, arguments)
+  return function (...args) {
+    const cookies = originalParse.apply(this, args)
     if (cookieParseCh.hasSubscribers && cookies) {
       cookieParseCh.publish({ cookies })
     }

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

@@ -1,12 +1,27 @@
 'use strict'
 
-const { errorMonitor } = require('events')
+const { tracingChannel } = require('dc-polyfill')
+
 const shimmer = require('../../datadog-shimmer')
 const {
-  channel,
   addHook,
 } = require('./helpers/instrument')
 
+// One TracingChannel per traced operation, looked up at module init so the
+// hot path only does property reads on a stable handle.
+const queryCh = tracingChannel('apm:couchbase:query')
+const upsertCh = tracingChannel('apm:couchbase:upsert')
+const insertCh = tracingChannel('apm:couchbase:insert')
+const replaceCh = tracingChannel('apm:couchbase:replace')
+
+/** @type {Map<string, ReturnType<typeof tracingChannel>>} */
+const opChannelByName = new Map([
+  ['query', queryCh],
+  ['upsert', upsertCh],
+  ['insert', insertCh],
+  ['replace', replaceCh],
+])
+
 function findCallbackIndex (args, lowerbound = 2) {
   for (let i = args.length - 1; i >= lowerbound; i--) {
     if (typeof args[i] === 'function') return i
@@ -19,274 +34,99 @@ function getQueryResource (q) {
   return q && (typeof q === 'string' ? q : q.statement)
 }
 
-function wrapAllNames (names, action) {
-  for (const name of names) {
-    action(name)
-  }
-}
-
-function wrapCallback (callback, ctx, channelPrefix) {
-  const callbackStartCh = channel(`${channelPrefix}:callback:start`)
-  const callbackFinishCh = channel(`${channelPrefix}:callback:finish`)
-
-  const wrapped = callbackStartCh.runStores(ctx, () => {
-    return function (...args) {
-      return callbackFinishCh.runStores(ctx, () => {
-        return callback.apply(this, args)
-      })
-    }
-  })
-  Object.defineProperty(wrapped, '_dd_wrapped', { value: true })
-  return wrapped
-}
-
-function wrapQuery (query) {
-  return function (q, params, callback) {
-    const cb = arguments[arguments.length - 1]
-    if (typeof cb === 'function') {
-      const ctx = {}
-      arguments[arguments.length - 1] = wrapCallback(cb, ctx, 'apm:couchbase:query')
-    }
-
-    return query.apply(this, arguments)
+// Hand-rolled instead of `tracingChannel.tracePromise`: synchronous
+// `res.then(...)` dodges the `Promise.resolve(thenable)` microtask race on
+// SDK v3.2.x / v4.0-v4.4 (lazy listener attachment), and external `.on()`
+// is forbidden on v4.5.0+ (JSCBC-1301 depromisify). See commit body.
+/**
+ * @param {import('node:diagnostics_channel').TracingChannel} ch
+ *   Pinned per-op channel.
+ * @param {(...callArgs: unknown[]) => unknown} fn The SDK method being traced.
+ * @param {object} ctx Mutated to record `result` / `error`.
+ * @param {object} thisArg
+ * @param {unknown[]} args Forwarded to `fn` verbatim.
+ */
+function traceV3 (ch, fn, ctx, thisArg, args) {
+  if (!ch.start.hasSubscribers) return fn.apply(thisArg, args)
+  const cbIndex = findCallbackIndex(args, 1)
+  if (cbIndex >= 0) {
+    return ch.traceCallback(fn, cbIndex, ctx, thisArg, ...args)
   }
-}
-
-function wrapCallbackFinish (callback, thisArg, _args, errorCh, finishCh, ctx, channelPrefix) {
-  const callbackStartCh = channel(`${channelPrefix}:callback:start`)
-  const callbackFinishCh = channel(`${channelPrefix}:callback:finish`)
-
-  const wrapped = callbackStartCh.runStores(ctx, () => {
-    return function finish (error, result) {
-      return callbackFinishCh.runStores(ctx, () => {
-        if (error) {
-          ctx.error = error
-          errorCh.publish(ctx)
-        }
-        finishCh.publish(ctx)
-        return callback.apply(thisArg, [error, result])
-      })
-    }
-  })
-  Object.defineProperty(wrapped, '_dd_wrapped', { value: true })
-  return wrapped
-}
-
-function wrap (prefix, fn) {
-  const startCh = channel(prefix + ':start')
-  const finishCh = channel(prefix + ':finish')
-  const errorCh = channel(prefix + ':error')
-
-  const wrapped = function () {
-    if (!startCh.hasSubscribers) {
-      return fn.apply(this, arguments)
-    }
-
-    const callbackIndex = findCallbackIndex(arguments, 1)
-
-    if (callbackIndex < 0) return fn.apply(this, arguments)
-
-    const ctx = { bucket: { name: this.name || this._name }, seedNodes: this._dd_hosts }
-    return startCh.runStores(ctx, () => {
-      const cb = arguments[callbackIndex]
-
-      arguments[callbackIndex] = shimmer.wrapFunction(cb, (cb) => {
-        return wrapCallbackFinish(cb, this, arguments, errorCh, finishCh, ctx, prefix)
-      })
-
-      try {
-        return fn.apply(this, arguments)
-      } catch (error) {
-        ctx.error = error
-        void error.stack // trigger getting the stack at the original throwing point
-        errorCh.publish(ctx)
-
-        throw error
-      }
-    })
-  }
-  return wrapped
-}
-
-// semver >=2 <3
-function wrapMaybeInvoke (_maybeInvoke, channelPrefix) {
-  return function (fn, args) {
-    if (!Array.isArray(args)) return _maybeInvoke.apply(this, arguments)
-
-    const callbackIndex = findCallbackIndex(args, 0)
-
-    if (callbackIndex === -1) return _maybeInvoke.apply(this, arguments)
-
-    const callback = args[callbackIndex]
-
-    if (typeof callback === 'function' && !callback._dd_wrapped) {
-      const ctx = {}
-      args[callbackIndex] = wrapCallback(callback, ctx, channelPrefix)
-    }
-
-    return _maybeInvoke.apply(this, arguments)
-  }
-}
-
-// semver >=3
-
-function wrapCBandPromise (fn, name, startData, thisArg, args) {
-  const startCh = channel(`apm:couchbase:${name}:start`)
-  const finishCh = channel(`apm:couchbase:${name}:finish`)
-  const errorCh = channel(`apm:couchbase:${name}:error`)
-
-  if (!startCh.hasSubscribers) return fn.apply(thisArg, args)
-
-  const ctx = startData
-  return startCh.runStores(ctx, () => {
+  return ch.start.runStores(ctx, () => {
     try {
-      const cbIndex = findCallbackIndex(args, 1)
-      if (cbIndex >= 0) {
-        // v3 offers callback or promises event handling
-        // NOTE: this does not work with v3.2.0-3.2.1 cluster.query, as there is a bug in the couchbase source code
-        args[cbIndex] = shimmer.wrapFunction(args[cbIndex], (cb) => {
-          return wrapCallbackFinish(cb, thisArg, args, errorCh, finishCh, ctx, `apm:couchbase:${name}`)
-        })
-      }
       const res = fn.apply(thisArg, args)
-
-      // semver >=3 will always return promise by default
       res.then(
         (result) => {
           ctx.result = result
-          finishCh.publish(ctx)
+          ch.asyncStart.publish(ctx)
+          ch.asyncEnd.publish(ctx)
         },
-        (err) => {
-          ctx.error = err
-          errorCh.publish(ctx)
-          finishCh.publish(ctx)
+        (error) => {
+          ctx.error = error
+          ch.error.publish(ctx)
+          ch.asyncStart.publish(ctx)
+          ch.asyncEnd.publish(ctx)
         }
       )
       return res
-    } catch (e) {
-      void e.stack
-      ctx.error = e
-      errorCh.publish(ctx)
-      throw e
+    } catch (error) {
+      ctx.error = error
+      ch.error.publish(ctx)
+      throw error
+    } finally {
+      ch.end.publish(ctx)
     }
   })
 }
 
-function wrapWithName (name) {
+/**
+ * @param {string} name Operation name (`upsert`, `insert`, `replace`).
+ */
+function wrapV3WithName (name) {
+  const ch = opChannelByName.get(name)
   return function (operation) {
-    return function () { // no arguments used by us
-      return wrapCBandPromise(operation, name, {
+    return function (...args) {
+      const ctx = {
         collection: { name: this._name || '_default' },
         bucket: { name: this._scope._bucket._name },
         seedNodes: this._dd_connStr,
-      }, this, arguments)
+      }
+      return traceV3(ch, operation, ctx, this, args)
     }
   }
 }
 
+/**
+ * @param {(...args: unknown[]) => unknown} query Original `Cluster.prototype.query`.
+ */
 function wrapV3Query (query) {
-  return function (q) {
-    const resource = getQueryResource(q)
-    return wrapCBandPromise(query, 'query', { resource, seedNodes: this._connStr }, this, arguments)
+  return function (...args) {
+    const ctx = { resource: getQueryResource(args[0]), seedNodes: this._connStr }
+    return traceV3(queryCh, query, ctx, this, args)
   }
 }
 
-// semver >=2 <3
-addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^2.6.12'] }, Bucket => {
-  shimmer.wrap(Bucket.prototype, '_maybeInvoke', maybeInvoke => {
-    return wrapMaybeInvoke(maybeInvoke, 'apm:couchbase:bucket:maybeInvoke')
-  })
-
-  const startCh = channel('apm:couchbase:query:start')
-  const finishCh = channel('apm:couchbase:query:finish')
-  const errorCh = channel('apm:couchbase:query:error')
-
-  shimmer.wrap(Bucket.prototype, 'query', query => wrapQuery(query))
-
-  shimmer.wrap(Bucket.prototype, '_n1qlReq', _n1qlReq => function (host, q, adhoc, emitter) {
-    if (!startCh.hasSubscribers) {
-      return _n1qlReq.apply(this, arguments)
-    }
-
-    if (!emitter || !emitter.once) return _n1qlReq.apply(this, arguments)
-
-    const n1qlQuery = getQueryResource(q)
-
-    const ctx = { resource: n1qlQuery, bucket: { name: this.name || this._name }, seedNodes: this._dd_hosts }
-    return startCh.runStores(ctx, () => {
-      emitter.once('rows', () => {
-        finishCh.publish(ctx)
-      })
-
-      emitter.once(errorMonitor, (error) => {
-        if (!error) return
-        ctx.error = error
-        errorCh.publish(ctx)
-        finishCh.publish(ctx)
-      })
-
-      try {
-        return _n1qlReq.apply(this, arguments)
-      } catch (err) {
-        void err.stack // trigger getting the stack at the original throwing point
-        ctx.error = err
-        errorCh.publish(ctx)
-
-        throw err
-      }
-    })
-  })
-
-  wrapAllNames(['upsert', 'insert', 'replace', 'append', 'prepend'], name => {
-    shimmer.wrap(Bucket.prototype, name, fn => wrap(`apm:couchbase:${name}`, fn))
-  })
-
-  return Bucket
-})
-
-addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^2.6.12'] }, Cluster => {
-  shimmer.wrap(Cluster.prototype, '_maybeInvoke', maybeInvoke => {
-    return wrapMaybeInvoke(maybeInvoke, 'apm:couchbase:cluster:maybeInvoke')
-  })
-
-  shimmer.wrap(Cluster.prototype, 'query', query => wrapQuery(query))
-  shimmer.wrap(Cluster.prototype, 'openBucket', openBucket => {
-    return function () {
-      const bucket = openBucket.apply(this, arguments)
-      const hosts = this.dsnObj.hosts
-      bucket._dd_hosts = hosts.map(hostAndPort => hostAndPort.join(':')).join(',')
-      return bucket
-    }
-  })
-  return Cluster
-})
-
 // semver >=3 <3.2.0
 
 addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^3.0.7', '^3.1.3'] }, Bucket => {
   shimmer.wrap(Bucket.prototype, 'collection', getCollection => {
-    return function () {
-      const collection = getCollection.apply(this, arguments)
+    return function (...args) {
+      const collection = getCollection.apply(this, args)
       const connStr = this._cluster._connStr
       collection._dd_connStr = connStr
       return collection
     }
   })
-
-  return Bucket
 })
 
 addHook({ name: 'couchbase', file: 'lib/collection.js', versions: ['^3.0.7', '^3.1.3'] }, Collection => {
-  wrapAllNames(['upsert', 'insert', 'replace'], name => {
-    shimmer.wrap(Collection.prototype, name, wrapWithName(name))
-  })
-
-  return Collection
+  for (const name of ['upsert', 'insert', 'replace']) {
+    shimmer.wrap(Collection.prototype, name, wrapV3WithName(name))
+  }
 })
 
 addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^3.0.7', '^3.1.3'] }, Cluster => {
   shimmer.wrap(Cluster.prototype, 'query', wrapV3Query)
-  return Cluster
 })
 
 // semver >=3.2.2
@@ -295,30 +135,25 @@ addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^3.0.7', '^3.1.
 addHook({ name: 'couchbase', file: 'dist/collection.js', versions: ['>=3.2.2'] }, collection => {
   const Collection = collection.Collection
 
-  wrapAllNames(['upsert', 'insert', 'replace'], name => {
-    shimmer.wrap(Collection.prototype, name, wrapWithName(name))
-  })
-
-  return collection
+  for (const name of ['upsert', 'insert', 'replace']) {
+    shimmer.wrap(Collection.prototype, name, wrapV3WithName(name))
+  }
 })
 
 addHook({ name: 'couchbase', file: 'dist/bucket.js', versions: ['>=3.2.2'] }, bucket => {
   const Bucket = bucket.Bucket
   shimmer.wrap(Bucket.prototype, 'collection', getCollection => {
-    return function () {
-      const collection = getCollection.apply(this, arguments)
+    return function (...args) {
+      const collection = getCollection.apply(this, args)
       const connStr = this._cluster._connStr
       collection._dd_connStr = connStr
       return collection
     }
   })
-
-  return bucket
 })
 
 addHook({ name: 'couchbase', file: 'dist/cluster.js', versions: ['>=3.2.2'] }, (cluster) => {
   const Cluster = cluster.Cluster
 
   shimmer.wrap(Cluster.prototype, 'query', wrapV3Query)
-  return cluster
 })

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

@@ -47,12 +47,12 @@ addHook({ name: 'crypto' }, crypto => {
 
 function wrapCryptoMethod (channel) {
   function wrapMethod (cryptoMethod) {
-    return function () {
-      if (channel.hasSubscribers && arguments.length > 0) {
-        const algorithm = arguments[0]
+    return function (...args) {
+      if (channel.hasSubscribers && args.length > 0) {
+        const algorithm = args[0]
         channel.publish({ algorithm })
       }
-      return cryptoMethod.apply(this, arguments)
+      return cryptoMethod.apply(this, args)
     }
   }
   return wrapMethod