@depup/dd-trace 5.90.0-depup.0

package/packages/datadog-instrumentations/src/helpers/bundler-register.js

@@ -0,0 +1,68 @@
+'use strict'
+
+const dc = require('dc-polyfill')
+
+const log = require('../../../dd-trace/src/log')
+const {
+  filename,
+  loadChannel,
+  matchVersion,
+} = require('./register.js')
+const hooks = require('./hooks')
+const instrumentations = require('./instrumentations')
+
+const CHANNEL = 'dd-trace:bundler:load'
+
+if (!dc.subscribe) {
+  dc.subscribe = (channel, cb) => {
+    dc.channel(channel).subscribe(cb)
+  }
+}
+if (!dc.unsubscribe) {
+  dc.unsubscribe = (channel, cb) => {
+    if (dc.channel(channel).hasSubscribers) {
+      dc.channel(channel).unsubscribe(cb)
+    }
+  }
+}
+
+function doHook (payload) {
+  const hook = hooks[payload.package]
+  if (!hook) {
+    log.error('esbuild-wrapped %s missing in list of hooks', payload.package)
+    return
+  }
+
+  const hookFn = hook.fn ?? hook
+  if (typeof hookFn !== 'function') {
+    log.error('esbuild-wrapped hook %s is not a function', payload.package)
+    return
+  }
+
+  try {
+    hookFn()
+  } catch {
+    log.error('esbuild-wrapped %s hook failed', payload.package)
+  }
+}
+
+dc.subscribe(CHANNEL, (payload) => {
+  doHook(payload)
+
+  if (!instrumentations[payload.package]) {
+    log.error('esbuild-wrapped %s missing in list of instrumentations', payload.package)
+    return
+  }
+
+  for (const { name, file, versions, hook } of instrumentations[payload.package]) {
+    if (payload.path !== filename(name, file)) continue
+    if (!matchVersion(payload.version, versions)) continue
+
+    try {
+      loadChannel.publish({ name, version: payload.version, file })
+      payload.module = hook(payload.module, payload.version)
+    } catch (e) {
+      log.error('Error executing bundler hook', e)
+    }
+  }
+})

package/packages/datadog-instrumentations/src/helpers/check-require-cache.js

@@ -0,0 +1,103 @@
+'use strict'
+
+// This code runs before the tracer is configured and before a logger is ready
+// For that reason we queue up the messages now and decide what to do with them later
+const warnings = []
+
+/**
+ * Here we maintain a list of packages that an application
+ * may have installed which could potentially conflict with
+ */
+const potentialConflicts = new Set([
+  '@appsignal/javascript',
+  '@appsignal/nodejs',
+  '@dynatrace/oneagent',
+  '@instana/aws-fargate',
+  '@instana/aws-lambda',
+  '@instana/azure-container-services',
+  '@instana/collector',
+  '@instana/google-cloud-run',
+  '@sentry/node',
+  'appoptics-apm',
+  'atatus-nodejs',
+  'elastic-apm-node',
+  'newrelic',
+  'stackify-node-apm',
+  'sqreen',
+])
+
+const extractPackageAndModulePath = require('./extract-package-and-module-path')
+
+/**
+ * The lowest hanging fruit to debug an app that isn't tracing
+ * properly is to check that it is loaded before any modules
+ * that need to be instrumented. This function checks the
+ * `require.cache` to see if any supported packages have
+ * already been required and prints a warning.
+ *
+ * Note that this only going to work for modules within npm
+ * packages, like `express`, and not internal modules, like
+ * `http`. It also only works with CJS, not with ESM imports.
+ *
+ * The output isn't necessarily 100% perfect. For example if the
+ * app loads a package we instrument but outside of an
+ * unsupported version then a warning would still be displayed.
+ * This is OK as the tracer should be loaded earlier anyway.
+ */
+module.exports.checkForRequiredModules = function () {
+  const packages = require('./hooks')
+  const naughties = new Set()
+  let didWarn = false
+
+  for (const pathToModule of Object.keys(require.cache)) {
+    const { pkg } = extractPackageAndModulePath(pathToModule)
+
+    if (naughties.has(pkg)) continue
+    if (!(pkg in packages)) continue
+
+    warnings.push(() => `Warning: Package '${pkg}' was loaded before dd-trace! This may break instrumentation.`)
+
+    naughties.add(pkg)
+    didWarn = true
+  }
+
+  if (didWarn) warnings.push('Warning: Please ensure dd-trace is loaded before other modules.')
+}
+
+/**
+ * APM tools, and some other packages in the community, work
+ * by monkey-patching internal modules and possibly some
+ * globals. Usually this is done in a conflict-free way by
+ * wrapping an existing method with a new method that still
+ * calls the original method. Unfortunately it's possible
+ * that some of these packages (dd-trace included) may
+ * wrap methods in a way that make it unsafe for the methods
+ * to be wrapped again by another library.
+ *
+ * When encountered, and when debug mode is on, a warning is
+ * printed if such a package is discovered. This can help
+ * when debugging a faulty installation.
+ */
+module.exports.checkForPotentialConflicts = function () {
+  const naughties = new Set()
+  let didWarn = false
+
+  for (const pathToModule of Object.keys(require.cache)) {
+    const { pkg } = extractPackageAndModulePath(pathToModule)
+    if (naughties.has(pkg)) continue
+    if (!potentialConflicts.has(pkg)) continue
+
+    warnings.push(() => `Warning: Package '${pkg}' may cause conflicts with dd-trace.`)
+
+    naughties.add(pkg)
+    didWarn = true
+  }
+
+  if (didWarn) warnings.push('Warning: Packages were loaded that may conflict with dd-trace.')
+}
+
+module.exports.flushStartupLogs = function (log) {
+  while (warnings.length) {
+    log.warn(warnings.shift())
+  }
+}

