@depup/dd-trace 5.90.0-depup.0

package/packages/datadog-instrumentations/src/light-my-request.js

@@ -0,0 +1,93 @@
+'use strict'
+
+/**
+ * light-my-request instrumentation
+ *
+ * This instrumentation enables dd-trace to capture spans for Fastify inject() calls
+ * which use light-my-request internally. Without this, inject() bypasses the HTTP
+ * server instrumentation since it doesn't go through http.Server.emit('request').
+ *
+ * This is critical for platforms like Platformatic that use undici-thread-interceptor
+ * to route requests between worker threads using Fastify inject().
+ */
+
+const shimmer = require('../../datadog-shimmer')
+const {
+  channel,
+  addHook,
+} = require('./helpers/instrument')
+
+// Reuse the same channels as HTTP server instrumentation
+const startServerCh = channel('apm:http:server:request:start')
+const exitServerCh = channel('apm:http:server:request:exit')
+const errorServerCh = channel('apm:http:server:request:error')
+const finishServerCh = channel('apm:http:server:request:finish')
+
+addHook({ name: 'light-my-request', versions: ['>=3'] }, (lightMyRequest) => {
+  // Wrap the inject function
+  return shimmer.wrapFunction(lightMyRequest, lightMyRequest => {
+    return function wrappedInject (dispatchFunc, options, callback) {
+      // If no subscribers, use original behavior
+      if (!startServerCh.hasSubscribers) {
+        return lightMyRequest.apply(this, arguments)
+      }
+
+      // Wrap the dispatch function to add tracing
+      const wrappedDispatch = wrapDispatchFunc(dispatchFunc)
+
+      // Call original with wrapped dispatch
+      return lightMyRequest.call(this, wrappedDispatch, options, callback)
+    }
+  })
+})
+
+function wrapDispatchFunc (dispatchFunc) {
+  return function tracedDispatch (req, res) {
+    const abortController = new AbortController()
+
+    // Link res.req like HTTP instrumentation does
+    res.req = req
+
+    // Publish start event (same as HTTP server)
+    startServerCh.publish({ req, res, abortController })
+
+    // Track when response finishes via 'finish' event (like HTTP instrumentation)
+    let finishCalled = false
+    const onFinish = () => {
+      if (!finishCalled) {
+        finishCalled = true
+        finishServerCh.publish({ req })
+      }
+    }
+
+    // light-my-request Response emits 'finish' when done
+    if (res.on && typeof res.on === 'function') {
+      res.once('finish', onFinish)
+      res.once('close', onFinish)
+    }
+
+    // Also wrap end() as fallback
+    const originalEnd = res.end
+    if (originalEnd) {
+      res.end = function wrappedEnd () {
+        const result = originalEnd.apply(this, arguments)
+        // Trigger finish if events don't fire
+        setImmediate(onFinish)
+        return result
+      }
+    }
+
+    try {
+      if (abortController.signal.aborted) {
+        return
+      }
+
+      return dispatchFunc.call(this, req, res)
+    } catch (err) {
+      errorServerCh.publish(err)
+      throw err
+    } finally {
+      exitServerCh.publish({ req })
+    }
+  }
+}

package/packages/datadog-instrumentations/src/limitd-client.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook, AsyncResource } = require('./helpers/instrument')
+
+function wrapRequest (original) {
+  return function () {
+    const id = arguments.length - 1
+    arguments[id] = AsyncResource.bind(arguments[id])
+    return original.apply(this, arguments)
+  }
+}
+
+addHook({
+  name: 'limitd-client',
+  versions: ['>=2.8'],
+  file: ['client.js'],
+}, LimitdClient => {
+  shimmer.wrap(LimitdClient.prototype, '_directRequest', wrapRequest)
+  shimmer.wrap(LimitdClient.prototype, '_retriedRequest', wrapRequest)
+  return LimitdClient
+})

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