package/packages/datadog-instrumentations/src/helpers/extract-package-and-module-path.js

@@ -0,0 +1,42 @@
+'use strict'
+
+const NM = 'node_modules/'
+
+/**
+ * For a given full path to a module,
+ *   return the package name it belongs to and the local path to the module
+ *   input: '/foo/node_modules/@co/stuff/foo/bar/baz.js'
+ *   output: { pkg: '@co/stuff', path: 'foo/bar/baz.js',  pkgJson: '/foo/node_modules/@co/stuff/package.json' }
+ */
+module.exports = function extractPackageAndModulePath (fullPath) {
+  const nm = fullPath.lastIndexOf(NM)
+  if (nm === -1) {
+    return { pkg: null, path: null }
+  }
+
+  const subPath = fullPath.slice(nm + NM.length)
+  const firstSlash = subPath.indexOf('/')
+
+  const firstPath = fullPath.slice(0, nm + NM.length)
+
+  const firstSlashSubPath = subPath.slice(Math.max(0, firstSlash + 1))
+
+  if (subPath[0] === '@') {
+    const secondSlash = firstSlashSubPath.indexOf('/')
+    const pkg = subPath.slice(0, Math.max(0, firstSlash + 1 + secondSlash))
+
+    return {
+      pkg,
+      path: subPath.slice(Math.max(0, firstSlash + 1 + secondSlash + 1)),
+      pkgJson: firstPath + pkg + '/package.json',
+    }
+  }
+
+  const pkg = subPath.slice(0, Math.max(0, firstSlash))
+
+  return {
+    pkg,
+    path: firstSlashSubPath,
+    pkgJson: firstPath + pkg + '/package.json',
+  }
+}

package/packages/datadog-instrumentations/src/helpers/fetch.js

@@ -0,0 +1,26 @@
+'use strict'
+
+exports.createWrapFetch = function createWrapFetch (Request, ch, onLoad) {
+  return function wrapFetch (fetch) {
+    if (typeof fetch !== 'function') return fetch
+
+    return function (input, init) {
+      if (onLoad) {
+        onLoad()
+        onLoad = undefined
+      }
+
+      if (!ch.start.hasSubscribers) return fetch.apply(this, arguments)
+
+      if (input instanceof Request) {
+        const ctx = { req: input }
+
+        return ch.tracePromise(() => fetch.call(this, input, init), ctx)
+      }
+      const req = new Request(input, init)
+      const ctx = { req }
+
+      return ch.tracePromise(() => fetch.call(this, req), ctx)
+    }
+  }
+}

package/packages/datadog-instrumentations/src/helpers/hook.js

@@ -0,0 +1,75 @@
+'use strict'
+const path = require('path')
+const iitm = require('../../../dd-trace/src/iitm')
+const ritm = require('../../../dd-trace/src/ritm')
+
+/**
+ * This is called for every package/internal-module that dd-trace supports instrumentation for
+ * In practice, `modules` is always an array with a single entry.
+ *
+ * @param {string[]} modules list of modules to hook into
+ * @param {object} hookOptions hook options
+ * @param {Function} onrequire callback to be executed upon encountering module
+ */
+function Hook (modules, hookOptions, onrequire) {
+  if (!(this instanceof Hook)) return new Hook(modules, hookOptions, onrequire)
+
+  if (typeof hookOptions === 'function') {
+    onrequire = hookOptions
+    hookOptions = {}
+  }
+
+  this._patched = Object.create(null)
+  const patched = new WeakMap()
+
+  const safeHook = (moduleExports, moduleName, moduleBaseDir, moduleVersion, isIitm) => {
+    const parts = [moduleBaseDir, moduleName].filter(Boolean)
+    const filename = path.join(...parts)
+
+    let defaultWrapResult
+
+    const wrappedOnrequire = (moduleExports, ...args) => {
+      if (this._patched[filename] && patched.has(moduleExports)) {
+        return patched.get(moduleExports)
+      }
+
+      const result = onrequire(moduleExports, ...args)
+      if (result && (typeof result === 'object' || typeof result === 'function')) {
+        patched.set(moduleExports, result)
+        patched.set(result, result)
+      }
+
+      return result
+    }
+
+    if (
+      isIitm &&
+      moduleExports.default &&
+      (typeof moduleExports.default === 'object' ||
+      typeof moduleExports.default === 'function')
+    ) {
+      defaultWrapResult = wrappedOnrequire(moduleExports.default, moduleName, moduleBaseDir, moduleVersion, isIitm)
+    }
+
+    const newExports = wrappedOnrequire(moduleExports, moduleName, moduleBaseDir, moduleVersion, isIitm)
+
+    if (defaultWrapResult) newExports.default = defaultWrapResult
+
+    this._patched[filename] = true
+
+    return newExports
+  }
+
+  this._ritmHook = ritm(modules, {}, safeHook)
+  this._iitmHook = iitm(modules, hookOptions, (moduleExports, moduleName, moduleBaseDir) => {
+    return safeHook(moduleExports, moduleName, moduleBaseDir, null, true)
+  })
+}
+
+Hook.prototype.unhook = function () {
+  this._ritmHook.unhook()
+  this._iitmHook.unhook()
+  this._patched = Object.create(null)
+}
+
+module.exports = Hook

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -0,0 +1,151 @@
+'use strict'
+
+module.exports = {
+  '@anthropic-ai/sdk': { esmFirst: true, fn: () => require('../anthropic') },
+  '@apollo/server': () => require('../apollo-server'),
+  '@apollo/gateway': () => require('../apollo'),
+  'apollo-server-core': () => require('../apollo-server-core'),
+  '@aws-sdk/smithy-client': () => require('../aws-sdk'),
+  '@azure/event-hubs': () => require('../azure-event-hubs'),
+  '@azure/functions': () => require('../azure-functions'),
+  'durable-functions': () => require('../azure-durable-functions'),
+  '@azure/service-bus': () => require('../azure-service-bus'),
+  '@cucumber/cucumber': () => require('../cucumber'),
+  '@playwright/test': () => require('../playwright'),
+  '@elastic/elasticsearch': () => require('../elasticsearch'),
+  '@elastic/transport': () => require('../elasticsearch'),
+  '@google/genai': () => require('../google-genai'),
+  '@google-cloud/pubsub': () => require('../google-cloud-pubsub'),
+  '@google-cloud/vertexai': () => require('../google-cloud-vertexai'),
+  '@graphql-tools/executor': () => require('../graphql'),
+  '@grpc/grpc-js': () => require('../grpc'),
+  '@hapi/hapi': () => require('../hapi'),
+  '@happy-dom/jest-environment': () => require('../jest'),
+  '@jest/core': () => require('../jest'),
+  '@jest/reporters': () => require('../jest'),
+  '@jest/test-sequencer': () => require('../jest'),
+  '@jest/transform': () => require('../jest'),
+  '@koa/router': () => require('../koa'),
+  '@langchain/core': { esmFirst: true, fn: () => require('../langchain') },
+  '@node-redis/client': () => require('../redis'),
+  '@opensearch-project/opensearch': () => require('../opensearch'),
+  '@opentelemetry/sdk-trace-node': () => require('../otel-sdk-trace'),
+  '@prisma/client': { esmFirst: true, fn: () => require('../prisma') },
+  './runtime/library.js': () => require('../prisma'),
+  '@redis/client': () => require('../redis'),
+  '@smithy/smithy-client': () => require('../aws-sdk'),
+  '@vitest/runner': { esmFirst: true, fn: () => require('../vitest') },
+  aerospike: () => require('../aerospike'),
+  ai: () => require('../ai'),
+  amqp10: () => require('../amqp10'),
+  amqplib: () => require('../amqplib'),
+  avsc: () => require('../avsc'),
+  'aws-sdk': () => require('../aws-sdk'),
+  bluebird: () => require('../bluebird'),
+  'body-parser': () => require('../body-parser'),
+  bullmq: () => require('../bullmq'),
+  bunyan: () => require('../bunyan'),
+  'cassandra-driver': () => require('../cassandra-driver'),
+  child_process: () => require('../child_process'),
+  connect: () => require('../connect'),
+  cookie: () => require('../cookie'),
+  'cookie-parser': () => require('../cookie-parser'),
+  couchbase: () => require('../couchbase'),
+  crypto: () => require('../crypto'),
+  cypress: () => require('../cypress'),
+  'dd-trace-api': () => require('../dd-trace-api'),
+  dns: () => require('../dns'),
+  elasticsearch: () => require('../elasticsearch'),
+  express: () => require('../express'),
+  'express-mongo-sanitize': () => require('../express-mongo-sanitize'),
+  'express-session': () => require('../express-session'),
+  fastify: () => require('../fastify'),
+  'find-my-way': () => require('../find-my-way'),
+  fs: { serverless: false, fn: () => require('../fs') },
+  'generic-pool': () => require('../generic-pool'),
+  graphql: () => require('../graphql'),
+  grpc: () => require('../grpc'),
+  handlebars: () => require('../handlebars'),
+  hapi: () => require('../hapi'),
+  hono: { esmFirst: true, fn: () => require('../hono') },
+  http: () => require('../http'),
+  http2: () => require('../http2'),
+  https: () => require('../http'),
+  ioredis: () => require('../ioredis'),
+  iovalkey: () => require('../iovalkey'),
+  'jest-circus': () => require('../jest'),
+  'jest-config': () => require('../jest'),
+  'jest-environment-node': () => require('../jest'),
+  'jest-environment-jsdom': () => require('../jest'),
+  'jest-runtime': () => require('../jest'),
+  'jest-worker': () => require('../jest'),
+  knex: () => require('../knex'),
+  koa: () => require('../koa'),
+  'koa-router': () => require('../koa'),
+  '@confluentinc/kafka-javascript': () => require('../confluentinc-kafka-javascript'),
+  kafkajs: () => require('../kafkajs'),
+  langchain: () => require('../langchain'),
+  ldapjs: () => require('../ldapjs'),
+  'light-my-request': () => require('../light-my-request'),
+  'limitd-client': () => require('../limitd-client'),
+  lodash: () => require('../lodash'),
+  mariadb: () => require('../mariadb'),
+  memcached: () => require('../memcached'),
+  'microgateway-core': () => require('../microgateway-core'),
+  mocha: () => require('../mocha'),
+  'mocha-each': () => require('../mocha'),
+  moleculer: () => require('../moleculer'),
+  mongodb: () => require('../mongodb'),
+  'mongodb-core': () => require('../mongodb-core'),
+  mongoose: () => require('../mongoose'),
+  mquery: () => require('../mquery'),
+  multer: () => require('../multer'),
+  mysql: () => require('../mysql'),
+  mysql2: () => require('../mysql2'),
+  net: () => require('../net'),
+  next: () => require('../next'),
+  'node-serialize': () => require('../node-serialize'),
+  'node:child_process': () => require('../child_process'),
+  'node:crypto': () => require('../crypto'),
+  'node:dns': () => require('../dns'),
+  'node:http': () => require('../http'),
+  'node:http2': () => require('../http2'),
+  'node:https': () => require('../http'),
+  'node:net': () => require('../net'),
+  'node:url': () => require('../url'),
+  'node:vm': () => require('../vm'),
+  nyc: () => require('../nyc'),
+  oracledb: () => require('../oracledb'),
+  openai: { esmFirst: true, fn: () => require('../openai') },
+  passport: () => require('../passport'),
+  'passport-http': () => require('../passport-http'),
+  'passport-local': () => require('../passport-local'),
+  pg: () => require('../pg'),
+  pino: () => require('../pino'),
+  'pino-pretty': () => require('../pino'),
+  playwright: () => require('../playwright'),
+  'playwright-core': () => require('../playwright'),
+  'promise-js': () => require('../promise-js'),
+  promise: () => require('../promise'),
+  protobufjs: () => require('../protobufjs'),
+  pug: () => require('../pug'),
+  q: () => require('../q'),
+  redis: () => require('../redis'),
+  restify: () => require('../restify'),
+  rhea: () => require('../rhea'),
+  router: () => require('../router'),
+  'selenium-webdriver': () => require('../selenium'),
+  sequelize: () => require('../sequelize'),
+  sharedb: () => require('../sharedb'),
+  stripe: () => require('../stripe'),
+  tedious: () => require('../tedious'),
+  tinypool: { esmFirst: true, fn: () => require('../vitest') },
+  undici: () => require('../undici'),
+  url: () => require('../url'),
+  vitest: { esmFirst: true, fn: () => require('../vitest') },
+  vm: () => require('../vm'),
+  when: () => require('../when'),
+  winston: () => require('../winston'),
+  workerpool: () => require('../mocha'),
+  ws: () => require('../ws'),
+}