@@ -0,0 +1,30 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { channel, addHook } = require('./helpers/instrument')
+
+addHook({ name: 'lodash', versions: ['>=4'] }, lodash => {
+  const lodashOperationCh = channel('datadog:lodash:operation')
+
+  const instrumentedLodashFn = ['trim', 'trimStart', 'trimEnd', 'toLower', 'toUpper', 'join']
+
+  shimmer.massWrap(
+    lodash,
+    instrumentedLodashFn,
+    lodashFn => {
+      return function () {
+        if (!lodashOperationCh.hasSubscribers) {
+          return lodashFn.apply(this, arguments)
+        }
+
+        const result = lodashFn.apply(this, arguments)
+        const message = { operation: lodashFn.name, arguments, result }
+        lodashOperationCh.publish(message)
+
+        return message.result
+      }
+    }
+  )
+
+  return lodash
+})

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

@@ -0,0 +1,186 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { channel, addHook } = require('./helpers/instrument')
+
+const commandAddCh = channel('apm:mariadb:command:add')
+const connectionStartCh = channel('apm:mariadb:connection:start')
+const connectionFinishCh = channel('apm:mariadb:connection:finish')
+const startCh = channel('apm:mariadb:query:start')
+const finishCh = channel('apm:mariadb:query:finish')
+const errorCh = channel('apm:mariadb:query:error')
+const skipCh = channel('apm:mariadb:pool:skip')
+
+function wrapCommandStart (start, ctx) {
+  return shimmer.wrapFunction(start, start => function () {
+    if (!startCh.hasSubscribers) return start.apply(this, arguments)
+
+    const { reject, resolve } = this
+    shimmer.wrap(this, 'resolve', function wrapResolve () {
+      return function () {
+        return finishCh.runStores(ctx, resolve, this, ...arguments)
+      }
+    })
+
+    shimmer.wrap(this, 'reject', function wrapReject () {
+      return function (error) {
+        ctx.error = error
+
+        errorCh.publish(ctx)
+
+        return finishCh.runStores(ctx, reject, this, ...arguments)
+      }
+    })
+
+    return startCh.runStores(ctx, start, this, ...arguments)
+  })
+}
+
+function wrapCommand (Command) {
+  return class extends Command {
+    constructor (...args) {
+      super(...args)
+
+      if (!this.start) return
+
+      const ctx = { sql: this.sql, conf: this.opts }
+
+      commandAddCh.publish(ctx)
+
+      this.start = wrapCommandStart(this.start, ctx)
+    }
+  }
+}
+
+function createWrapQuery (options) {
+  return function wrapQuery (query) {
+    return function (sql) {
+      if (!startCh.hasSubscribers) return query.apply(this, arguments)
+
+      const ctx = { sql, conf: options }
+
+      return startCh.runStores(ctx, query, this, ...arguments)
+        .then(result => {
+          ctx.result = result
+          finishCh.publish(ctx)
+          return result
+        }, error => {
+          ctx.error = error
+          errorCh.publish(ctx)
+          finishCh.publish(ctx)
+          throw error
+        })
+    }
+  }
+}
+
+function createWrapQueryCallback (options) {
+  return function wrapQuery (query) {
+    return function (sql) {
+      if (!startCh.hasSubscribers) return query.apply(this, arguments)
+
+      const cb = arguments[arguments.length - 1]
+      const ctx = { sql, conf: options }
+      const wrapper = (cb) => function (err) {
+        if (err) {
+          ctx.error = err
+          errorCh.publish(ctx)
+        }
+
+        return typeof cb === 'function'
+          ? finishCh.runStores(ctx, cb, this, ...arguments)
+          : finishCh.publish(ctx)
+      }
+
+      if (typeof cb === 'function') {
+        arguments[arguments.length - 1] = shimmer.wrapFunction(cb, wrapper)
+      } else {
+        arguments.length += 1
+        arguments[arguments.length - 1] = wrapper()
+      }
+
+      return startCh.runStores(ctx, query, this, ...arguments)
+    }
+  }
+}
+
+function wrapConnection (promiseMethod, Connection) {
+  return function (options) {
+    Connection.apply(this, arguments)
+
+    shimmer.wrap(this, promiseMethod, createWrapQuery(options))
+    shimmer.wrap(this, '_queryCallback', createWrapQueryCallback(options))
+  }
+}
+
+function wrapPoolBase (PoolBase) {
+  return function (options, processTask, createConnectionPool, pingPromise) {
+    arguments[1] = wrapPoolMethod(processTask)
+    arguments[2] = wrapPoolMethod(createConnectionPool)
+
+    PoolBase.apply(this, arguments)
+
+    shimmer.wrap(this, 'query', createWrapQuery(options.connOptions))
+  }
+}
+
+// It's not possible to prevent connection pools from leaking across queries,
+// so instead we just skip instrumentation completely to avoid memory leaks
+// and/or orphan spans.
+function wrapPoolMethod (createConnection) {
+  return function () {
+    return skipCh.runStores({}, createConnection, this, ...arguments)
+  }
+}
+
+function wrapPoolGetConnectionMethod (getConnection) {
+  return function wrappedGetConnection () {
+    const cb = arguments[arguments.length - 1]
+    if (typeof cb !== 'function') return getConnection.apply(this, arguments)
+
+    const ctx = {}
+
+    arguments[arguments.length - 1] = function () {
+      return connectionFinishCh.runStores(ctx, cb, this, ...arguments)
+    }
+
+    connectionStartCh.publish(ctx)
+
+    return getConnection.apply(this, arguments)
+  }
+}
+
+const name = 'mariadb'
+
+addHook({ name, file: 'lib/cmd/query.js', versions: ['>=3'] }, (Query) => {
+  return wrapCommand(Query)
+})
+
+addHook({ name, file: 'lib/cmd/execute.js', versions: ['>=3'] }, (Execute) => {
+  return wrapCommand(Execute)
+})
+
+// in 3.4.1 getConnection method start to use callbacks instead of promises
+addHook({ name, file: 'lib/pool.js', versions: ['>=3.4.1'] }, (Pool) => {
+  shimmer.wrap(Pool.prototype, 'getConnection', wrapPoolGetConnectionMethod)
+
+  return Pool
+})
+
+addHook({ name, file: 'lib/pool.js', versions: ['>=3'] }, (Pool) => {
+  shimmer.wrap(Pool.prototype, '_createConnection', wrapPoolMethod)
+
+  return Pool
+})
+
+addHook({ name, file: 'lib/connection.js', versions: ['>=2.5.2 <3'] }, (Connection) => {
+  return shimmer.wrapFunction(Connection, wrapConnection.bind(null, '_queryPromise'))
+})
+
+addHook({ name, file: 'lib/connection.js', versions: ['>=2.0.4 <=2.5.1'] }, (Connection) => {
+  return shimmer.wrapFunction(Connection, wrapConnection.bind(null, 'query'))
+})
+
+addHook({ name, file: 'lib/pool-base.js', versions: ['>=2.0.4 <3'] }, (PoolBase) => {
+  return shimmer.wrapFunction(PoolBase, wrapPoolBase)
+})

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