package/packages/datadog-instrumentations/src/helpers/instrument.js

@@ -0,0 +1,57 @@
+'use strict'
+
+const { AsyncResource } = require('async_hooks')
+const dc = require('dc-polyfill')
+const instrumentations = require('./instrumentations')
+const rewriterInstrumentations = require('./rewriter/instrumentations')
+
+const channelMap = {}
+exports.channel = function (name) {
+  const maybe = channelMap[name]
+  if (maybe) return maybe
+  const ch = dc.channel(name)
+  channelMap[name] = ch
+  return ch
+}
+
+const tracingChannelMap = {}
+exports.tracingChannel = function (name) {
+  const maybe = tracingChannelMap[name]
+  if (maybe) return maybe
+  const tc = dc.tracingChannel(name)
+  tracingChannelMap[name] = tc
+  return tc
+}
+
+exports.getHooks = function getHooks (names) {
+  names = [names].flat()
+
+  return rewriterInstrumentations
+    .map(inst => inst.module)
+    .filter(({ name }) => names.includes(name))
+    .map(({ name, versionRange, filePath }) => ({ name, versions: [versionRange], file: filePath }))
+}
+
+/**
+ * @param {object} args
+ * @param {string|string[]} args.name module name
+ * @param {string[]} args.versions array of semver range strings
+ * @param {string} [args.file='index.js'] path to file within package to instrument
+ * @param {string} [args.filePattern] pattern to match files within package to instrument
+ * @param {boolean} [args.patchDefault] whether to patch the default export
+ * @param {(moduleExports: unknown, version: string) => unknown} hook
+ */
+exports.addHook = function addHook ({ name, versions, file, filePattern, patchDefault }, hook) {
+  if (typeof name === 'string') {
+    name = [name]
+  }
+
+  for (const val of name) {
+    if (!instrumentations[val]) {
+      instrumentations[val] = []
+    }
+    instrumentations[val].push({ name: val, versions, file, filePattern, hook, patchDefault })
+  }
+}
+
+exports.AsyncResource = AsyncResource

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

@@ -0,0 +1,8 @@
+'use strict'
+
+// Use a global symbol to prevent stealthy-require to interfere.
+// TODO: Use the symbol from dd-trace instead and remove this file.
+const sym = Symbol.for('_ddtrace_instrumentations')
+globalThis[sym] ??= {}
+
+module.exports = globalThis[sym]

package/packages/datadog-instrumentations/src/helpers/promise.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const { AsyncResource } = require('async_hooks')
+
+exports.wrapThen = function wrapThen (origThen) {
+  return function then (onFulfilled, onRejected, onProgress) {
+    const ar = new AsyncResource('bound-anonymous-fn')
+
+    arguments[0] = wrapCallback(ar, onFulfilled)
+    arguments[1] = wrapCallback(ar, onRejected)
+
+    // not standard but sometimes supported
+    if (onProgress) {
+      arguments[2] = wrapCallback(ar, onProgress)
+    }
+
+    return origThen.apply(this, arguments)
+  }
+}
+
+function wrapCallback (ar, callback) {
+  if (typeof callback !== 'function') return callback
+
+  return function () {
+    return ar.runInAsyncScope(() => {
+      return callback.apply(this, arguments)
+    })
+  }
+}