@@ -0,0 +1,45 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const {
+  channel,
+  addHook,
+} = require('./helpers/instrument')
+
+addHook({ name: 'memcached', versions: ['>=2.2'] }, Memcached => {
+  const startCh = channel('apm:memcached:command:start')
+  const finishCh = channel('apm:memcached:command:finish')
+  const errorCh = channel('apm:memcached:command:error')
+
+  shimmer.wrap(Memcached.prototype, 'command', command => function (queryCompiler, server) {
+    if (!startCh.hasSubscribers) {
+      return command.apply(this, arguments)
+    }
+
+    const client = this
+
+    const wrappedQueryCompiler = function () {
+      const query = queryCompiler.apply(this, arguments)
+
+      const ctx = { client, server, query }
+      startCh.runStores(ctx, () => {
+        query.callback = shimmer.wrapFunction(query.callback, callback => function (err) {
+          if (err) {
+            ctx.error = err
+            errorCh.publish(ctx)
+          }
+          finishCh.publish(ctx)
+
+          return finishCh.runStores(ctx, callback, this, ...arguments)
+        })
+      })
+      return query
+    }
+
+    arguments[0] = wrappedQueryCompiler
+
+    return command.apply(this, arguments)
+  })
+
+  return Memcached
+})

package/packages/datadog-instrumentations/src/microgateway-core.js

@@ -0,0 +1,69 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel } = require('./helpers/instrument')
+
+const handleChannel = channel('apm:microgateway-core:request:handle')
+const routeChannel = channel('apm:microgateway-core:request:route')
+const errorChannel = channel('apm:microgateway-core:request:error')
+
+const name = 'microgateway-core'
+
+// TODO Remove " <=3.0.0" when "volos-util-apigee" module is fixed
+const versions = ['>=2.1 <=3.0.0']
+const requestContexts = new WeakMap()
+
+function wrapConfigProxyFactory (configProxyFactory) {
+  return function () {
+    const configProxy = configProxyFactory.apply(this, arguments)
+
+    return function (req, res, next) {
+      const ctx = { req, res }
+
+      requestContexts.set(req, ctx)
+
+      handleChannel.publish(ctx)
+
+      return configProxy.apply(this, arguments)
+    }
+  }
+}
+
+function wrapPluginsFactory (pluginsFactory) {
+  return function (plugins) {
+    const pluginsMiddleware = pluginsFactory.apply(this, arguments)
+
+    return function pluginsMiddlewareWithTrace (req, res, next) {
+      arguments[2] = wrapNext(req, res, next)
+
+      return pluginsMiddleware.apply(this, arguments)
+    }
+  }
+}
+
+function wrapNext (req, res, next) {
+  return shimmer.wrapFunction(next, next => function nextWithTrace (err) {
+    const ctx = requestContexts.get(req)
+
+    if (err) {
+      ctx.error = err
+      errorChannel.publish(ctx)
+    }
+
+    if (res.proxy && res.proxy.base_path) {
+      ctx.req = req
+      ctx.res = res
+      ctx.route = res.proxy.base_path
+      routeChannel.publish(ctx)
+    }
+    return next.apply(this, arguments)
+  })
+}
+
+addHook({ name, versions, file: 'lib/config-proxy-middleware.js' }, configProxyFactory => {
+  return shimmer.wrapFunction(configProxyFactory, wrapConfigProxyFactory)
+})
+
+addHook({ name, versions, file: 'lib/plugins-middleware.js' }, pluginsFactory => {
+  return shimmer.wrapFunction(pluginsFactory, wrapPluginsFactory)
+})

package/packages/datadog-instrumentations/src/mocha/common.js

@@ -0,0 +1,50 @@
+'use strict'
+
+const { addHook, channel } = require('../helpers/instrument')
+const shimmer = require('../../../datadog-shimmer')
+const { getCallSites } = require('../../../dd-trace/src/plugins/util/stacktrace')
+const { testToStartLine } = require('./utils')
+
+const parameterizedTestCh = channel('ci:mocha:test:parameterize')
+const patched = new WeakSet()
+
+// mocha-each support
+addHook({
+  name: 'mocha-each',
+  versions: ['>=2.0.1'],
+}, mochaEach => {
+  if (patched.has(mochaEach)) return mochaEach
+
+  patched.add(mochaEach)
+
+  return shimmer.wrapFunction(mochaEach, mochaEach => function () {
+    const [params] = arguments
+    const { it, ...rest } = mochaEach.apply(this, arguments)
+    return {
+      it: function (title) {
+        parameterizedTestCh.publish({ title, params })
+        it.apply(this, arguments)
+      },
+      ...rest,
+    }
+  })
+})
+
+// support for start line
+addHook({
+  name: 'mocha',
+  versions: ['>=5.2.0'],
+  file: 'lib/suite.js',
+}, (Suite) => {
+  shimmer.wrap(Suite.prototype, 'addTest', addTest => function (test) {
+    const callSites = getCallSites()
+    let startLine
+    const testCallSite = callSites.find(site => site.getFileName() === test.file)
+    if (testCallSite) {
+      startLine = testCallSite.getLineNumber()
+      testToStartLine.set(test, startLine)
+    }
+    return addTest.apply(this, arguments)
+  })
+  return Suite
+})